Skip to content

Commit 2df5199

Browse files
bnbarhambnbarham
authored
Revert "Add tests for AttributedString Index Tracking preconditions (swiftlang#1326)" (swiftlang#1337)
This reverts commit 226ba0a.
1 parent 22cac91 commit 2df5199

File tree

2 files changed

+74
-162
lines changed

2 files changed

+74
-162
lines changed

‎Package.swift‎

Lines changed: 3 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -75,10 +75,6 @@ let wasiLibcCSettings: [CSetting] = [
7575
.define("_WASI_EMULATED_MMAN", .when(platforms: [.wasi])),
7676
]
7777

78-
let testOnlySwiftSettings: [SwiftSetting] = [
79-
.define("FOUNDATION_EXIT_TESTS", .when(platforms: [.macOS, .linux])) // The latest Windows toolchain does not yet have exit tests in swift-testing
80-
]
81-
8278
let package = Package(
8379
name: "swift-foundation",
8480
platforms: [.macOS("15"), .iOS("18"), .tvOS("18"), .watchOS("11")],
@@ -175,7 +171,7 @@ let package = Package(
175171
"LifetimeDependenceMutableAccessors",
176172
.when(platforms: [.macOS, .iOS, .watchOS, .tvOS, .linux])
177173
),
178-
] + availabilityMacros + featureSettings + testOnlySwiftSettings
174+
] + availabilityMacros + featureSettings
179175
),
180176

181177
// FoundationInternationalization
@@ -208,7 +204,7 @@ let package = Package(
208204
"TestSupport",
209205
"FoundationInternationalization",
210206
],
211-
swiftSettings: availabilityMacros + featureSettings + testOnlySwiftSettings
207+
swiftSettings: availabilityMacros + featureSettings
212208
),
213209

214210
// FoundationMacros
@@ -240,7 +236,7 @@ package.targets.append(contentsOf: [
240236
"FoundationMacros",
241237
"TestSupport"
242238
],
243-
swiftSettings: availabilityMacros + featureSettings + testOnlySwiftSettings
239+
swiftSettings: availabilityMacros + featureSettings
244240
)
245241
])
246242
#endif

‎Tests/FoundationEssentialsTests/AttributedString/AttributedStringIndexTrackingTests.swift‎

Lines changed: 71 additions & 155 deletions
Original file line numberDiff line numberDiff line change
@@ -10,286 +10,202 @@
1010
//
1111
//===----------------------------------------------------------------------===//
1212

13-
import Testing
14-
15-
#if canImport(FoundationEssentials)
16-
import FoundationEssentials
17-
#else
18-
import Foundation
13+
#if canImport(TestSupport)
14+
import TestSupport
1915
#endif
2016

