Adopt Swift Testing (#41)

* Adopt Swift Testing

* Allow for slow CI machines

* Get code coverage back up

Author: dfed

Package.swift

@@ -16,20 +16,23 @@ let package = Package(
     products: [
         .library(
             name: "AsyncQueue",
-            targets: ["AsyncQueue"]),
+            targets: ["AsyncQueue"]
+        ),
     ],
     targets: [
         .target(
             name: "AsyncQueue",
             dependencies: [],
             swiftSettings: [
                 .swiftLanguageMode(.v6),
-            ]),
+            ]
+        ),
         .testTarget(
             name: "AsyncQueueTests",
             dependencies: ["AsyncQueue"],
             swiftSettings: [
                 .swiftLanguageMode(.v6),
-            ]),
+            ]
+        ),
     ]
 )

Tests/AsyncQueueTests/ActorQueueTests.swift

@@ -20,34 +20,33 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-import XCTest
+import Foundation
+import Testing
 
 @testable import AsyncQueue
 
-final class ActorQueueTests: XCTestCase {
+struct ActorQueueTests {
 
-    // MARK: XCTestCase
-
-    override func setUp() async throws {
-        try await super.setUp()
+    // MARK: Initialization
 
+    init() {
         systemUnderTest = ActorQueue<Counter>()
         counter = Counter()
         systemUnderTest.adoptExecutionContext(of: counter)
     }
 
     // MARK: Behavior Tests
 
-    func test_adoptExecutionContext_doesNotRetainActor() {
+    @Test func test_adoptExecutionContext_doesNotRetainActor() {
         let systemUnderTest = ActorQueue<Counter>()
         var counter: Counter? = Counter()
         weak var weakCounter = counter
         systemUnderTest.adoptExecutionContext(of: counter!)
         counter = nil
-        XCTAssertNil(weakCounter)
+        #expect(weakCounter == nil)
     }
 
-    func test_enqueue_retainsAdoptedActorUntilEnqueuedTasksComplete() async {
+    @Test func test_enqueue_retainsAdoptedActorUntilEnqueuedTasksComplete() async {
         let systemUnderTest = ActorQueue<Counter>()
         var counter: Counter? = Counter()
         weak var weakCounter = counter
@@ -59,27 +58,27 @@ final class ActorQueueTests: XCTestCase {
         }
 
         counter = nil
-        XCTAssertNotNil(weakCounter)
+        #expect(weakCounter != nil)
         await semaphore.signal()
     }
 
-    func test_enqueue_taskParameterIsAdoptedActor() async {
+    @Test func test_enqueue_taskParameterIsAdoptedActor() async {
         let semaphore = Semaphore()
         systemUnderTest.enqueue { [storedCounter = counter] counter in
-            XCTAssertTrue(counter === storedCounter)
+            #expect(counter === storedCounter)
             await semaphore.signal()
         }
 
         await semaphore.wait()
     }
 
-    func test_enqueueAndWait_taskParameterIsAdoptedActor() async {
+    @Test func test_enqueueAndWait_taskParameterIsAdoptedActor() async {
         await systemUnderTest.enqueueAndWait { [storedCounter = counter] counter in
-            XCTAssertTrue(counter === storedCounter)
+            #expect(counter === storedCounter)
         }
     }
 
-    func test_enqueue_sendsEventsInOrder() async {
+    @Test func test_enqueue_sendsEventsInOrder() async {
         for iteration in 1...1_000 {
             systemUnderTest.enqueue { counter in
                 counter.incrementAndExpectCount(equals: iteration)
@@ -88,7 +87,7 @@ final class ActorQueueTests: XCTestCase {
         await systemUnderTest.enqueueAndWait { _ in /* Drain the queue */ }
     }
 
-    func test_enqueue_startsExecutionOfNextTaskAfterSuspension() async {
+    @Test func test_enqueue_startsExecutionOfNextTaskAfterSuspension() async {
         let systemUnderTest = ActorQueue<Semaphore>()
         let semaphore = Semaphore()
         systemUnderTest.adoptExecutionContext(of: semaphore)
@@ -105,7 +104,7 @@ final class ActorQueueTests: XCTestCase {
         await systemUnderTest.enqueueAndWait { _ in /* Drain the queue */ }
     }
 
-    func test_enqueueAndWait_allowsReentrancy() async {
+    @Test func test_enqueueAndWait_allowsReentrancy() async {
         await systemUnderTest.enqueueAndWait { [systemUnderTest] counter in
             await systemUnderTest.enqueueAndWait { counter in
                 counter.incrementAndExpectCount(equals: 1)
@@ -114,11 +113,11 @@ final class ActorQueueTests: XCTestCase {
         }
     }
 
-    func test_enqueue_executesEnqueuedTasksAfterReceiverIsDeallocated() async {
+    @Test func test_enqueue_executesEnqueuedTasksAfterReceiverIsDeallocated() async {
         var systemUnderTest: ActorQueue<Counter>? = ActorQueue()
         systemUnderTest?.adoptExecutionContext(of: counter)
 
-        let expectation = self.expectation(description: #function)
+        let expectation = Expectation()
         let semaphore = Semaphore()
         systemUnderTest?.enqueue { counter in
             // Make the task wait.
@@ -129,14 +128,13 @@ final class ActorQueueTests: XCTestCase {
         weak var queue = systemUnderTest
         // Nil out our reference to the queue to show that the enqueued tasks will still complete
         systemUnderTest = nil
-        XCTAssertNil(queue)
+        #expect(queue == nil)
         // Signal the semaphore to unlock the enqueued tasks.
         await semaphore.signal()
-
-        await fulfillment(of: [expectation], timeout: 1.0)
+        await expectation.fulfillment(withinSeconds: 10)
     }
 
-    func test_enqueue_doesNotRetainTaskAfterExecution() async {
+    @Test func test_enqueue_doesNotRetainTaskAfterExecution() async {
         final class Reference: Sendable {}
         final class ReferenceHolder: @unchecked Sendable {
             init() {
@@ -156,7 +154,7 @@ final class ActorQueueTests: XCTestCase {
         let systemUnderTest = ActorQueue<Semaphore>()
         systemUnderTest.adoptExecutionContext(of: syncSemaphore)
 
-        let expectation = self.expectation(description: #function)
+        let expectation = Expectation()
         systemUnderTest.enqueue { [reference = referenceHolder.reference] syncSemaphore in
             // Now that we've started the task and captured the reference, release the synchronous code.
             syncSemaphore.signal()
@@ -173,16 +171,16 @@ final class ActorQueueTests: XCTestCase {
         // Wait for the asynchronous task to start.
         await syncSemaphore.wait()
         referenceHolder.clearReference()
-        XCTAssertNotNil(referenceHolder.weakReference)
+        #expect(referenceHolder.weakReference != nil)
         // Allow the enqueued task to complete.
         await asyncSemaphore.signal()
         // Make sure the task has completed.
-        await fulfillment(of: [expectation], timeout: 1.0)
+        await expectation.fulfillment(withinSeconds: 10)
 
-        XCTAssertNil(referenceHolder.weakReference)
+        #expect(referenceHolder.weakReference == nil)
     }
 
-    func test_enqueueAndWait_sendsEventsInOrder() async {
+    @Test func test_enqueueAndWait_sendsEventsInOrder() async {
         for iteration in 1...1_000 {
             systemUnderTest.enqueue { counter in
                 counter.incrementAndExpectCount(equals: iteration)
@@ -194,32 +192,32 @@ final class ActorQueueTests: XCTestCase {
             }
 
             await systemUnderTest.enqueueAndWait { counter in
-                XCTAssertEqual(counter.count, iteration)
+                #expect(counter.count == iteration)
             }
         }
         await systemUnderTest.enqueueAndWait { _ in /* Drain the queue */ }
     }
 
-    func test_enqueueAndWait_canReturn() async {
+    @Test func test_enqueueAndWait_canReturn() async {
         let expectedValue = UUID()
         let returnedValue = await systemUnderTest.enqueueAndWait { _ in expectedValue }
-        XCTAssertEqual(expectedValue, returnedValue)
+        #expect(expectedValue == returnedValue)
     }
 
-    func test_enqueueAndWait_canThrow() async {
+    @Test func test_enqueueAndWait_canThrow() async {
         struct TestError: Error, Equatable {
             private let identifier = UUID()
         }
         let expectedError = TestError()
         do {
             try await systemUnderTest.enqueueAndWait { _ in throw expectedError }
         } catch {
-            XCTAssertEqual(error as? TestError, expectedError)
+            #expect(error as? TestError == expectedError)
         }
     }
 
     // MARK: Private
 
-    private var systemUnderTest = ActorQueue<Counter>()
-    private var counter = Counter()
+    private let systemUnderTest: ActorQueue<Counter>
+    private let counter: Counter
 }

Tests/AsyncQueueTests/ExpectationTests.swift

@@ -0,0 +1,101 @@
+// MIT License
+//
+// Copyright (c) 2024 Dan Federman
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+import Testing
+
+struct ExpectationTests {
+
+    // MARK: Behavior Tests
+
+    @Test func test_fulfill_triggersExpectation() async {
+        await confirmation { confirmation in
+            let systemUnderTest = Expectation(
+                expectedCount: 1,
+                expect: { expectation, _, _ in
+                    #expect(expectation)
+                    confirmation()
+                }
+            )
+            await systemUnderTest.fulfill().value
+        }
+    }
+
+    @Test func test_fulfill_triggersExpectationOnceWhenCalledTwiceAndExpectedCountIsTwo() async {
+        await confirmation { confirmation in
+            let systemUnderTest = Expectation(
+                expectedCount: 2,
+                expect: { expectation, _, _ in
+                    #expect(expectation)
+                    confirmation()
+                }
+            )
+            await systemUnderTest.fulfill().value
+            await systemUnderTest.fulfill().value
+        }
+    }
+
+    @Test func test_fulfill_triggersExpectationWhenExpectedCountIsZero() async {
+        await confirmation { confirmation in
+            let systemUnderTest = Expectation(
+                expectedCount: 0,
+                expect: { expectation, _, _ in
+                    #expect(!expectation)
+                    confirmation()
+                }
+            )
+            await systemUnderTest.fulfill().value
+        }
+    }
+
+    @Test func test_fulfillment_doesNotWaitIfAlreadyFulfilled() async {
+        let systemUnderTest = Expectation(expectedCount: 0)
+        await systemUnderTest.fulfillment(withinSeconds: 10)
+    }
+
+    @MainActor // Global actor ensures Task ordering.
+    @Test func test_fulfillment_waitsForFulfillment() async {
+        let systemUnderTest = Expectation(expectedCount: 1)
+        var hasFulfilled = false
+        let wait = Task {
+            await systemUnderTest.fulfillment(withinSeconds: 10)
+            #expect(hasFulfilled)
+        }
+        Task {
+            systemUnderTest.fulfill()
+            hasFulfilled = true
+        }
+        await wait.value
+    }
+
+    @Test func test_fulfillment_triggersFalseExpectationWhenItTimesOut() async {
+        await confirmation { confirmation in
+            let systemUnderTest = Expectation(
+                expectedCount: 1,
+                expect: { expectation, _, _ in
+                    #expect(!expectation)
+                    confirmation()
+                }
+            )
+            await systemUnderTest.fulfillment(withinSeconds: 0)
+        }
+    }
+}