In withTaskPriorityChangedHandler execute the task that watches for priority changes with high priority

I saw a nondeterministic test failure of `AsyncUtilsTests.testWithTimeoutEscalatesPriority` and I believe this was the cause.

Also refactor a few test helper functions on the way.

Author: ahoppen

Sources/SKTestSupport/RepeatUntilExpectedResult.swift

@@ -10,27 +10,34 @@
 //
 //===----------------------------------------------------------------------===//
 
-#if compiler(>=6)
-package import XCTest
-#else
+import SKLogging
 import XCTest
-#endif
 
 /// Runs the body repeatedly once per second until it returns `true`, giving up after `timeout`.
 ///
 /// This is useful to test some request that requires global state to be updated but will eventually converge on the
 /// correct result.
+///
+/// `sleepInterval` is the duration to wait before re-executing the body.
 package func repeatUntilExpectedResult(
-  timeout: TimeInterval = defaultTimeout,
+  timeout: Duration = .seconds(defaultTimeout),
+  sleepInterval: Duration = .seconds(1),
   _ body: () async throws -> Bool,
   file: StaticString = #filePath,
   line: UInt = #line
 ) async throws {
-  for _ in 0..<Int(timeout) {
+  logger.info("x: \(Int(timeout.seconds / sleepInterval.seconds))")
+  for _ in 0..<Int(timeout.seconds / sleepInterval.seconds) {
     if try await body() {
       return
     }
-    try await Task.sleep(for: .seconds(1))
+    try await Task.sleep(for: sleepInterval)
   }
   XCTFail("Failed to get expected result", file: file, line: line)
 }
+
+fileprivate extension Duration {
+  var seconds: Double {
+    return Double(self.components.attoseconds) / 1_000_000_000_000_000_000 + Double(self.components.seconds)
+  }
+}

Sources/SwiftExtensions/Task+WithPriorityChangedHandler.swift

@@ -24,7 +24,10 @@ package func withTaskPriorityChangedHandler<T: Sendable>(
 ) async throws -> T {
   let lastPriority = ThreadSafeBox(initialValue: initialPriority)
   let result: T? = try await withThrowingTaskGroup(of: Optional<T>.self) { taskGroup in
-    taskGroup.addTask {
+    // Run the task priority watcher with high priority instead of inheriting the initial priority. Otherwise a
+    // `.background` task might not get its priority elevated because the priority watching task also runs at
+    // `.background` priority and might not actually get executed in time.
+    taskGroup.addTask(priority: .high) {
       while true {
         if Task.isCancelled {
           break

Tests/BuildSystemIntegrationTests/BuildServerBuildSystemTests.swift

@@ -299,7 +299,7 @@ final class BuildServerBuildSystemTests: XCTestCase {
     XCTAssertEqual(diagnosticsBeforeCrash.fullReport?.items, [])
     try FileManager.default.removeItem(at: project.scratchDirectory.appendingPathComponent("should_crash"))
 
-    try await repeatUntilExpectedResult(timeout: 20) {
+    try await repeatUntilExpectedResult(timeout: .seconds(20)) {
       let diagnostics = try await project.testClient.send(
         DocumentDiagnosticsRequest(textDocument: TextDocumentIdentifier(uri))
       )

Tests/SKSupportTests/AsyncUtilsTests.swift

@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+import SKLogging
 import SKSupport
 import SKTestSupport
 import SwiftExtensions
@@ -46,7 +47,8 @@ final class AsyncUtilsTests: XCTestCase {
       // We don't actually hit the timeout. It's just a large value.
       try await withTimeout(.seconds(defaultTimeout * 2)) {
         expectation.fulfill()
-        try await repeatUntilExpectedResult {
+        try await repeatUntilExpectedResult(sleepInterval: .seconds(0.1)) {
+          logger.debug("Current priority: \(Task.currentPriority.rawValue)")
           return Task.currentPriority > .background
         }
       }