diff --git a/Tests/BasicsTests/ConcurrencyHelpersTests.swift b/Tests/BasicsTests/ConcurrencyHelpersTests.swift
index e3ae5616b8e..9661a3a0812 100644
--- a/Tests/BasicsTests/ConcurrencyHelpersTests.swift
+++ b/Tests/BasicsTests/ConcurrencyHelpersTests.swift
@@ -36,16 +36,13 @@ struct ConcurrencyHelpersTest {
                         lock.withLock {
                             expected[index] = value
                         }
-                        cache.memoize(index) {
-                            value
-                        }
-                        cache.memoize(index) {
-                            Int.random(in: Int.min ..< Int.max)
-                        }
+                        cache.memoize(index) { value }
+                        cache.memoize(index) { Int.random(in: Int.min ..< Int.max) }
                     }
                 }
 
-                try #require(sync.wait(timeout: .now() + .seconds(2)) == .success)
+                sync.wait()
+
                 expected.forEach { key, value in
                     #expect(cache[key] == value)
                 }
@@ -71,149 +68,80 @@ struct ConcurrencyHelpersTest {
                         cache.append(value)
                     }
                 }
+                sync.wait()
 
-                try #require(sync.wait(timeout: .now() + .seconds(2)) == .success)
                 let expectedSorted = expected.sorted()
-                let resultsSorted = cache.get().sorted()
+                let resultsSorted  = cache.get().sorted()
                 #expect(expectedSorted == resultsSorted)
             }
         }
-    }
 
