Update

Author: muukii

Sources/ConcurrencyTaskManager/TaskManager.swift

@@ -179,7 +179,7 @@ public final class TaskManager: Sendable {
     let extendedContinuation: AutoReleaseContinuationBox<Return> = .init(nil)
 
     let referenceTask = Task { [weak extendedContinuation] in
-      return try await withUnsafeThrowingContinuation{ (continuation: UnsafeContinuation<Return, Error>) in
+      return try await withUnsafeThrowingContinuation { (continuation: UnsafeContinuation<Return, Error>) in
         extendedContinuation?.setContinuation(continuation)
       }
     }

Tests/ConcurrencyTaskManagerTests/SimpleTest.swift

@@ -1,9 +1,9 @@
 import ConcurrencyTaskManager
-import XCTest
+import Testing
 
-final class SimpleTest: XCTestCase {
+@Suite struct SimpleTest {
 
-  func test_simple_task() async {
+  @Test func simpleTask() async {
     let manager = TaskManager()
 
     let completed = UnfairLockAtomic<Bool>(false)
@@ -14,6 +14,6 @@ final class SimpleTest: XCTestCase {
 
     _ = try? await task.value
 
-    XCTAssertTrue(completed.value)
+    #expect(completed.value)
   }
 }

Tests/ConcurrencyTaskManagerTests/TaskKeyTests.swift

@@ -1,28 +1,28 @@
-import XCTest
+import Testing
 import ConcurrencyTaskManager
 
-final class TaskKeyTests: XCTestCase {
+@Suite struct TaskKeyTests {
 
-  func testBase() {
+  @Test func base() {
 
     enum LocalKey: TaskKeyType {}
     enum LocalKey2: TaskKeyType {}
 
     let key = TaskKey(LocalKey.self)
     let key2 = TaskKey(LocalKey2.self)
 
-    XCTAssertNotEqual(key, key2)
-    XCTAssertEqual(key, key)
+    #expect(key != key2)
+    #expect(key == key)
   }
 
-  func testCombined() {
+  @Test func combined() {
 
     enum LocalKey: TaskKeyType {}
 
     let key = TaskKey(LocalKey.self)
 
-    XCTAssertEqual(key, key.combined(.init(LocalKey.self)))
-    XCTAssertNotEqual(key, key.combined("A"))
+    #expect(key == key.combined(.init(LocalKey.self)))
+    #expect(key != key.combined("A"))
 
   }
 

Tests/ConcurrencyTaskManagerTests/TaskManagerTests.swift

@@ -1,15 +1,15 @@
 import ConcurrencyTaskManager
-import XCTest
+import Testing
 
 @discardableResult
 func dummyTask<V>(_ v: V, nanoseconds: UInt64) async -> V {
   try? await Task.sleep(nanoseconds: nanoseconds)
   return v
 }
 
-final class TaskManagerTests: XCTestCase {
+@Suite struct TaskManagerTests {
 
-  func test_run_distinct_tasks() async {
+  @Test func runDistinctTasks() async {
 
     let manager = TaskManager()
 
@@ -30,11 +30,11 @@ final class TaskManagerTests: XCTestCase {
 
     try? await Task.sleep(nanoseconds: 1_000_000)
 
-    XCTAssertEqual(Set(events.value), Set(["1", "2", "3"]))
+    #expect(Set(events.value) == Set(["1", "2", "3"]))
 
   }
 
-  func test_drop_current_task_in_key() async {
+  @Test func dropCurrentTaskInKey() async {
 
     let manager = TaskManager()
 
@@ -51,10 +51,10 @@ final class TaskManagerTests: XCTestCase {
 
     try? await Task.sleep(nanoseconds: 2_000_000_000)
 
-    XCTAssertEqual(events.value, ["9"])
+    #expect(events.value == ["9"])
   }
 
-  func test_wait_current_task_in_key() async {
+  @Test func waitCurrentTaskInKey() async {
 
     let manager = TaskManager()
 
@@ -76,10 +76,10 @@ final class TaskManagerTests: XCTestCase {
 
     try? await Task.sleep(nanoseconds: 1_000_000_000)
 
-    XCTAssertEqual(events.value, ["1", "2"])
+    #expect(events.value == ["1", "2"])
   }
 
-  func test_isRunning() async {
+  @Test func isRunning() async {
 
     let manager = TaskManager()
 
@@ -90,13 +90,13 @@ final class TaskManagerTests: XCTestCase {
     _ = manager.task(key: .init("request"), mode: .waitInCurrent) {
       print("done 1")
       callCount.modify { $0 += 1 }
-      XCTAssert(_isRunning.value == true)
+      #expect(_isRunning.value == true)
     }
 
     _ = manager.task(key: .init("request"), mode: .waitInCurrent) {
       print("done 2")
       callCount.modify { $0 += 1 }
-      XCTAssert(_isRunning.value == true)
+      #expect(_isRunning.value == true)
     }
 
     try? await Task.sleep(nanoseconds: 1_000_000_000)
@@ -106,10 +106,10 @@ final class TaskManagerTests: XCTestCase {
 
     try? await Task.sleep(nanoseconds: 1_000_000_000)
 
-    XCTAssertEqual(callCount.value, 2)
+    #expect(callCount.value == 2)
   }
 
-  func test_cancel_specific_key() async {
+  @Test func cancelSpecificKey() async {
     let manager = TaskManager()
 
     let events: UnfairLockAtomic<[String]> = .init([])
@@ -143,10 +143,10 @@ final class TaskManagerTests: XCTestCase {
     try? await Task.sleep(nanoseconds: 2_000_000_000)
 
     // key1 and key3 should complete, key2 should be cancelled
-    XCTAssertEqual(Set(events.value), Set(["key1", "key3"]))
+    #expect(Set(events.value) == Set(["key1", "key3"]))
   }
 
-  func test_cancel_key_with_multiple_queued_tasks() async {
+  @Test func cancelKeyWithMultipleQueuedTasks() async {
     let manager = TaskManager()
 
     let events: UnfairLockAtomic<[String]> = .init([])
@@ -180,22 +180,24 @@ final class TaskManagerTests: XCTestCase {
     try? await Task.sleep(nanoseconds: 2_000_000_000)
 
     // No tasks should have completed
-    XCTAssertEqual(events.value, [])
+    #expect(events.value == [])
   }
 
-  func test_cancel_nonexistent_key() async {
+  @Test func cancelNonexistentKey() async {
     let manager = TaskManager()
 
     // This should not crash
     manager.cancel(key: .init("nonexistent"))
 
     // Verify manager still works after cancelling nonexistent key
-    let expectation = XCTestExpectation(description: "Task completes")
+    let completed = UnfairLockAtomic<Bool>(false)
 
     manager.task(key: .init("test"), mode: .dropCurrent) {
-      expectation.fulfill()
+      completed.modify { $0 = true }
     }
 
-    await fulfillment(of: [expectation], timeout: 1.0)
+    try? await Task.sleep(nanoseconds: 100_000_000) // 100ms
+
+    #expect(completed.value)
   }
 }

Tests/ConcurrencyTaskManagerTests/TaskWaitTests.swift

@@ -1,10 +1,11 @@
 import ConcurrencyTaskManager
-import XCTest
+import Testing
+import Foundation
 
 /// Tests for TaskNode wait functionality via TaskManager
-final class TaskWaitTests: XCTestCase {
+@Suite struct TaskWaitTests {
 
-  func test_wait_for_queued_tasks() async throws {
+  @Test func waitForQueuedTasks() async throws {
     let manager = TaskManager()
     let events = UnfairLockAtomic<[String]>([])
 
@@ -30,10 +31,10 @@ final class TaskWaitTests: XCTestCase {
     _ = try await task3.value
 
     // Tasks should execute in order
-    XCTAssertEqual(events.value, ["task1", "task2", "task3"])
+    #expect(events.value == ["task1", "task2", "task3"])
   }
 
-  func test_drop_mode_cancels_previous_tasks() async throws {
+  @Test func dropModeCancelsPreviousTasks() async throws {
     let manager = TaskManager()
     let events = UnfairLockAtomic<[String]>([])
 
@@ -55,18 +56,18 @@ final class TaskWaitTests: XCTestCase {
     // Wait for tasks
     do {
       _ = try await task1.value
-      XCTFail("Task1 should have been cancelled")
+      Issue.record("Task1 should have been cancelled")
     } catch is CancellationError {
       // Expected
     }
 
     _ = try await task2.value
 
     // Only task2 should complete
-    XCTAssertEqual(events.value, ["task2"])
+    #expect(events.value == ["task2"])
   }
 
-  func test_concurrent_tasks_with_different_keys() async throws {
+  @Test func concurrentTasksWithDifferentKeys() async throws {
     let manager = TaskManager()
     let events = UnfairLockAtomic<[String]>([])
     let startTime = Date()
@@ -95,11 +96,11 @@ final class TaskWaitTests: XCTestCase {
     let elapsed = Date().timeIntervalSince(startTime)
 
     // Should complete in ~100ms (concurrent), not ~300ms (sequential)
-    XCTAssertLessThan(elapsed, 0.2, "Tasks should run concurrently")
-    XCTAssertEqual(events.value.count, 3, "All tasks should complete")
+    #expect(elapsed < 0.2, "Tasks should run concurrently")
+    #expect(events.value.count == 3, "All tasks should complete")
   }
 
-  func test_task_cancellation_propagation() async throws {
+  @Test func taskCancellationPropagation() async throws {
     let manager = TaskManager()
     let events = UnfairLockAtomic<[String]>([])
 
@@ -143,13 +144,13 @@ final class TaskWaitTests: XCTestCase {
     _ = try? await task3.value
 
     // Should see cancellation events
-    XCTAssertTrue(events.value.contains("task1-cancelled") || events.value.isEmpty)
-    XCTAssertFalse(events.value.contains("task1-completed"))
-    XCTAssertFalse(events.value.contains("task2-completed"))
-    XCTAssertFalse(events.value.contains("task3-completed"))
+    #expect(events.value.contains("task1-cancelled") || events.value.isEmpty)
+    #expect(!events.value.contains("task1-completed"))
+    #expect(!events.value.contains("task2-completed"))
+    #expect(!events.value.contains("task3-completed"))
   }
 
-  func test_task_completion_order_with_wait_mode() async throws {
+  @Test func taskCompletionOrderWithWaitMode() async throws {
     let manager = TaskManager()
     let events = UnfairLockAtomic<[String]>([])
     let completionTimes = UnfairLockAtomic<[String: Date]>([:])
@@ -181,12 +182,12 @@ final class TaskWaitTests: XCTestCase {
     _ = try await task3.value
 
     // Verify order
-    XCTAssertEqual(events.value, ["task1", "task2", "task3"], "Tasks should complete in order")
+    #expect(events.value == ["task1", "task2", "task3"], "Tasks should complete in order")
 
     // Verify timing - task2 should complete after task1 despite being faster
     if let time1 = completionTimes.value["task1"],
        let time2 = completionTimes.value["task2"] {
-      XCTAssertTrue(time2 > time1, "Task2 should complete after task1")
+      #expect(time2 > time1, "Task2 should complete after task1")
     }
   }