Make sure --parallel works

Author: grynspan

Sources/Commands/SwiftTestCommand.swift

@@ -240,62 +240,69 @@ public struct SwiftTestCommand: AsyncSwiftCommand {
             _ = try? localFileSystem.removeFileTree(buildParameters.testOutputPath)
         }
 
-        if !self.options.shouldRunInParallel {
-            if options.testLibraryOptions.enableXCTestSupport {
+        var ranSuccessfully = true
+
+        // Run XCTest.
+        if options.testLibraryOptions.enableXCTestSupport {
+            if !self.options.shouldRunInParallel {
                 let xctestArgs = try xctestArgs(for: testProducts, swiftCommandState: swiftCommandState)
-                try await runTestProducts(
+                ranSuccessfully = try await runTestProducts(
                     testProducts,
                     additionalArguments: xctestArgs,
                     productsBuildParameters: buildParameters,
                     swiftCommandState: swiftCommandState,
                     library: .xctest
-                )
-            }
-            if options.testLibraryOptions.enableSwiftTestingLibrarySupport {
-                try await runTestProducts(
-                    testProducts,
-                    additionalArguments: [],
-                    productsBuildParameters: buildParameters,
+                ) && ranSuccessfully
+            } else {
+                let testSuites = try TestingSupport.getTestSuites(
+                    in: testProducts,
                     swiftCommandState: swiftCommandState,
-                    library: .swiftTesting
+                    enableCodeCoverage: options.enableCodeCoverage,
+                    shouldSkipBuilding: options.sharedOptions.shouldSkipBuilding,
+                    experimentalTestOutput: options.enableExperimentalTestOutput,
+                    sanitizers: globalOptions.build.sanitizers
                 )
-            }
-        } else {
-            let testSuites = try TestingSupport.getTestSuites(
-                in: testProducts,
-                swiftCommandState: swiftCommandState,
-                enableCodeCoverage: options.enableCodeCoverage,
-                shouldSkipBuilding: options.sharedOptions.shouldSkipBuilding,
-                experimentalTestOutput: options.enableExperimentalTestOutput,
-                sanitizers: globalOptions.build.sanitizers
-            )
-            let tests = try testSuites
-                .filteredTests(specifier: options.testCaseSpecifier)
-                .skippedTests(specifier: options.skippedTests(fileSystem: swiftCommandState.fileSystem))
+                let tests = try testSuites
+                    .filteredTests(specifier: options.testCaseSpecifier)
+                    .skippedTests(specifier: options.skippedTests(fileSystem: swiftCommandState.fileSystem))
 
-            // Run the tests using the parallel runner.
-            let runner = ParallelTestRunner(
-                bundlePaths: testProducts.map { $0.bundlePath },
-                cancellator: swiftCommandState.cancellator,
-                toolchain: toolchain,
-                numJobs: options.numberOfWorkers ?? ProcessInfo.processInfo.activeProcessorCount,
-                buildOptions: globalOptions.build,
-                productsBuildParameters: buildParameters,
-                shouldOutputSuccess: swiftCommandState.logLevel <= .info,
-                observabilityScope: swiftCommandState.observabilityScope
-            )
+                // Run the tests using the parallel runner.
+                let runner = ParallelTestRunner(
+                    bundlePaths: testProducts.map { $0.bundlePath },
+                    cancellator: swiftCommandState.cancellator,
+                    toolchain: toolchain,
+                    numJobs: options.numberOfWorkers ?? ProcessInfo.processInfo.activeProcessorCount,
+                    buildOptions: globalOptions.build,
+                    productsBuildParameters: buildParameters,
+                    shouldOutputSuccess: swiftCommandState.logLevel <= .info,
+                    observabilityScope: swiftCommandState.observabilityScope
+                )
 
-            let testResults = try runner.run(tests)
+                let testResults = try runner.run(tests)
 
-            try generateXUnitOutputIfRequested(for: testResults, swiftCommandState: swiftCommandState)
+                try generateXUnitOutputIfRequested(for: testResults, swiftCommandState: swiftCommandState)
 
-            if !runner.ranSuccessfully {
-                swiftCommandState.executionStatus = .failure
+                ranSuccessfully = ranSuccessfully && runner.ranSuccessfully
             }
+        }
 
-            if self.options.enableExperimentalTestOutput, !runner.ranSuccessfully {
-                try Self.handleTestOutput(productsBuildParameters: buildParameters, packagePath: testProducts[0].packagePath)
-            }
+        // Run Swift Testing (parallel or not, it has a single entry point.)
+        if options.testLibraryOptions.enableSwiftTestingLibrarySupport {
+            ranSuccessfully = try await runTestProducts(
+                testProducts,
+                additionalArguments: [],
+                productsBuildParameters: buildParameters,
+                swiftCommandState: swiftCommandState,
+                library: .swiftTesting
+            ) && ranSuccessfully
+        }
+
+        if !ranSuccessfully {
+            swiftCommandState.executionStatus = .failure
+        }
+
+        if self.options.enableExperimentalTestOutput, !ranSuccessfully {
+            try Self.handleTestOutput(productsBuildParameters: buildParameters, packagePath: testProducts[0].packagePath)
         }
     }
 
@@ -390,12 +397,12 @@ public struct SwiftTestCommand: AsyncSwiftCommand {
         productsBuildParameters: BuildParameters,
         swiftCommandState: SwiftCommandState,
         library: BuildParameters.Testing.Library
-    ) async throws {
+    ) async throws -> Bool {
 #if os(macOS)
         if library == .swiftTesting {
             // On macOS, the xctest executable provided with Xcode acts as a harness
             // for Swift Testing, so we don't need to run Swift Testing tests separately.
-            return
+            return true
         }
 #endif
 
@@ -424,19 +431,11 @@ public struct SwiftTestCommand: AsyncSwiftCommand {
         )
 
         // Finally, run the tests.
-        let ranSuccessfully = runner.test(outputHandler: {
+        return runner.test(outputHandler: {
             // command's result output goes on stdout
             // ie "swift test" should output to stdout
             print($0, terminator: "")
         })
-
-        if !ranSuccessfully {
-            swiftCommandState.executionStatus = .failure
-        }
-
-        if self.options.enableExperimentalTestOutput, !ranSuccessfully {
-            try Self.handleTestOutput(productsBuildParameters: productsBuildParameters, packagePath: testProducts[0].packagePath)
-        }
     }
 
     private static func handleTestOutput(productsBuildParameters: BuildParameters, packagePath: AbsolutePath) throws {