-    @Test
-    func threadSafeBox() throws {
-        let queue = DispatchQueue(label: "ConcurrencyHelpersTest", attributes: .concurrent)
-        for _ in 0 ..< 100 {
-            let sync = DispatchGroup()
+        @Test
+        func threadSafeBox() throws {
+            let queue = DispatchQueue(label: "ConcurrencyHelpersTest", attributes: .concurrent)
+            for _ in 0 ..< 100 {
+                let sync = DispatchGroup()
 
-            var winner: Int?
-            let lock = NSLock()
+                var winner: Int?
+                let lock = NSLock()
 
-            let serial = DispatchQueue(label: "testThreadSafeBoxSerial")
+                let serial = DispatchQueue(label: "testThreadSafeBoxSerial")
 
-            let cache = ThreadSafeBox<Int>()
-            for index in 0 ..< 1000 {
-                queue.async(group: sync) {
-                    Thread.sleep(forTimeInterval: Double.random(in: 100 ... 300) * 1.0e-6)
-                    serial.async(group: sync) {
-                        lock.withLock {
-                            if winner == nil {
-                                winner = index
+                let cache = ThreadSafeBox<Int>()
+                for index in 0 ..< 1000 {
+                    queue.async(group: sync) {
+                        Thread.sleep(forTimeInterval: Double.random(in: 100 ... 300) * 1.0e-6)
+                        serial.async(group: sync) {
+                            lock.withLock {
+                                if winner == nil {
+                                    winner = index
+                                }
                             }
-                        }
-                        cache.memoize {
-                            index
+                            cache.memoize { index }
                         }
                     }
                 }
-            }
-
-            try #require(sync.wait(timeout: .now() + .seconds(2)) == .success)
-            #expect(cache.get() == winner)
-        }
-    }
+                sync.wait()
 
-    @Suite
-    struct AsyncOperationQueueTests {
-        fileprivate actor ResultsTracker {
-            var results = [Int]()
-            var maxConcurrent = 0
-            var currentConcurrent = 0
-
-            func incrementConcurrent() {
-                currentConcurrent += 1
-                maxConcurrent = max(maxConcurrent, currentConcurrent)
+                #expect(cache.get() == winner)
             }
+        }
 
-            func decrementConcurrent() {
-                currentConcurrent -= 1
-            }
 
-            func appendResult(_ value: Int) {
-                results.append(value)
-            }
-        }
+        @Suite
+        struct AsyncOperationQueueTests {
+            fileprivate actor ResultsTracker {
+                var results = [Int]()
+                var maxConcurrent = 0
+                var currentConcurrent = 0
 
-        @Test
-        func limitsConcurrentOperations() async throws {
-            let queue = AsyncOperationQueue(concurrentTasks: 5)
-
-            let totalTasks = 20
-            let tracker = ResultsTracker()
-
-            try await withThrowingTaskGroup(of: Void.self) { group in
-                for index in 0..<totalTasks {
-                    group.addTask {
-                        try await queue.withOperation {
-                            await tracker.incrementConcurrent()
-                            try? await Task.sleep(nanoseconds: 5_000_000)
-                            await tracker.decrementConcurrent()
-                            await tracker.appendResult(index)
-                        }
-                    }
+                func incrementConcurrent() {
+                    currentConcurrent += 1
+                    maxConcurrent = max(maxConcurrent, currentConcurrent)
                 }
-                try await group.waitForAll()
-            }
-
-            let maxConcurrent = await tracker.maxConcurrent
-            let results = await tracker.results
 
-            // Check that at no point did we exceed 5 concurrent operations
-            #expect(maxConcurrent == 5)
-            #expect(results.count == totalTasks)
-        }
+                func decrementConcurrent() {
+                    currentConcurrent -= 1
+                }
 
-        @Test
-        func passesThroughWhenUnderConcurrencyLimit() async throws {
-            let queue = AsyncOperationQueue(concurrentTasks: 5)
-
-            let totalTasks = 5
-            let tracker = ResultsTracker()
-
-            try await withThrowingTaskGroup(of: Void.self) { group in
-                for index in 0..<totalTasks {
-                    group.addTask {
-                        try await queue.withOperation {
-                            await tracker.incrementConcurrent()
-                            try? await Task.sleep(nanoseconds: 5_000_000)
-                            await tracker.decrementConcurrent()
-                            await tracker.appendResult(index)
-                        }
-                    }
+                func appendResult(_ value: Int) {
+                    results.append(value)
                 }
-                try await group.waitForAll()
             }
 
-            let maxConcurrent = await tracker.maxConcurrent
-            let results = await tracker.results
+            @Test
+            func limitsConcurrentOperations() async throws {
+                let queue = AsyncOperationQueue(concurrentTasks: 5)
 
-            // Check that we never exceeded the concurrency limit
-            #expect(maxConcurrent <= 5)
-            #expect(results.count == totalTasks)
-        }
+                let totalTasks = 20
+                let tracker = ResultsTracker()
 
-        @Test
-        func handlesImmediateCancellation() async throws {
-            let queue = AsyncOperationQueue(concurrentTasks: 5)
-            let totalTasks = 20
-            let tracker = ResultsTracker()
-
-            await #expect(throws: _Concurrency.CancellationError.self) {
                 try await withThrowingTaskGroup(of: Void.self) { group in
-                    // Cancel the task group immediately
-                    group.cancelAll()
-
                     for index in 0..<totalTasks {
                         group.addTask {
                             try await queue.withOperation {
-                                if Task.isCancelled {
-                                    throw _Concurrency.CancellationError()
-                                }
                                 await tracker.incrementConcurrent()
-                                // sleep for a long time to ensure cancellation can occur.
-                                // If this is too short the cancellation may be triggered after
-                                // all tasks have completed.
-                                try await Task.sleep(nanoseconds: 10_000_000_000)
+                                try? await Task.sleep(nanoseconds: 5_000_000)
                                 await tracker.decrementConcurrent()
                                 await tracker.appendResult(index)
                             }
@@ -221,29 +149,26 @@ struct ConcurrencyHelpersTest {
                     }
                     try await group.waitForAll()
                 }
-            }
 
-            let maxConcurrent = await tracker.maxConcurrent
-            let results = await tracker.results
+                let maxConcurrent = await tracker.maxConcurrent
+                let results = await tracker.results
 
-            #expect(maxConcurrent <= 5)
-            #expect(results.count < totalTasks)
-        }
+                // Check that at no point did we exceed 5 concurrent operations
+                #expect(maxConcurrent == 5)
+                #expect(results.count == totalTasks)
+            }
 
-        @Test
-        func handlesCancellationDuringWait() async throws {
-            let queue = AsyncOperationQueue(concurrentTasks: 5)
-            let totalTasks = 20
-            let tracker = ResultsTracker()
+            @Test
+            func passesThroughWhenUnderConcurrencyLimit() async throws {
+                let queue = AsyncOperationQueue(concurrentTasks: 5)
+
+                let totalTasks = 5
+                let tracker = ResultsTracker()
 
-            await #expect(throws: _Concurrency.CancellationError.self) {
                 try await withThrowingTaskGroup(of: Void.self) { group in
                     for index in 0..<totalTasks {
                         group.addTask {
                             try await queue.withOperation {
-                                if Task.isCancelled {
-                                    throw _Concurrency.CancellationError()
-                                }
                                 await tracker.incrementConcurrent()
                                 try? await Task.sleep(nanoseconds: 5_000_000)
                                 await tracker.decrementConcurrent()
@@ -251,19 +176,90 @@ struct ConcurrencyHelpersTest {
                             }
                         }
                     }
+                    try await group.waitForAll()
+                }
+
+                let maxConcurrent = await tracker.maxConcurrent
+                let results = await tracker.results
+
+                // Check that we never exceeded the concurrency limit
+                #expect(maxConcurrent <= 5)
+                #expect(results.count == totalTasks)
+            }
+
+            @Test
+            func handlesImmediateCancellation() async throws {
+                let queue = AsyncOperationQueue(concurrentTasks: 5)
+                let totalTasks = 20
+                let tracker = ResultsTracker()
 
-                    group.addTask { [group] in
+                await #expect(throws: _Concurrency.CancellationError.self) {
+                    try await withThrowingTaskGroup(of: Void.self) { group in
+                        // Cancel the task group immediately
                         group.cancelAll()
+
+                        for index in 0..<totalTasks {
+                            group.addTask {
+                                try await queue.withOperation {
+                                    if Task.isCancelled {
+                                        throw _Concurrency.CancellationError()
+                                    }
+                                    await tracker.incrementConcurrent()
+                                    // sleep for a long time to ensure cancellation can occur.
+                                    // If this is too short the cancellation may be triggered after
+                                    // all tasks have completed.
+                                    try await Task.sleep(nanoseconds: 10_000_000_000)
+                                    await tracker.decrementConcurrent()
+                                    await tracker.appendResult(index)
+                                }
+                            }
+                        }
+                        try await group.waitForAll()
                     }
-                    try await group.waitForAll()
                 }
+
+                let maxConcurrent = await tracker.maxConcurrent
+                let results = await tracker.results
+
+                #expect(maxConcurrent <= 5)
+                #expect(results.count < totalTasks)
             }
 
-            let maxConcurrent = await tracker.maxConcurrent
-            let results = await tracker.results
+            @Test
+            func handlesCancellationDuringWait() async throws {
+                let queue = AsyncOperationQueue(concurrentTasks: 5)
+                let totalTasks = 20
+                let tracker = ResultsTracker()
+
+                await #expect(throws: _Concurrency.CancellationError.self) {
+                    try await withThrowingTaskGroup(of: Void.self) { group in
+                        for index in 0..<totalTasks {
+                            group.addTask {
+                                try await queue.withOperation {
+                                    if Task.isCancelled {
+                                        throw _Concurrency.CancellationError()
+                                    }
+                                    await tracker.incrementConcurrent()
+                                    try? await Task.sleep(nanoseconds: 5_000_000)
+                                    await tracker.decrementConcurrent()
+                                    await tracker.appendResult(index)
+                                }
+                            }
+                        }
+
+                        group.addTask { [group] in
+                            group.cancelAll()
+                        }
+                        try await group.waitForAll()
+                    }
+                }
+
+                let maxConcurrent = await tracker.maxConcurrent
+                let results = await tracker.results
 
-            #expect(maxConcurrent <= 5)
-            #expect(results.count < totalTasks)
+                #expect(maxConcurrent <= 5)
+                #expect(results.count < totalTasks)
+            }
         }
     }
 }
diff --git a/Tests/CommandsTests/RunCommandTests.swift b/Tests/CommandsTests/RunCommandTests.swift
index 2eebe108e76..40564e2d680 100644
--- a/Tests/CommandsTests/RunCommandTests.swift
+++ b/Tests/CommandsTests/RunCommandTests.swift
@@ -154,55 +154,56 @@ class RunCommandTestCase: CommandsBuildProviderTestCase {
     }
 
     func testSwiftRunSIGINT() throws {
-        try XCTSkipIfPlatformCI(because: "This seems to be flaky in CI")
-        try XCTSkipIfselfHostedCI(because: "This seems to be flaky in CI")
+        // try XCTSkipIfPlatformCI(because: "This seems to be flaky in CI")
+        // try XCTSkipIfselfHostedCI(because: "This seems to be flaky in CI")
+
         try fixture(name: "Miscellaneous/SwiftRun") { fixturePath in
-            let mainFilePath = fixturePath.appending("main.swift")
-            try localFileSystem.removeFileTree(mainFilePath)
-            try localFileSystem.writeFileContents(
-                mainFilePath,
-                string: """
+            // write the test executable
+            let mainFile = fixturePath.appending("main.swift")
+            try localFileSystem.removeFileTree(mainFile)
+            try localFileSystem.writeFileContents(mainFile, string: """
                 import Foundation
-
                 print("sleeping")
                 fflush(stdout)
-
                 Thread.sleep(forTimeInterval: 10)
                 print("done")
-                """
-            )
-
-            let sync = DispatchGroup()
-            let outputHandler = OutputHandler(sync: sync)
+                """)
 
+            let startedExp = expectation(description: "Process prints 'sleeping'")
             var environment = Environment.current
             environment["SWIFTPM_EXEC_NAME"] = "swift-run"
             let process = AsyncProcess(
-                arguments: [SwiftPM.Run.xctestBinaryPath.pathString, "--package-path", fixturePath.pathString],
+                arguments: [
+                    SwiftPM.Run.xctestBinaryPath.pathString,
+                    "--package-path", fixturePath.pathString
+                ],
                 environment: environment,
-                outputRedirection: .stream(stdout: outputHandler.handle(bytes:), stderr: outputHandler.handle(bytes:))
+                outputRedirection: .stream(
+                    stdout: { bytes in
+                        // convert bytes -> string line
+                        if let line = String(data: Data(bytes), encoding: .utf8)?
+                                         .trimmingCharacters(in: .newlines),
+                           line == "sleeping"
+                        {
+                            startedExp.fulfill()
+                        }
+                    },
+                    stderr: { _ in /* ignore */ }
+                )
             )
 
-            sync.enter()
             try process.launch()
-
-            // wait for the process to start
-            if case .timedOut = sync.wait(timeout: .now() + 60) {
-                return XCTFail("timeout waiting for process to start")
-            }
-
-            // interrupt the process
-            print("interrupting")
+            wait(for: [startedExp], timeout: 10.0)
             process.signal(SIGINT)
 
-            // check for interrupt result
             let result = try process.waitUntilExit()
-#if os(Windows)
+        #if os(Windows)
             XCTAssertEqual(result.exitStatus, .abnormal(exception: 2))
-#else
+        #else
             XCTAssertEqual(result.exitStatus, .signalled(signal: SIGINT))
-#endif
+        #endif
         }
+    }
 
         class OutputHandler {
             let sync: DispatchGroup
@@ -248,7 +249,7 @@ class RunCommandTestCase: CommandsBuildProviderTestCase {
         }
     }
 
-}
+
 
 class RunCommandNativeTests: RunCommandTestCase {
     override open var buildSystemProvider: BuildSystemProvider.Kind {