Skip to content

Commit 80fd04c

Browse files
fabianfettfabianfett
committed
More tests
1 parent c0c36c4 commit 80fd04c

File tree

2 files changed

+122
-102
lines changed

2 files changed

+122
-102
lines changed

‎Tests/ConnectionPoolModuleTests/PoolStateMachine+ConnectionStateTests.swift‎

Lines changed: 55 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -56,7 +56,8 @@ import Testing
5656
#expect(state.lease(streams: 1) == expectLeaseAction)
5757
}
5858

59-
func testStartupParkLeaseBeforeTimersRegistered() {
59+
@available(macOS 13.0, iOS 16.0, tvOS 16.0, watchOS 9.0, *)
60+
@Test func testStartupParkLeaseBeforeTimersRegistered() {
6061
let connectionID = 1
6162
var state = TestConnectionState(id: connectionID)
6263
let connection = MockConnection(id: connectionID)
@@ -83,7 +84,8 @@ import Testing
8384
#expect(state.timerScheduled(idleTimer, cancelContinuation: idleTimerCancellationToken) == idleTimerCancellationToken)
8485
}
8586

86-
func testStartupParkLeasePark() {
87+
@available(macOS 13.0, iOS 16.0, tvOS 16.0, watchOS 9.0, *)
88+
@Test func testStartupParkLeasePark() {
8789
let connectionID = 1
8890
var state = TestConnectionState(id: connectionID)
8991
let connection = MockConnection(id: connectionID)
@@ -118,7 +120,8 @@ import Testing
118120
#expect(state.timerScheduled(idleTimer, cancelContinuation: initialIdleTimerCancellationToken) == initialIdleTimerCancellationToken)
119121
}
120122

121-
func testStartupFailed() {
123+
@available(macOS 13.0, iOS 16.0, tvOS 16.0, watchOS 9.0, *)
124+
@Test func testStartupFailed() {
122125
let connectionID = 1
123126
var state = TestConnectionState(id: connectionID)
124127
let firstBackoffTimer = state.failedToConnect()
@@ -152,13 +155,17 @@ import Testing
152155
#expect(state.connected(connection, maxStreams: 1) == .idle(availableStreams: 1, newIdle: true))
153156
}
154157

155-
func testLeaseMultipleStreams() {
158+
@available(macOS 13.0, iOS 16.0, tvOS 16.0, watchOS 9.0, *)
159+
@Test func testLeaseMultipleStreams() {
156160
let connectionID = 1
157161
var state = TestConnectionState(id: connectionID)
158162
let connection = MockConnection(id: connectionID)
159163
#expect(state.connected(connection, maxStreams: 100) == .idle(availableStreams: 100, newIdle: true))
160164
let timers = state.parkConnection(scheduleKeepAliveTimer: true, scheduleIdleTimeoutTimer: false)
161-
guard let keepAliveTimer = timers.first else { return XCTFail("Expected to get a keepAliveTimer") }
165+
guard let keepAliveTimer = timers.first else {
166+
Issue.record("Expected to get a keepAliveTimer")
167+
return
168+
}
162169

163170
let keepAliveTimerCancellationToken = MockTimerCancellationToken(keepAliveTimer)
164171
#expect(state.timerScheduled(keepAliveTimer, cancelContinuation: keepAliveTimerCancellationToken) == nil)
@@ -185,84 +192,93 @@ import Testing
185192
#expect(state.release(streams: 1) == .idle(availableStreams: 100, newIdle: true))
186193
}
187194

188-
func testRunningKeepAliveReducesAvailableStreams() {
195+
@available(macOS 13.0, iOS 16.0, tvOS 16.0, watchOS 9.0, *)
196+
@Test func testRunningKeepAliveReducesAvailableStreams() {
189197
let connectionID = 1
190198
var state = TestConnectionState(id: connectionID)
191199
let connection = MockConnection(id: connectionID)
192200
#expect(state.connected(connection, maxStreams: 100) == .idle(availableStreams: 100, newIdle: true))
193201
let timers = state.parkConnection(scheduleKeepAliveTimer: true, scheduleIdleTimeoutTimer: false)
194-
guard let keepAliveTimer = timers.first else { return XCTFail("Expected to get a keepAliveTimer") }
202+
guard let keepAliveTimer = timers.first else {
203+
Issue.record("Expected to get a keepAliveTimer")
204+
return
205+
}
195206

196207
let keepAliveTimerCancellationToken = MockTimerCancellationToken(keepAliveTimer)
197-
XCTAssertNil(state.timerScheduled(keepAliveTimer, cancelContinuation: keepAliveTimerCancellationToken))
208+
#expect(state.timerScheduled(keepAliveTimer, cancelContinuation: keepAliveTimerCancellationToken) == nil)
198209

199-
XCTAssertEqual(
200-
state.runKeepAliveIfIdle(reducesAvailableStreams: true),
210+
#expect(
211+
state.runKeepAliveIfIdle(reducesAvailableStreams: true) ==
201212
.init(connection: connection, keepAliveTimerCancellationContinuation: keepAliveTimerCancellationToken)
202213
)
203214

204-
XCTAssertEqual(
205-
state.lease(streams: 30),
215+
#expect(
216+
state.lease(streams: 30) ==
206217
TestConnectionState.LeaseAction(connection: connection, timersToCancel: [], wasIdle: true)
207218
)
208219

209-
XCTAssertEqual(state.release(streams: 10), .leased(availableStreams: 79))
210-
XCTAssertEqual(state.isAvailable, true)
211-
XCTAssertEqual(
212-
state.lease(streams: 79),
220+
#expect(state.release(streams: 10) == .leased(availableStreams: 79))
221+
#expect(state.isAvailable)
222+
#expect(
223+
state.lease(streams: 79) ==
213224
TestConnectionState.LeaseAction(connection: connection, timersToCancel: [], wasIdle: false)
214225
)
215-
XCTAssertEqual(state.isAvailable, false)
216-
XCTAssertEqual(state.keepAliveSucceeded(), .leased(availableStreams: 1))
217-
XCTAssertEqual(state.isAvailable, true)
226+
#expect(!state.isAvailable)
227+
#expect(state.keepAliveSucceeded() == .leased(availableStreams: 1))
228+
#expect(state.isAvailable)
218229
}
219230

220-
func testRunningKeepAliveDoesNotReduceAvailableStreams() {
231+
@available(macOS 13.0, iOS 16.0, tvOS 16.0, watchOS 9.0, *)
232+
@Test func testRunningKeepAliveDoesNotReduceAvailableStreams() {
221233
let connectionID = 1
222234
var state = TestConnectionState(id: connectionID)
223235
let connection = MockConnection(id: connectionID)
224-
XCTAssertEqual(state.connected(connection, maxStreams: 100), .idle(availableStreams: 100, newIdle: true))
236+
#expect(state.connected(connection, maxStreams: 100) == .idle(availableStreams: 100, newIdle: true))
225237
let timers = state.parkConnection(scheduleKeepAliveTimer: true, scheduleIdleTimeoutTimer: false)
226-
guard let keepAliveTimer = timers.first else { return XCTFail("Expected to get a keepAliveTimer") }
238+
guard let keepAliveTimer = timers.first else {
239+
Issue.record("Expected to get a keepAliveTimer")
240+
return
241+
}
227242

228243
let keepAliveTimerCancellationToken = MockTimerCancellationToken(keepAliveTimer)
229-
XCTAssertNil(state.timerScheduled(keepAliveTimer, cancelContinuation: keepAliveTimerCancellationToken))
244+
#expect(state.timerScheduled(keepAliveTimer, cancelContinuation: keepAliveTimerCancellationToken) == nil)
230245

231-
XCTAssertEqual(
232-
state.runKeepAliveIfIdle(reducesAvailableStreams: false),
246+
#expect(
247+
state.runKeepAliveIfIdle(reducesAvailableStreams: false) ==
233248
.init(connection: connection, keepAliveTimerCancellationContinuation: keepAliveTimerCancellationToken)
234249
)
235250

236-
XCTAssertEqual(
237-
state.lease(streams: 30),
251+
#expect(
252+
state.lease(streams: 30) ==
238253
TestConnectionState.LeaseAction(connection: connection, timersToCancel: [], wasIdle: true)
239254
)
240255

241-
XCTAssertEqual(state.release(streams: 10), .leased(availableStreams: 80))
242-
XCTAssertEqual(state.keepAliveSucceeded(), .leased(availableStreams: 80))
256+
#expect(state.release(streams: 10) == .leased(availableStreams: 80))
257+
#expect(state.keepAliveSucceeded() == .leased(availableStreams: 80))
243258
}
244259

245-
func testRunKeepAliveRacesAgainstIdleClose() {
260+
@available(macOS 13.0, iOS 16.0, tvOS 16.0, watchOS 9.0, *)
261+
@Test func testRunKeepAliveRacesAgainstIdleClose() {
246262
let connectionID = 1
247263
var state = TestConnectionState(id: connectionID)
248264
let connection = MockConnection(id: connectionID)
249-
XCTAssertEqual(state.connected(connection, maxStreams: 1), .idle(availableStreams: 1, newIdle: true))
265+
#expect(state.connected(connection, maxStreams: 1) == .idle(availableStreams: 1, newIdle: true))
250266
let parkResult = state.parkConnection(scheduleKeepAliveTimer: true, scheduleIdleTimeoutTimer: true)
251267
guard let keepAliveTimer = parkResult.first, let idleTimer = parkResult.second else {
252-
return XCTFail("Expected to get two timers")
268+
Issue.record("Expected to get two timers")
269+
return
253270
}
254271

255-
XCTAssertEqual(keepAliveTimer, .init(timerID: 0, connectionID: connectionID, usecase: .keepAlive))
256-
XCTAssertEqual(idleTimer, .init(timerID: 1, connectionID: connectionID, usecase: .idleTimeout))
272+
#expect(keepAliveTimer == .init(timerID: 0, connectionID: connectionID, usecase: .keepAlive))
273+
#expect(idleTimer == .init(timerID: 1, connectionID: connectionID, usecase: .idleTimeout))
257274

258275
let keepAliveTimerCancellationToken = MockTimerCancellationToken(keepAliveTimer)
259276
let idleTimerCancellationToken = MockTimerCancellationToken(idleTimer)
260277

261-
XCTAssertNil(state.timerScheduled(keepAliveTimer, cancelContinuation: keepAliveTimerCancellationToken))
262-
XCTAssertNil(state.timerScheduled(idleTimer, cancelContinuation: idleTimerCancellationToken))
263-
264-
XCTAssertEqual(state.closeIfIdle(), .init(connection: connection, previousConnectionState: .idle, cancelTimers: [keepAliveTimerCancellationToken, idleTimerCancellationToken], usedStreams: 0, maxStreams: 1, runningKeepAlive: false))
265-
XCTAssertEqual(state.runKeepAliveIfIdle(reducesAvailableStreams: true), .none)
278+
#expect(state.timerScheduled(keepAliveTimer, cancelContinuation: keepAliveTimerCancellationToken) == nil)
279+
#expect(state.timerScheduled(idleTimer, cancelContinuation: idleTimerCancellationToken) == nil)
266280

281+
#expect(state.closeIfIdle() == .init(connection: connection, previousConnectionState: .idle, cancelTimers: [keepAliveTimerCancellationToken, idleTimerCancellationToken], usedStreams: 0, maxStreams: 1, runningKeepAlive: false))
282+
#expect(state.runKeepAliveIfIdle(reducesAvailableStreams: true) == .none)
267283
}
268284
}

‎Tests/ConnectionPoolModuleTests/PoolStateMachine+RequestQueueTests.swift‎

Lines changed: 67 additions & 63 deletions
Original file line numberDiff line numberDiff line change
@@ -1,29 +1,30 @@
11
@testable import _ConnectionPoolModule
22
import _ConnectionPoolTestUtils
3-
import XCTest
3+
import Testing
44

5-
@available(macOS 13.0, iOS 16.0, tvOS 16.0, watchOS 9.0, *)
6-
final class PoolStateMachine_RequestQueueTests: XCTestCase {
5+
@Suite struct PoolStateMachine_RequestQueueTests {
76

87
typealias TestQueue = TestPoolStateMachine.RequestQueue
98

10-
func testHappyPath() {
9+
@available(macOS 13.0, iOS 16.0, tvOS 16.0, watchOS 9.0, *)
10+
@Test func testHappyPath() {
1111
var queue = TestQueue()
12-
XCTAssert(queue.isEmpty)
12+
#expect(queue.isEmpty)
1313

1414
let request1 = MockRequest(connectionType: MockConnection.self)
1515
queue.queue(request1)
16-
XCTAssertEqual(queue.count, 1)
17-
XCTAssertFalse(queue.isEmpty)
16+
#expect(queue.count == 1)
17+
#expect(!queue.isEmpty)
1818
let popResult = queue.pop(max: 3)
19-
XCTAssert(popResult.elementsEqual([request1]))
20-
XCTAssert(queue.isEmpty)
21-
XCTAssertEqual(queue.count, 0)
19+
#expect(popResult.elementsEqual([request1]))
20+
#expect(queue.isEmpty)
21+
#expect(queue.count == 0)
2222
}
2323

24-
func testEnqueueAndPopMultipleRequests() {
24+
@available(macOS 13.0, iOS 16.0, tvOS 16.0, watchOS 9.0, *)
25+
@Test func testEnqueueAndPopMultipleRequests() {
2526
var queue = TestQueue()
26-
XCTAssert(queue.isEmpty)
27+
#expect(queue.isEmpty)
2728

2829
var request1 = MockRequest(connectionType: MockConnection.self)
2930
queue.queue(request1)
@@ -33,21 +34,22 @@ final class PoolStateMachine_RequestQueueTests: XCTestCase {
3334
queue.queue(request3)
3435

3536
do {
36-
XCTAssertEqual(queue.count, 3)
37-
XCTAssertFalse(queue.isEmpty)
37+
#expect(queue.count == 3)
38+
#expect(!queue.isEmpty)
3839
let popResult = queue.pop(max: 3)
39-
XCTAssert(popResult.elementsEqual([request1, request2, request3]))
40-
XCTAssert(queue.isEmpty)
41-
XCTAssertEqual(queue.count, 0)
40+
#expect(popResult.elementsEqual([request1, request2, request3]))
41+
#expect(queue.isEmpty)
42+
#expect(queue.count == 0)
4243
}
43-
XCTAssert(isKnownUniquelyReferenced(&request1))
44-
XCTAssert(isKnownUniquelyReferenced(&request2))
45-
XCTAssert(isKnownUniquelyReferenced(&request3))
44+
#expect(isKnownUniquelyReferenced(&request1))
45+
#expect(isKnownUniquelyReferenced(&request2))
46+
#expect(isKnownUniquelyReferenced(&request3))
4647
}
4748

48-
func testEnqueueAndPopOnlyOne() {
49+
@available(macOS 13.0, iOS 16.0, tvOS 16.0, watchOS 9.0, *)
50+
@Test func testEnqueueAndPopOnlyOne() {
4951
var queue = TestQueue()
50-
XCTAssert(queue.isEmpty)
52+
#expect(queue.isEmpty)
5153

5254
var request1 = MockRequest(connectionType: MockConnection.self)
5355
queue.queue(request1)
@@ -57,24 +59,25 @@ final class PoolStateMachine_RequestQueueTests: XCTestCase {
5759
queue.queue(request3)
5860

5961
do {
60-
XCTAssertEqual(queue.count, 3)
61-
XCTAssertFalse(queue.isEmpty)
62+
#expect(queue.count == 3)
63+
#expect(!queue.isEmpty)
6264
let popResult = queue.pop(max: 1)
63-
XCTAssert(popResult.elementsEqual([request1]))
64-
XCTAssertFalse(queue.isEmpty)
65-
XCTAssertEqual(queue.count, 2)
65+
#expect(popResult.elementsEqual([request1]))
66+
#expect(!queue.isEmpty)
67+
#expect(queue.count == 2)
6668

6769
let removeAllResult = queue.removeAll()
68-
XCTAssert(Set(removeAllResult) == [request2, request3])
70+
#expect(Set(removeAllResult) == [request2, request3])
6971
}
70-
XCTAssert(isKnownUniquelyReferenced(&request1))
71-
XCTAssert(isKnownUniquelyReferenced(&request2))
72-
XCTAssert(isKnownUniquelyReferenced(&request3))
72+
#expect(isKnownUniquelyReferenced(&request1))
73+
#expect(isKnownUniquelyReferenced(&request2))
74+
#expect(isKnownUniquelyReferenced(&request3))
7375
}
7476

75-
func testCancellation() {
77+
@available(macOS 13.0, iOS 16.0, tvOS 16.0, watchOS 9.0, *)
78+
@Test func testCancellation() {
7679
var queue = TestQueue()
77-
XCTAssert(queue.isEmpty)
80+
#expect(queue.isEmpty)
7881

7982
var request1 = MockRequest(connectionType: MockConnection.self)
8083
queue.queue(request1)
@@ -84,34 +87,35 @@ final class PoolStateMachine_RequestQueueTests: XCTestCase {
8487
queue.queue(request3)
8588

8689
do {
87-
XCTAssertEqual(queue.count, 3)
90+
#expect(queue.count == 3)
8891
let returnedRequest2 = queue.remove(request2.id)
89-
XCTAssert(returnedRequest2 === request2)
90-
XCTAssertEqual(queue.count, 2)
91-
XCTAssertFalse(queue.isEmpty)
92+
#expect(returnedRequest2 === request2)
93+
#expect(queue.count == 2)
94+
#expect(!queue.isEmpty)
9295
}
9396

9497
// still retained by the deque inside the queue
95-
XCTAssertEqual(queue.requests.count, 2)
96-
XCTAssertEqual(queue.queue.count, 3)
98+
#expect(queue.requests.count == 2)
99+
#expect(queue.queue.count == 3)
97100

98101
do {
99-
XCTAssertEqual(queue.count, 2)
100-
XCTAssertFalse(queue.isEmpty)
102+
#expect(queue.count == 2)
103+
#expect(!queue.isEmpty)
101104
let popResult = queue.pop(max: 3)
102-
XCTAssert(popResult.elementsEqual([request1, request3]))
103-
XCTAssert(queue.isEmpty)
104-
XCTAssertEqual(queue.count, 0)
105+
#expect(popResult.elementsEqual([request1, request3]))
106+
#expect(queue.isEmpty)
107+
#expect(queue.count == 0)
105108
}
106109

107-
XCTAssert(isKnownUniquelyReferenced(&request1))
108-
XCTAssert(isKnownUniquelyReferenced(&request2))
109-
XCTAssert(isKnownUniquelyReferenced(&request3))
110+
#expect(isKnownUniquelyReferenced(&request1))
111+
#expect(isKnownUniquelyReferenced(&request2))
112+
#expect(isKnownUniquelyReferenced(&request3))
110113
}
111114

112-
func testRemoveAllAfterCancellation() {
115+
@available(macOS 13.0, iOS 16.0, tvOS 16.0, watchOS 9.0, *)
116+
@Test func testRemoveAllAfterCancellation() {
113117
var queue = TestQueue()
114-
XCTAssert(queue.isEmpty)
118+
#expect(queue.isEmpty)
115119

116120
var request1 = MockRequest(connectionType: MockConnection.self)
117121
queue.queue(request1)
@@ -121,28 +125,28 @@ final class PoolStateMachine_RequestQueueTests: XCTestCase {
121125
queue.queue(request3)
122126

123127
do {
124-
XCTAssertEqual(queue.count, 3)
128+
#expect(queue.count == 3)
125129
let returnedRequest2 = queue.remove(request2.id)
126-
XCTAssert(returnedRequest2 === request2)
127-
XCTAssertEqual(queue.count, 2)
128-
XCTAssertFalse(queue.isEmpty)
130+
#expect(returnedRequest2 === request2)
131+
#expect(queue.count == 2)
132+
#expect(!queue.isEmpty)
129133
}
130134

131135
// still retained by the deque inside the queue
132-
XCTAssertEqual(queue.requests.count, 2)
133-
XCTAssertEqual(queue.queue.count, 3)
136+
#expect(queue.requests.count == 2)
137+
#expect(queue.queue.count == 3)
134138

135139
do {
136-
XCTAssertEqual(queue.count, 2)
137-
XCTAssertFalse(queue.isEmpty)
140+
#expect(queue.count == 2)
141+
#expect(!queue.isEmpty)
138142
let removeAllResult = queue.removeAll()
139-
XCTAssert(Set(removeAllResult) == [request1, request3])
140-
XCTAssert(queue.isEmpty)
141-
XCTAssertEqual(queue.count, 0)
143+
#expect(Set(removeAllResult) == [request1, request3])
144+
#expect(queue.isEmpty)
145+
#expect(queue.count == 0)
142146
}
143147

144-
XCTAssert(isKnownUniquelyReferenced(&request1))
145-
XCTAssert(isKnownUniquelyReferenced(&request2))
146-
XCTAssert(isKnownUniquelyReferenced(&request3))
148+
#expect(isKnownUniquelyReferenced(&request1))
149+
#expect(isKnownUniquelyReferenced(&request2))
150+
#expect(isKnownUniquelyReferenced(&request3))
147151
}
148152
}

0 commit comments

Comments
 (0)