Use swift-testing for ConnectionPoolTests

Author: fabianfett

Tests/ConnectionPoolModuleTests/ConnectionIDGeneratorTests.swift

@@ -1,13 +1,14 @@
 import _ConnectionPoolModule
-import XCTest
+import Testing
 
-final class ConnectionIDGeneratorTests: XCTestCase {
-    func testGenerateConnectionIDs() async {
+@Suite struct ConnectionIDGeneratorTests {
+
+    @Test func testGenerateConnectionIDs() async {
         let idGenerator = ConnectionIDGenerator()
 
-        XCTAssertEqual(idGenerator.next(), 0)
-        XCTAssertEqual(idGenerator.next(), 1)
-        XCTAssertEqual(idGenerator.next(), 2)
+        #expect(idGenerator.next() == 0)
+        #expect(idGenerator.next() == 1)
+        #expect(idGenerator.next() == 2)
 
         await withTaskGroup(of: Void.self) { taskGroup in
             for _ in 0..<1000 {
@@ -17,6 +18,6 @@ final class ConnectionIDGeneratorTests: XCTestCase {
             }
         }
 
-        XCTAssertEqual(idGenerator.next(), 1003)
+        #expect(idGenerator.next() == 1003)
     }
 }

Tests/ConnectionPoolModuleTests/ConnectionPoolTests.swift

@@ -1,29 +1,29 @@
 @testable import _ConnectionPoolModule
 import _ConnectionPoolTestUtils
-import XCTest
+import Testing
 
-final class ConnectionRequestTests: XCTestCase {
+@Suite struct ConnectionRequestTests {
 
-    func testHappyPath() async throws {
+    @Test func testHappyPath() async throws {
         let mockConnection = MockConnection(id: 1)
         let lease = try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<ConnectionLease<MockConnection>, any Error>) in
             let request = ConnectionRequest(id: 42, continuation: continuation)
-            XCTAssertEqual(request.id, 42)
+            #expect(request.id == 42)
             let lease = ConnectionLease(connection: mockConnection) { _ in }
             continuation.resume(with: .success(lease))
         }
 
-        XCTAssert(lease.connection === mockConnection)
+        #expect(lease.connection === mockConnection)
     }
 
-    func testSadPath() async throws {
+    @Test func testSadPath() async throws {
         do {
             _ = try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<MockConnection, any Error>) in
                 continuation.resume(with: .failure(ConnectionPoolError.requestCancelled))
             }
-            XCTFail("This point should not be reached")
+            Issue.record("This point should not be reached")
         } catch {
-            XCTAssertEqual(error as? ConnectionPoolError, .requestCancelled)
+            #expect(error as? ConnectionPoolError == .requestCancelled)
         }
     }
 }

Tests/ConnectionPoolModuleTests/ConnectionRequestTests.swift

@@ -1,60 +1,61 @@
 @testable import _ConnectionPoolModule
-import XCTest
+import Testing
 
-final class Max2SequenceTests: XCTestCase {
-    func testCountAndIsEmpty() async {
+@Suite struct Max2SequenceTests {
+
+    @Test func testCountAndIsEmpty() async {
         var sequence = Max2Sequence<Int>()
-        XCTAssertEqual(sequence.count, 0)
-        XCTAssertEqual(sequence.isEmpty, true)
+        #expect(sequence.count == 0)
+        #expect(sequence.isEmpty == true)
         sequence.append(1)
-        XCTAssertEqual(sequence.count, 1)
-        XCTAssertEqual(sequence.isEmpty, false)
+        #expect(sequence.count == 1)
+        #expect(sequence.isEmpty == false)
         sequence.append(2)
-        XCTAssertEqual(sequence.count, 2)
-        XCTAssertEqual(sequence.isEmpty, false)
+        #expect(sequence.count == 2)
+        #expect(sequence.isEmpty == false)
     }
 
-    func testOptionalInitializer() {
+    @Test func testOptionalInitializer() {
         let emptySequence = Max2Sequence<Int>(nil, nil)
-        XCTAssertEqual(emptySequence.count, 0)
-        XCTAssertEqual(emptySequence.isEmpty, true)
+        #expect(emptySequence.count == 0)
+        #expect(emptySequence.isEmpty == true)
         var emptySequenceIterator = emptySequence.makeIterator()
-        XCTAssertNil(emptySequenceIterator.next())
-        XCTAssertNil(emptySequenceIterator.next())
-        XCTAssertNil(emptySequenceIterator.next())
+        #expect(emptySequenceIterator.next() == nil)
+        #expect(emptySequenceIterator.next() == nil)
+        #expect(emptySequenceIterator.next() == nil)
 
         let oneElemSequence1 = Max2Sequence<Int>(1, nil)
-        XCTAssertEqual(oneElemSequence1.count, 1)
-        XCTAssertEqual(oneElemSequence1.isEmpty, false)
+        #expect(oneElemSequence1.count == 1)
+        #expect(oneElemSequence1.isEmpty == false)
         var oneElemSequence1Iterator = oneElemSequence1.makeIterator()
-        XCTAssertEqual(oneElemSequence1Iterator.next(), 1)
-        XCTAssertNil(oneElemSequence1Iterator.next())
-        XCTAssertNil(oneElemSequence1Iterator.next())
+        #expect(oneElemSequence1Iterator.next() == 1)
+        #expect(oneElemSequence1Iterator.next() == nil)
+        #expect(oneElemSequence1Iterator.next() == nil)
 
         let oneElemSequence2 = Max2Sequence<Int>(nil, 2)
-        XCTAssertEqual(oneElemSequence2.count, 1)
-        XCTAssertEqual(oneElemSequence2.isEmpty, false)
+        #expect(oneElemSequence2.count == 1)
+        #expect(oneElemSequence2.isEmpty == false)
         var oneElemSequence2Iterator = oneElemSequence2.makeIterator()
-        XCTAssertEqual(oneElemSequence2Iterator.next(), 2)
-        XCTAssertNil(oneElemSequence2Iterator.next())
-        XCTAssertNil(oneElemSequence2Iterator.next())
+        #expect(oneElemSequence2Iterator.next() == 2)
+        #expect(oneElemSequence2Iterator.next() == nil)
+        #expect(oneElemSequence2Iterator.next() == nil)
 
         let twoElemSequence = Max2Sequence<Int>(1, 2)
-        XCTAssertEqual(twoElemSequence.count, 2)
-        XCTAssertEqual(twoElemSequence.isEmpty, false)
+        #expect(twoElemSequence.count == 2)
+        #expect(twoElemSequence.isEmpty == false)
         var twoElemSequenceIterator = twoElemSequence.makeIterator()
-        XCTAssertEqual(twoElemSequenceIterator.next(), 1)
-        XCTAssertEqual(twoElemSequenceIterator.next(), 2)
-        XCTAssertNil(twoElemSequenceIterator.next())
+        #expect(twoElemSequenceIterator.next() == 1)
+        #expect(twoElemSequenceIterator.next() == 2)
+        #expect(twoElemSequenceIterator.next() == nil)
     }
 
     func testMap() {
         let twoElemSequence = Max2Sequence<Int>(1, 2).map({ "\($0)" })
-        XCTAssertEqual(twoElemSequence.count, 2)
-        XCTAssertEqual(twoElemSequence.isEmpty, false)
+        #expect(twoElemSequence.count == 2)
+        #expect(twoElemSequence.isEmpty == false)
         var twoElemSequenceIterator = twoElemSequence.makeIterator()
-        XCTAssertEqual(twoElemSequenceIterator.next(), "1")
-        XCTAssertEqual(twoElemSequenceIterator.next(), "2")
-        XCTAssertNil(twoElemSequenceIterator.next())
+        #expect(twoElemSequenceIterator.next() == "1")
+        #expect(twoElemSequenceIterator.next() == "2")
+        #expect(twoElemSequenceIterator.next() == nil)
     }
 }

Tests/ConnectionPoolModuleTests/Max2SequenceTests.swift

@@ -1,11 +1,12 @@
 import _ConnectionPoolModule
 import _ConnectionPoolTestUtils
-import XCTest
+import Testing
 
-@available(macOS 13.0, iOS 16.0, tvOS 16.0, watchOS 9.0, *)
-final class NoKeepAliveBehaviorTests: XCTestCase {
-    func testNoKeepAlive() {
+
+@Suite struct NoKeepAliveBehaviorTests {
+    @available(macOS 13.0, iOS 16.0, tvOS 16.0, watchOS 9.0, *)
+    @Test func testNoKeepAlive() {
         let keepAliveBehavior = NoOpKeepAliveBehavior(connectionType: MockConnection.self)
-        XCTAssertNil(keepAliveBehavior.keepAliveFrequency)
+        #expect(keepAliveBehavior.keepAliveFrequency == nil)
     }
 }