Skip to content

Commit 26d37b6

Browse files
natecook1000natecook1000
committed
Stop masquerading as XCTest
1 parent 875a810 commit 26d37b6

23 files changed

+261
-261
lines changed

‎Tests/SwiftAlgorithmsTests/AdjacentPairsTests.swift

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -15,57 +15,57 @@ import XCTest
1515
final class AdjacentPairsTests: XCTestCase {
1616
func testEmptySequence() {
1717
let pairs = (0...).prefix(0).adjacentPairs()
18-
XCTAssertEqualSequences(pairs, [], by: ==)
18+
expectEqualSequences(pairs, [], by: ==)
1919
}
2020

2121
func testOneElementSequence() {
2222
let pairs = (0...).prefix(1).adjacentPairs()
23-
XCTAssertEqualSequences(pairs, [], by: ==)
23+
expectEqualSequences(pairs, [], by: ==)
2424
}
2525

2626
func testTwoElementSequence() {
2727
let pairs = (0...).prefix(2).adjacentPairs()
28-
XCTAssertEqualSequences(pairs, [(0, 1)], by: ==)
28+
expectEqualSequences(pairs, [(0, 1)], by: ==)
2929
}
3030

3131
func testThreeElementSequence() {
3232
let pairs = (0...).prefix(3).adjacentPairs()
33-
XCTAssertEqualSequences(pairs, [(0, 1), (1, 2)], by: ==)
33+
expectEqualSequences(pairs, [(0, 1), (1, 2)], by: ==)
3434
}
3535

3636
func testManySequences() {
3737
for n in 4...100 {
3838
let pairs = (0...).prefix(n).adjacentPairs()
39-
XCTAssertEqualSequences(pairs, zip(0..., 1...).prefix(n - 1), by: ==)
39+
expectEqualSequences(pairs, zip(0..., 1...).prefix(n - 1), by: ==)
4040
}
4141
}
4242

4343
func testZeroElements() {
4444
let pairs = (0..<0).adjacentPairs()
4545
XCTAssertEqual(pairs.startIndex, pairs.endIndex)
46-
XCTAssertEqualSequences(pairs, [], by: ==)
46+
expectEqualSequences(pairs, [], by: ==)
4747
}
4848

4949
func testOneElement() {
5050
let pairs = (0..<1).adjacentPairs()
5151
XCTAssertEqual(pairs.startIndex, pairs.endIndex)
52-
XCTAssertEqualSequences(pairs, [], by: ==)
52+
expectEqualSequences(pairs, [], by: ==)
5353
}
5454

5555
func testTwoElements() {
5656
let pairs = (0..<2).adjacentPairs()
57-
XCTAssertEqualSequences(pairs, [(0, 1)], by: ==)
57+
expectEqualSequences(pairs, [(0, 1)], by: ==)
5858
}
5959

6060
func testThreeElements() {
6161
let pairs = (0..<3).adjacentPairs()
62-
XCTAssertEqualSequences(pairs, [(0, 1), (1, 2)], by: ==)
62+
expectEqualSequences(pairs, [(0, 1), (1, 2)], by: ==)
6363
}
6464

6565
func testManyElements() {
6666
for n in 4...100 {
6767
let pairs = (0..<n).adjacentPairs()
68-
XCTAssertEqualSequences(pairs, zip(0..., 1...).prefix(n - 1), by: ==)
68+
expectEqualSequences(pairs, zip(0..., 1...).prefix(n - 1), by: ==)
6969
}
7070
}
7171

@@ -78,7 +78,7 @@ final class AdjacentPairsTests: XCTestCase {
7878
}
7979

8080
func testLaziness() {
81-
XCTAssertLazySequence((0...).lazy.adjacentPairs())
82-
XCTAssertLazyCollection((0..<100).lazy.adjacentPairs())
81+
requireLazySequence((0...).lazy.adjacentPairs())
82+
requireLazyCollection((0..<100).lazy.adjacentPairs())
8383
}
8484
}