21-
@Suite("AttributedString Index Tracking")
22-
private struct AttributedStringIndexTrackingTests {
23-
@Test
24-
func basics() throws {
17+
final class AttributedStringIndexTrackingTests: XCTestCase {
18+
func testBasic() throws {
2519
var text = AttributedString("ABC. Hello, world!")
2620
let original = text
27-
let helloRange = try #require(text.range(of: "Hello"))
28-
let worldRange = try #require(text.range(of: "world"))
21+
let helloRange = try XCTUnwrap(text.range(of: "Hello"))
22+
let worldRange = try XCTUnwrap(text.range(of: "world"))
2923

30-
let updatedRanges = try #require(text.transform(updating: [helloRange, worldRange]) {
24+
let updatedRanges = try XCTUnwrap(text.transform(updating: [helloRange, worldRange]) {
3125
$0.insert(AttributedString("Goodbye. "), at: $0.startIndex)
3226
})
3327

34-
#expect(updatedRanges.count == 2)
35-
#expect(text[updatedRanges[0]] == original[helloRange])
36-
#expect(text[updatedRanges[1]] == original[worldRange])
28+
XCTAssertEqual(updatedRanges.count, 2)
29+
XCTAssertEqual(text[updatedRanges[0]], original[helloRange])
30+
XCTAssertEqual(text[updatedRanges[1]], original[worldRange])
3731
}
3832

39-
@Test
40-
func insertionWithinRange() throws {
33+
func testInsertionWithinRange() throws {
4134
var text = AttributedString("Hello, world")
42-
var helloRange = try #require(text.range(of: "Hello"))
35+
var helloRange = try XCTUnwrap(text.range(of: "Hello"))
4336

4437
text.transform(updating: &helloRange) {
4538
$0.insert(AttributedString("_Goodbye_"), at: $0.index($0.startIndex, offsetByCharacters: 3))
4639
}
4740

48-
#expect(String(text[helloRange].characters) == "Hel_Goodbye_lo")
41+
XCTAssertEqual(String(text[helloRange].characters), "Hel_Goodbye_lo")
4942
}
5043

51-
@Test
52-
func insertionAtStartOfRange() throws {
44+
func testInsertionAtStartOfRange() throws {
5345
var text = AttributedString("Hello, world")
54-
let helloRange = try #require(text.range(of: "llo"))
46+
let helloRange = try XCTUnwrap(text.range(of: "llo"))
5547

56-
let updatedHelloRange = try #require(text.transform(updating: helloRange) {
48+
let updatedHelloRange = try XCTUnwrap(text.transform(updating: helloRange) {
5749
$0.insert(AttributedString("_"), at: helloRange.lowerBound)
5850
})
5951

60-
#expect(String(text[updatedHelloRange].characters) == "llo")
52+
XCTAssertEqual(String(text[updatedHelloRange].characters), "llo")
6153
}
6254

63-
@Test
64-
func insertionAtEndOfRange() throws {
55+
func testInsertionAtEndOfRange() throws {
6556
var text = AttributedString("Hello, world")
66-
let helloRange = try #require(text.range(of: "llo"))
57+
let helloRange = try XCTUnwrap(text.range(of: "llo"))
6758

68-
let updatedHelloRange = try #require(text.transform(updating: helloRange) {
59+
let updatedHelloRange = try XCTUnwrap(text.transform(updating: helloRange) {
6960
$0.insert(AttributedString("_"), at: helloRange.upperBound)
7061
})
7162

72-
#expect(String(text[updatedHelloRange].characters) == "llo")
63+
XCTAssertEqual(String(text[updatedHelloRange].characters), "llo")
7364
}
7465

75-
@Test
76-
func insertionAtEmptyRange() throws {
66+
func testInsertionAtEmptyRange() throws {
7767
var text = AttributedString("ABCDE")
7868
let idx = text.index(text.startIndex, offsetByCharacters: 3)
7969

80-
let updatedRange = try #require(text.transform(updating: idx ..< idx) {
70+
let updatedRange = try XCTUnwrap(text.transform(updating: idx ..< idx) {
8171
$0.insert(AttributedString("_"), at: idx)
8272
})
8373

84-
#expect(updatedRange.lowerBound == updatedRange.upperBound)
85-
#expect(text.characters[updatedRange.lowerBound] == "D")
74+
XCTAssertEqual(updatedRange.lowerBound, updatedRange.upperBound)
75+
XCTAssertEqual(text.characters[updatedRange.lowerBound], "D")
8676
}
8777

88-
@Test
89-
func removalWithinRange() throws {
78+
func testRemovalWithinRange() throws {
9079
var text = AttributedString("Hello, world")
91-
var helloRange = try #require(text.range(of: "Hello"))
80+
var helloRange = try XCTUnwrap(text.range(of: "Hello"))
9281

9382
try text.transform(updating: &helloRange) {
94-
$0.removeSubrange(try #require($0.range(of: "ll")))
83+
$0.removeSubrange(try XCTUnwrap($0.range(of: "ll")))
9584
}
9685

97-
#expect(String(text[helloRange].characters) == "Heo")
86+
XCTAssertEqual(String(text[helloRange].characters), "Heo")
9887
}
9988

100-
@Test
101-
func fullCollapse() throws {
89+
func testFullCollapse() throws {
10290
do {
10391
var text = AttributedString("Hello, world")
104-
var helloRange = try #require(text.range(of: "Hello"))
92+
var helloRange = try XCTUnwrap(text.range(of: "Hello"))
10593

10694
text.transform(updating: &helloRange) {
10795
$0.removeSubrange($0.startIndex ..< $0.endIndex)
10896
}
10997

110-
#expect(String(text[helloRange].characters) == "")
98+
XCTAssertEqual(String(text[helloRange].characters), "")
11199
}
112100

113101
do {
114102
var text = AttributedString("Hello, world")
115-
let helloRange = try #require(text.range(of: "Hello"))
103+
let helloRange = try XCTUnwrap(text.range(of: "Hello"))
116104

117-
let updatedHelloRange = try #require(text.transform(updating: helloRange) {
105+
let updatedHelloRange = try XCTUnwrap(text.transform(updating: helloRange) {
118106
$0.removeSubrange(helloRange)
119107
})
120108

121-
#expect(String(text[updatedHelloRange].characters) == "")
109+
XCTAssertEqual(String(text[updatedHelloRange].characters), "")
122110
}
123111

124112
do {
125113
var text = AttributedString("Hello, world")
126-
var helloRange = try #require(text.range(of: ", "))
114+
var helloRange = try XCTUnwrap(text.range(of: ", "))
127115

128116
try text.transform(updating: &helloRange) {
129-
$0.removeSubrange(try #require($0.range(of: "o, w")))
117+
$0.removeSubrange(try XCTUnwrap($0.range(of: "o, w")))
130118
}
131119

132-
#expect(String(text[helloRange].characters) == "")
120+
XCTAssertEqual(String(text[helloRange].characters), "")
133121
let collapsedIdx = text.index(text.startIndex, offsetByCharacters: 4)
134-
#expect(helloRange == collapsedIdx ..< collapsedIdx)
122+
XCTAssertEqual(helloRange, collapsedIdx ..< collapsedIdx)
135123
}
136124
}
137125

138-
@Test
139-
func collapseLeft() throws {
126+
func testCollapseLeft() throws {
140127
var text = AttributedString("Hello, world")
141-
var helloRange = try #require(text.range(of: "Hello"))
128+
var helloRange = try XCTUnwrap(text.range(of: "Hello"))
142129

143130
try text.transform(updating: &helloRange) {
144-
$0.removeSubrange(try #require($0.range(of: "llo, wo")))
131+
$0.removeSubrange(try XCTUnwrap($0.range(of: "llo, wo")))
145132
}
146133

147-
#expect(String(text[helloRange].characters) == "He")
134+
XCTAssertEqual(String(text[helloRange].characters), "He")
148135
}
149136

150-
@Test
151-
func collapseRight() throws {
137+
func testCollapseRight() throws {
152138
var text = AttributedString("Hello, world")
153-
var worldRange = try #require(text.range(of: "world"))
139+
var worldRange = try XCTUnwrap(text.range(of: "world"))
154140

155141
try text.transform(updating: &worldRange) {
156-
$0.removeSubrange(try #require($0.range(of: "llo, wo")))
142+
$0.removeSubrange(try XCTUnwrap($0.range(of: "llo, wo")))
157143
}
158144

159-
#expect(String(text[worldRange].characters) == "rld")
145+
XCTAssertEqual(String(text[worldRange].characters), "rld")
160146
}
161147

162-
@Test
163-
func nesting() throws {
148+
func testNesting() throws {
164149
var text = AttributedString("Hello, world")
165-
var helloRange = try #require(text.range(of: "Hello"))
150+
var helloRange = try XCTUnwrap(text.range(of: "Hello"))
166151
try text.transform(updating: &helloRange) {
167-
var worldRange = try #require($0.range(of: "world"))
152+
var worldRange = try XCTUnwrap($0.range(of: "world"))
168153
try $0.transform(updating: &worldRange) {
169-
$0.removeSubrange(try #require($0.range(of: "llo, wo")))
154+
$0.removeSubrange(try XCTUnwrap($0.range(of: "llo, wo")))
170155
}
171-
#expect(String($0[worldRange].characters) == "rld")
156+
XCTAssertEqual(String($0[worldRange].characters), "rld")
172157
}
173-
#expect(String(text[helloRange].characters) == "He")
158+
XCTAssertEqual(String(text[helloRange].characters), "He")
174159
}
175160

176-
#if FOUNDATION_EXIT_TESTS
177-
@Test
178-
func trackingLostPreconditions() async {
179-
await #expect(processExitsWith: .failure) {
180-
var text = AttributedString("Hello, world")
181-
var helloRange = try #require(text.range(of: "Hello"))
182-
text.transform(updating: &helloRange) {
183-
$0 = AttributedString("Foo")
184-
}
185-
}
186-
187-
await #expect(processExitsWith: .failure) {
188-
var text = AttributedString("Hello, world")
189-
var helloRange = try #require(text.range(of: "Hello"))
190-
text.transform(updating: &helloRange) {
191-
$0 = AttributedString("Hello world")
192-
}
193-
}
194-
195-
await #expect(processExitsWith: .failure) {
196-
var text = AttributedString("Hello, world")
197-
var ranges = [try #require(text.range(of: "Hello"))]
198-
text.transform(updating: &ranges) {
199-
$0 = AttributedString("Foo")
200-
}
201-
}
202-
203-
await #expect(processExitsWith: .failure) {
204-
var text = AttributedString("Hello, world")
205-
var ranges = [try #require(text.range(of: "Hello"))]
206-
text.transform(updating: &ranges) {
207-
$0 = AttributedString("Hello world")
208-
}
209-
}
210-
}
211-
#endif
212-
213-
@Test
214-
func trackingLost() throws {
161+
func testTrackingLost() throws {
215162
let text = AttributedString("Hello, world")
216-
let helloRange = try #require(text.range(of: "Hello"))
163+
let helloRange = try XCTUnwrap(text.range(of: "Hello"))
217164

218165
do {
219166
var copy = text
220-
#expect(copy.transform(updating: helloRange) {
167+
XCTAssertNil(copy.transform(updating: helloRange) {
221168
$0 = AttributedString("Foo")
222-
} == nil)
169+
})
223170
}
224171

225172
do {
226173
var copy = text
227-
#expect(copy.transform(updating: helloRange) {
174+
XCTAssertNil(copy.transform(updating: helloRange) {
228175
$0 = AttributedString("Hello world")
229-
} == nil)
176+
})
230177
}
231178

232179
do {
233180
var copy = text
234-
#expect(copy.transform(updating: helloRange) {
181+
XCTAssertNotNil(copy.transform(updating: helloRange) {
235182
$0 = $0
236-
} != nil)
183+
})
237184
}
238185

239186
do {
240187
var copy = text
241-
#expect(copy.transform(updating: helloRange) {
188+
XCTAssertNotNil(copy.transform(updating: helloRange) {
242189
var reference = $0
243190
reference.testInt = 2
244191
$0 = $0
245-
} != nil)
246-
#expect(copy.testInt == nil)
192+
})
193+
XCTAssertNil(copy.testInt)
247194
}
248195
}
249196

250-
@Test
251-
func attributeMutation() throws {
197+
func testAttributeMutation() throws {
252198
var text = AttributedString("Hello, world!")
253199
let original = text
254-
let helloRange = try #require(text.range(of: "Hello"))
255-
let worldRange = try #require(text.range(of: "world"))
200+
let helloRange = try XCTUnwrap(text.range(of: "Hello"))
201+
let worldRange = try XCTUnwrap(text.range(of: "world"))
256202

257-
let updatedRanges = try #require(text.transform(updating: [helloRange, worldRange]) {
203+
let updatedRanges = try XCTUnwrap(text.transform(updating: [helloRange, worldRange]) {
258204
$0.testInt = 2
259205
})
260206

261-
#expect(updatedRanges.count == 2)
262-
#expect(AttributedString(text[updatedRanges[0]]) == original[helloRange].settingAttributes(AttributeContainer.testInt(2)))
263-
#expect(AttributedString(text[updatedRanges[1]]) == original[worldRange].settingAttributes(AttributeContainer.testInt(2)))
264-
}
265-
266-
#if FOUNDATION_EXIT_TESTS
267-
@Test
268-
func invalidInputRanges() async {
269-
await #expect(processExitsWith: .failure) {
270-
var text = AttributedString("Hello, world")
271-
let other = text + AttributedString("Extra text")
272-
let range = other.startIndex ..< other.endIndex
273-
_ = text.transform(updating: range) { _ in
274-
275-
}
276-
}
277-
278-
await #expect(processExitsWith: .failure) {
279-
var text = AttributedString("Hello, world")
280-
let other = text + AttributedString("Extra text")
281-
let range = other.endIndex ..< other.endIndex
282-
_ = text.transform(updating: range) { _ in
283-
284-
}
285-
}
286-
287-
await #expect(processExitsWith: .failure) {
288-
var text = AttributedString("Hello, world")
289-
_ = text.transform(updating: []) { _ in
290-
291-
}
292-
}
207+
XCTAssertEqual(updatedRanges.count, 2)
208+
XCTAssertEqual(AttributedString(text[updatedRanges[0]]), original[helloRange].settingAttributes(AttributeContainer.testInt(2)))
209+
XCTAssertEqual(AttributedString(text[updatedRanges[1]]), original[worldRange].settingAttributes(AttributeContainer.testInt(2)))
293210
}
294-
#endif
295211
}

0 commit comments

Comments
 (0)