Merge pull request #727 from Quick/8.x-waitUntil-race-condition-fix

[8.x] Wait until race condition fix

Author: ikesyo

Sources/Nimble/Utils/Await.swift

@@ -301,11 +301,19 @@ internal class Awaiter {
             let timeoutSource = createTimerSource(timeoutQueue)
             var completionCount = 0
             let trigger = AwaitTrigger(timeoutSource: timeoutSource, actionSource: nil) {
-                try closure {
+                try closure { result in
                     completionCount += 1
                     if completionCount < 2 {
-                        if promise.resolveResult(.completed($0)) {
-                            CFRunLoopStop(CFRunLoopGetMain())
+                        func completeBlock() {
+                            if promise.resolveResult(.completed(result)) {
+                                CFRunLoopStop(CFRunLoopGetMain())
+                            }
+                        }
+
+                        if Thread.isMainThread {
+                            completeBlock()
+                        } else {
+                            DispatchQueue.main.async { completeBlock() }
                         }
                     } else {
                         fail("waitUntil(..) expects its completion closure to be only called once",

Tests/NimbleTests/AsynchronousTest.swift

@@ -1,4 +1,5 @@
 import Dispatch
+import CoreFoundation
 import Foundation
 import XCTest
 import Nimble
@@ -165,6 +166,39 @@ final class AsyncTest: XCTestCase, XCTestCaseProvider {
         }
     }
 
+    func testWaitUntilDoesNotCompleteBeforeRunLoopIsWaiting() {
+        // This verifies the fix for a race condition in which `done()` is
+        // called asynchronously on a background thread after the main thread checks
+        // for completion, but prior to `RunLoop.current.run(mode:before:)` being called.
+        // This race condition resulted in the RunLoop locking up.
+        var failed = false
+
+        let timeoutQueue = DispatchQueue(label: "Nimble.waitUntilTest.timeout", qos: .background)
+        let timer = DispatchSource.makeTimerSource(flags: .strict, queue: timeoutQueue)
+        timer.schedule(
+            deadline: DispatchTime.now() + 5,
+            repeating: .never,
+            leeway: DispatchTimeInterval.milliseconds(1)
+        )
+        timer.setEventHandler {
+            failed = true
+            fail("Timed out: Main RunLoop stalled.")
+            CFRunLoopStop(CFRunLoopGetMain())
+        }
+        timer.resume()
+
+        for index in 0..<100 {
+            if failed { break }
+            waitUntil(line: UInt(index)) { done in
+                DispatchQueue(label: "Nimble.waitUntilTest.\(index)").async {
+                    done()
+                }
+            }
+        }
+
+        timer.cancel()
+    }
+
     func testWaitUntilMustBeInMainThread() {
 #if !SWIFT_PACKAGE
         var executedAsyncBlock: Bool = false

Tests/NimbleTests/XCTestManifests.swift

@@ -20,6 +20,7 @@ extension AsyncTest {
         ("testToEventuallyPositiveMatches", testToEventuallyPositiveMatches),
         ("testToEventuallyWithCustomDefaultTimeout", testToEventuallyWithCustomDefaultTimeout),
         ("testWaitUntilDetectsStalledMainThreadActivity", testWaitUntilDetectsStalledMainThreadActivity),
+        ("testWaitUntilDoesNotCompleteBeforeRunLoopIsWaiting", testWaitUntilDoesNotCompleteBeforeRunLoopIsWaiting),
         ("testWaitUntilErrorsIfDoneIsCalledMultipleTimes", testWaitUntilErrorsIfDoneIsCalledMultipleTimes),
         ("testWaitUntilMustBeInMainThread", testWaitUntilMustBeInMainThread),
         ("testWaitUntilNegativeMatches", testWaitUntilNegativeMatches),