Introduce a MultiEntrySemaphore for testing

Compare to the `while !AtomicBool.value { sleep }` pattern, this eventually times out, avoiding a timeout of the entire `swift test` invocation.

Author: ahoppen

Sources/SKTestSupport/MultiEntrySemaphore.swift

@@ -0,0 +1,52 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftExtensions
+import XCTest
+
+/// A semaphore that, once signaled, will pass on every `wait` call. Ie. the semaphore only needs to be signaled once
+/// and from that point onwards it can be acquired as many times as necessary.
+///
+/// Use cases of this are for example to delay indexing until a some other task has been performed. But once that is
+/// done, all index operations should be able to run, not just one.
+package final class MultiEntrySemaphore: Sendable {
+  private let name: String
+  private let signaled = AtomicBool(initialValue: false)
+
+  package init(name: String) {
+    self.name = name
+  }
+
+  package func signal() {
+    signaled.value = true
+  }
+
+  package func waitOrThrow() async throws {
+    do {
+      try await repeatUntilExpectedResult(sleepInterval: .seconds(0.01)) { signaled.value }
+    } catch {
+      struct TimeoutError: Error, CustomStringConvertible {
+        let name: String
+        var description: String { "\(name) timed out" }
+      }
+      throw TimeoutError(name: "\(name) timed out")
+    }
+  }
+
+  package func waitOrXCTFail(file: StaticString = #filePath, line: UInt = #line) async {
+    do {
+      try await waitOrThrow()
+    } catch {
+      XCTFail("\(error)", file: file, line: line)
+    }
+  }
+}

Tests/SourceKitLSPTests/BackgroundIndexingTests.swift

@@ -1937,12 +1937,10 @@ final class BackgroundIndexingTests: XCTestCase {
   }
 
   func testIsIndexingRequest() async throws {
-    let checkedIsIndexStatus = AtomicBool(initialValue: false)
+    let checkedIsIndexStatus = MultiEntrySemaphore(name: "Checked is index status")
     let hooks = Hooks(
       indexHooks: IndexHooks(updateIndexStoreTaskDidStart: { task in
-        while !checkedIsIndexStatus.value {
-          try? await Task.sleep(for: .seconds(0.1))
-        }
+        await checkedIsIndexStatus.waitOrXCTFail()
       })
     )
     let project = try await SwiftPMTestProject(
@@ -1956,7 +1954,7 @@ final class BackgroundIndexingTests: XCTestCase {
     )
     let isIndexingResponseWhileIndexing = try await project.testClient.send(IsIndexingRequest())
     XCTAssert(isIndexingResponseWhileIndexing.indexing)
-    checkedIsIndexStatus.value = true
+    checkedIsIndexStatus.signal()
 
     try await repeatUntilExpectedResult {
       try await project.testClient.send(IsIndexingRequest()).indexing == false

Tests/SourceKitLSPTests/PullDiagnosticsTests.swift

@@ -279,20 +279,13 @@ final class PullDiagnosticsTests: XCTestCase {
   }
 
   func testDiagnosticsWaitForDocumentToBePrepared() async throws {
-    let diagnosticRequestSent = AtomicBool(initialValue: false)
+    let diagnosticRequestSent = MultiEntrySemaphore(name: "Diagnostic request sent")
     var testHooks = Hooks()
     testHooks.indexHooks.preparationTaskDidStart = { @Sendable taskDescription in
       // Only start preparation after we sent the diagnostic request. In almost all cases, this should not give
       // preparation enough time to finish before the diagnostic request is handled unless we wait for preparation in
       // the diagnostic request.
-      while diagnosticRequestSent.value == false {
-        do {
-          try await Task.sleep(for: .seconds(0.01))
-        } catch {
-          XCTFail("Did not expect sleep to fail")
-          break
-        }
-      }
+      await diagnosticRequestSent.waitOrXCTFail()
     }
 
     let project = try await SwiftPMTestProject(
@@ -331,7 +324,7 @@ final class PullDiagnosticsTests: XCTestCase {
       XCTAssertEqual(diagnostics.success?.fullReport?.items, [])
       receivedDiagnostics.fulfill()
     }
-    diagnosticRequestSent.value = true
+    diagnosticRequestSent.signal()
     try await fulfillmentOfOrThrow([receivedDiagnostics])
   }