‎Tests/SwiftAlgorithmsTests/ChainTests.swift

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -16,24 +16,24 @@ import XCTest
1616
final class ChainTests: XCTestCase {
1717
func testChainSequences() {
1818
let run = chain((1...).prefix(10), 20...)
19-
XCTAssertEqualSequences(run.prefix(20), Array(1...10) + (20..<30))
19+
expectEqualSequences(run.prefix(20), Array(1...10) + (20..<30))
2020
}
2121

2222
func testChainForwardCollection() {
2323
let s1 = Set(0...10)
2424
let s2 = Set(20...30)
2525
let c = chain(s1, s2)
26-
XCTAssertEqualSequences(c, Array(s1) + Array(s2))
26+
expectEqualSequences(c, Array(s1) + Array(s2))
2727
}
2828

2929
func testChainBidirectionalCollection() {
3030
let s1 = "ABCDEFGHIJ"
3131
let s2 = "klmnopqrstuv"
3232
let c = chain(s1, s2)
3333

34-
XCTAssertEqualSequences(c, "ABCDEFGHIJklmnopqrstuv")
35-
XCTAssertEqualSequences(c.reversed(), "ABCDEFGHIJklmnopqrstuv".reversed())
36-
XCTAssertEqualSequences(chain(s1.reversed(), s2), "JIHGFEDCBAklmnopqrstuv")
34+
expectEqualSequences(c, "ABCDEFGHIJklmnopqrstuv")
35+
expectEqualSequences(c.reversed(), "ABCDEFGHIJklmnopqrstuv".reversed())
36+
expectEqualSequences(chain(s1.reversed(), s2), "JIHGFEDCBAklmnopqrstuv")
3737
}
3838

3939
func testChainIndexTraversals() {

‎Tests/SwiftAlgorithmsTests/ChunkedTests.swift

Lines changed: 23 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -33,7 +33,7 @@ final class ChunkedTests: XCTestCase {
3333
fruits[18..<19],
3434
fruits[19..<22],
3535
]
36-
XCTAssertEqualSequences(expectedChunks, fruitChunks, by: ==)
36+
expectEqualSequences(expectedChunks, fruitChunks, by: ==)
3737

3838
XCTAssertEqual(fruits[19..<22], fruitChunks.last)
3939

@@ -53,7 +53,7 @@ final class ChunkedTests: XCTestCase {
5353
("K", ["Kyle", "Karoy"]),
5454
("N", ["Nate"]),
5555
]
56-
XCTAssertEqualSequences(expected, chunks, by: ==)
56+
expectEqualSequences(expected, chunks, by: ==)
5757

5858
// Empty sequence
5959
XCTAssertEqual(0, names.prefix(0).chunked(on: { $0.first }).count)
@@ -80,72 +80,72 @@ final class ChunkedTests: XCTestCase {
8080
}
8181

8282
func testChunkedByComparesConsecutiveElements() {
83-
XCTAssertEqualSequences(
83+
expectEqualSequences(
8484
[1, 2, 3, 4, 6, 7, 8, 9].chunked(by: { $1 - $0 == 1 }),
8585
[[1, 2, 3, 4], [6, 7, 8, 9]])
8686

87-
XCTAssertEqualSequences(
87+
expectEqualSequences(
8888
[1, 2, 3, 4, 6, 7, 8, 9].lazy.chunked(by: { $1 - $0 == 1 }),
8989
[[1, 2, 3, 4], [6, 7, 8, 9]])
9090

91-
XCTAssertEqualSequences(
91+
expectEqualSequences(
9292
[1, 2, 3, 4, 6, 7, 8, 9].lazy.chunked(by: { $1 - $0 == 1 }).reversed(),
9393
[[6, 7, 8, 9], [1, 2, 3, 4]])
9494

9595
IndexValidator().validate([1, 2, 3].lazy.chunked(by: { $1 - $0 == 1 }))
9696
}
9797

9898
func testChunkedLazy() {
99-
XCTAssertLazySequence(fruits.lazy.chunked(by: { $0.first == $1.first }))
100-
XCTAssertLazySequence(fruits.lazy.chunked(on: { $0.first }))
99+
requireLazySequence(fruits.lazy.chunked(by: { $0.first == $1.first }))
100+
requireLazySequence(fruits.lazy.chunked(on: { $0.first }))
101101
}
102102

103103
//===----------------------------------------------------------------------===//
104104
// Tests for `chunks(ofCount:)`
105105
//===----------------------------------------------------------------------===//
106106

107107
func testChunksOfCount() {
108-
XCTAssertEqualSequences([Int]().chunks(ofCount: 1), [])
109-
XCTAssertEqualSequences([Int]().chunks(ofCount: 5), [])
108+
expectEqualSequences([Int]().chunks(ofCount: 1), [])
109+
expectEqualSequences([Int]().chunks(ofCount: 5), [])
110110

111111
let collection1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
112-
XCTAssertEqualSequences(
112+
expectEqualSequences(
113113
collection1.chunks(ofCount: 1),
114114
[[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]])
115-
XCTAssertEqualSequences(
115+
expectEqualSequences(
116116
collection1.chunks(ofCount: 3),
117117
[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]])
118-
XCTAssertEqualSequences(
118+
expectEqualSequences(
119119
collection1.chunks(ofCount: 5),
120120
[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
121-
XCTAssertEqualSequences(
121+
expectEqualSequences(
122122
collection1.chunks(ofCount: 11),
123123
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]])
124124

125125
let collection2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
126-
XCTAssertEqualSequences(
126+
expectEqualSequences(
127127
collection2.chunks(ofCount: 3),
128128
[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11]])
129129
}
130130

131131
func testChunksOfCountBidirectional() {
132132
let collection1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
133133

134-
XCTAssertEqualSequences(
134+
expectEqualSequences(
135135
collection1.chunks(ofCount: 1).reversed(),
136136
[[10], [9], [8], [7], [6], [5], [4], [3], [2], [1]])
137-
XCTAssertEqualSequences(
137+
expectEqualSequences(
138138
collection1.chunks(ofCount: 3).reversed(),
139139
[[10], [7, 8, 9], [4, 5, 6], [1, 2, 3]])
140-
XCTAssertEqualSequences(
140+
expectEqualSequences(
141141
collection1.chunks(ofCount: 5).reversed(),
142142
[[6, 7, 8, 9, 10], [1, 2, 3, 4, 5]])
143-
XCTAssertEqualSequences(
143+
expectEqualSequences(
144144
collection1.chunks(ofCount: 11).reversed(),
145145
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]])
146146

147147
let collection2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
148-
XCTAssertEqualSequences(
148+
expectEqualSequences(
149149
collection2.chunks(ofCount: 3).reversed(),
150150
[[10, 11], [7, 8, 9], [4, 5, 6], [1, 2, 3]])
151151
}
@@ -183,19 +183,19 @@ final class ChunkedTests: XCTestCase {
183183
}
184184

185185
func testEvenChunks() {
186-
XCTAssertEqualSequences(
186+
expectEqualSequences(
187187
(0..<10).evenlyChunked(in: 4),
188188
[0..<3, 3..<6, 6..<8, 8..<10])
189189

190-
XCTAssertEqualSequences(
190+
expectEqualSequences(
191191
(0..<3).evenlyChunked(in: 5),
192192
[0..<1, 1..<2, 2..<3, 3..<3, 3..<3])
193193

194-
XCTAssertEqualSequences(
194+
expectEqualSequences(
195195
"".evenlyChunked(in: 0),
196196
[])
197197

198-
XCTAssertEqualSequences(
198+
expectEqualSequences(
199199
"".evenlyChunked(in: 1),
200200
[""])
201201
}

‎Tests/SwiftAlgorithmsTests/CombinationsTests.swift

Lines changed: 13 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -132,23 +132,23 @@ final class CombinationsTests: XCTestCase {
132132

133133
func testEmpty() {
134134
// `k == 0` results in one zero-length combination
135-
XCTAssertEqualSequences([[]], "".combinations(ofCount: 0))
136-
XCTAssertEqualSequences([[]], "".combinations(ofCount: 0...0))
137-
XCTAssertEqualSequences([[]], "ABCD".combinations(ofCount: 0))
138-
XCTAssertEqualSequences([[]], "ABCD".combinations(ofCount: 0...0))
135+
expectEqualSequences([[]], "".combinations(ofCount: 0))
136+
expectEqualSequences([[]], "".combinations(ofCount: 0...0))
137+
expectEqualSequences([[]], "ABCD".combinations(ofCount: 0))
138+
expectEqualSequences([[]], "ABCD".combinations(ofCount: 0...0))
139139

140140
// `k` greater than element count results in zero combinations
141-
XCTAssertEqualSequences([], "".combinations(ofCount: 5))
142-
XCTAssertEqualSequences([], "".combinations(ofCount: 5...10))
143-
XCTAssertEqualSequences([], "ABCD".combinations(ofCount: 5))
144-
XCTAssertEqualSequences([], "ABCD".combinations(ofCount: 5...10))
141+
expectEqualSequences([], "".combinations(ofCount: 5))
142+
expectEqualSequences([], "".combinations(ofCount: 5...10))
143+
expectEqualSequences([], "ABCD".combinations(ofCount: 5))
144+
expectEqualSequences([], "ABCD".combinations(ofCount: 5...10))
145145
}
146146

147147
func testCombinationsLazy() {
148-
XCTAssertLazySequence("ABC".lazy.combinations(ofCount: 1))
149-
XCTAssertLazySequence("ABC".lazy.combinations(ofCount: 1...3))
150-
XCTAssertLazySequence("ABC".lazy.combinations(ofCount: 1...))
151-
XCTAssertLazySequence("ABC".lazy.combinations(ofCount: ...3))
152-
XCTAssertLazySequence("ABC".lazy.combinations(ofCount: 0...))
148+
requireLazySequence("ABC".lazy.combinations(ofCount: 1))
149+
requireLazySequence("ABC".lazy.combinations(ofCount: 1...3))
150+
requireLazySequence("ABC".lazy.combinations(ofCount: 1...))
151+
requireLazySequence("ABC".lazy.combinations(ofCount: ...3))
152+
requireLazySequence("ABC".lazy.combinations(ofCount: 0...))
153153
}
154154
}

‎Tests/SwiftAlgorithmsTests/CompactedTests.swift

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -22,16 +22,16 @@ final class CompactedTests: XCTestCase {
2222
func testCompactedCompacted() {
2323
for collection in self.tests {
2424
let seq = AnySequence(collection)
25-
XCTAssertEqualSequences(
25+
expectEqualSequences(
2626
seq.compactMap({ $0 }), seq.compacted())
27-
XCTAssertEqualSequences(
27+
expectEqualSequences(
2828
collection.compactMap({ $0 }), collection.compacted())
2929
}
3030
}
3131

3232
func testCompactedBidirectionalCollection() {
3333
for array in self.tests {
34-
XCTAssertEqualSequences(
34+
expectEqualSequences(
3535
array.compactMap({ $0 }).reversed(),
3636
array.compacted().reversed())
3737
}

‎Tests/SwiftAlgorithmsTests/CycleTests.swift

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ import XCTest
1515
final class CycleTests: XCTestCase {
1616
func testCycle() {
1717
let cycle = (1...4).cycled()
18-
XCTAssertEqualSequences(
18+
expectEqualSequences(
1919
[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4],
2020
cycle.prefix(20)
2121
)
@@ -32,12 +32,12 @@ final class CycleTests: XCTestCase {
3232
}
3333

3434
func testCycleLazy() {
35-
XCTAssertLazySequence((1...4).lazy.cycled())
35+
requireLazySequence((1...4).lazy.cycled())
3636
}
3737

3838
func testRepeated() {
3939
let repeats = (1...4).cycled(times: 3)
40-
XCTAssertEqualSequences(
40+
expectEqualSequences(
4141
[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4],
4242
repeats)
4343
}
@@ -58,7 +58,7 @@ final class CycleTests: XCTestCase {
5858
}
5959

6060
func testRepeatedLazy() {
61-
XCTAssertLazySequence((1...4).lazy.cycled(times: 3))
61+
requireLazySequence((1...4).lazy.cycled(times: 3))
6262
}
6363

6464
func testRepeatedIndexMethods() {

‎Tests/SwiftAlgorithmsTests/IndexedTests.swift

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -29,6 +29,6 @@ final class IndexedTests: XCTestCase {
2929
}
3030

3131
func testIndexedLazy() {
32-
XCTAssertLazyCollection("ABCD".lazy.indexed())
32+
requireLazyCollection("ABCD".lazy.indexed())
3333
}
3434
}

0 commit comments

Comments
 (0)