test: Fix a few different issues that caused some tests to be flaky. And other minor improvements to tests.

Author: scottmarchant

Tests/DispatchAsyncTests/AsyncSemaphoreTests.swift

@@ -2,33 +2,40 @@ import Testing
 
 @testable import DispatchAsync
 
-@Test
+@Test(.timeLimit(.minutes(1)))
 func asyncSemaphoreWaitSignal() async throws {
     let semaphore = AsyncSemaphore(value: 1)
 
     // First wait should succeed immediately and bring the count to 0
     await semaphore.wait()
 
     // Launch a task that tries to wait – it should be suspended until we signal
-    var didEnterCriticalSection = false
-    let waiter = Task {
-        await semaphore.wait()
-        didEnterCriticalSection = true
-        await semaphore.signal()
+    nonisolated(unsafe) var didEnterCriticalSection = false
+    await withCheckedContinuation { continuation in
+        Task { @Sendable in
+            // Ensure the rest of this test doesn't
+            // proceed until the Task block has started executing
+            continuation.resume()
+
+            await semaphore.wait()
+            didEnterCriticalSection = true
+            await semaphore.signal()
+        }
     }
 
-    // Allow the task a brief moment to start and (hopefully) suspend
+    // Allow the task a few cycles to reach the initial semaphore.wait()
     try? await Task.sleep(nanoseconds: 1_000)
 
     #expect(!didEnterCriticalSection)  // should still be waiting
 
     // Now release the semaphore – the waiter should proceed
     await semaphore.signal()
 
-    // Give the waiter a chance to run
-    try? await Task.sleep(nanoseconds: 1_000)
+    // Wait for second signal to fire from inside the task above
+    // There is a timeout on this test, so if there is a problem
+    // we'll either hit the timeout and fail, or didEnterCriticalSection
+    // will be false below
+    await semaphore.wait()
 
     #expect(didEnterCriticalSection)   // waiter must have run
-
-    _ = await waiter.value
 }

Tests/DispatchAsyncTests/DispatchSemaphoreTests.swift

@@ -26,6 +26,7 @@ private typealias DispatchSemaphore = AsyncSemaphore
 nonisolated(unsafe) private var sharedPoolCompletionCount = 0
 
 @Test func basicAsyncSemaphoreTest() async throws {
+    sharedPoolCompletionCount = 0 // Reset to 0 for each test run
     let totalConcurrentPools = 10
 
     let semaphore = DispatchSemaphore(value: 1)

Tests/DispatchAsyncTests/DispatchTimeTests.swift

@@ -23,5 +23,17 @@ private typealias DispatchTime = DispatchAsync.DispatchTime
 func testDispatchTimeContinousClockBasics() async throws {
     let a = DispatchTime.now().uptimeNanoseconds
     let b = DispatchTime.now().uptimeNanoseconds
-    #expect(a <= b)
+    try await Task.sleep(for: .nanoseconds(1))
+    let c = DispatchTime.now().uptimeNanoseconds
+    #expect(a < b)
+    #expect(b < c)
+}
+
+@Test
+func testUptimeNanosecondsEqualityForConsecutiveCalls() async throws {
+    let original = DispatchTime.now()
+    let a = original.uptimeNanoseconds
+    try await Task.sleep(for: .nanoseconds(100))
+    let b = original.uptimeNanoseconds
+    #expect(a == b)
 }