Create an xunit results file even if no tests are run.

This PR ensures that when `--xunit-output` is passed to `swift test --parallel`, the output XML file is generated even if no tests are run.

Failure modes outside of test failures (i.e. errors thrown during the build process or when trying to run the test process) will still prevent the generation of this file.

Resolves #7065.

Author: grynspan

Fixtures/Miscellaneous/EmptyTestsPkg/.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+/.build
+/Packages
+/*.xcodeproj

Fixtures/Miscellaneous/EmptyTestsPkg/Package.swift

@@ -0,0 +1,14 @@
+// swift-tools-version:4.2
+import PackageDescription
+
+let package = Package(
+    name: "EmptyTestsPkg",
+    targets: [
+        .target(
+            name: "EmptyTestsPkg",
+            dependencies: []),
+        .testTarget(
+            name: "EmptyTestsPkgTests",
+            dependencies: ["EmptyTestsPkg"]),
+    ]
+)

Fixtures/Miscellaneous/EmptyTestsPkg/Sources/EmptyTestsPkg/EmptyTestsPkg.swift

@@ -0,0 +1,5 @@
+struct EmptyTests {
+
+    var text = "Hello, World!"
+    var bool = false
+}

Fixtures/Miscellaneous/EmptyTestsPkg/Tests/EmptyTestsPkgTests/EmptyTestsTests.swift

@@ -0,0 +1,2 @@
+import XCTest
+@testable import EmptyTestsPkg

Sources/Commands/SwiftTestTool.swift

@@ -237,32 +237,45 @@ public struct SwiftTestTool: SwiftCommand {
             let tests = try testSuites
                 .filteredTests(specifier: options.testCaseSpecifier)
                 .skippedTests(specifier: options.skippedTests(fileSystem: swiftTool.fileSystem))
+            var testResults = [ParallelTestRunner.TestResult]()
 
             // If there were no matches, emit a warning and exit.
             if tests.isEmpty {
                 swiftTool.observabilityScope.emit(.noMatchingTests)
-                return
-            }
+            } else {
+                // Clean out the code coverage directory that may contain stale
+                // profraw files from a previous run of the code coverage tool.
+                if self.options.enableCodeCoverage {
+                    try swiftTool.fileSystem.removeFileTree(buildParameters.codeCovPath)
+                }
 
-            // Clean out the code coverage directory that may contain stale
-            // profraw files from a previous run of the code coverage tool.
-            if self.options.enableCodeCoverage {
-                try swiftTool.fileSystem.removeFileTree(buildParameters.codeCovPath)
-            }
+                // Run the tests using the parallel runner.
+                let runner = ParallelTestRunner(
+                    bundlePaths: testProducts.map { $0.bundlePath },
+                    cancellator: swiftTool.cancellator,
+                    toolchain: toolchain,
+                    numJobs: options.numberOfWorkers ?? ProcessInfo.processInfo.activeProcessorCount,
+                    buildOptions: globalOptions.build,
+                    buildParameters: buildParameters,
+                    shouldOutputSuccess: swiftTool.logLevel <= .info,
+                    observabilityScope: swiftTool.observabilityScope
+                )
 
-            // Run the tests using the parallel runner.
-            let runner = ParallelTestRunner(
-                bundlePaths: testProducts.map { $0.bundlePath },
-                cancellator: swiftTool.cancellator,
-                toolchain: toolchain,
-                numJobs: options.numberOfWorkers ?? ProcessInfo.processInfo.activeProcessorCount,
-                buildOptions: globalOptions.build,
-                buildParameters: buildParameters,
-                shouldOutputSuccess: swiftTool.logLevel <= .info,
-                observabilityScope: swiftTool.observabilityScope
-            )
+                testResults = try runner.run(tests)
+
+                // process code Coverage if request
+                if self.options.enableCodeCoverage, runner.ranSuccessfully {
+                    try processCodeCoverage(testProducts, swiftTool: swiftTool, library: .xctest)
+                }
 
-            let testResults = try runner.run(tests)
+                if !runner.ranSuccessfully {
+                    swiftTool.executionStatus = .failure
+                }
+
+                if self.options.enableExperimentalTestOutput, !runner.ranSuccessfully {
+                    try Self.handleTestOutput(buildParameters: buildParameters, packagePath: testProducts[0].packagePath)
+                }
+            }
 
             // Generate xUnit file if requested
             if let xUnitOutput = options.xUnitOutput {
@@ -272,19 +285,6 @@ public struct SwiftTestTool: SwiftCommand {
                 )
                 try generator.generate(at: xUnitOutput)
             }
-
-            // process code Coverage if request
-            if self.options.enableCodeCoverage, runner.ranSuccessfully {
-                try processCodeCoverage(testProducts, swiftTool: swiftTool, library: .xctest)
-            }
-
-            if !runner.ranSuccessfully {
-                swiftTool.executionStatus = .failure
-            }
-
-            if self.options.enableExperimentalTestOutput, !runner.ranSuccessfully {
-                try Self.handleTestOutput(buildParameters: buildParameters, packagePath: testProducts[0].packagePath)
-            }
         }
     }
 

Tests/CommandsTests/TestToolTests.swift

@@ -128,6 +128,22 @@ final class TestToolTests: CommandsTestCase {
         }
     }
 
+    func testSwiftTestXMLOutputWhenEmpty() throws {
+        try fixture(name: "Miscellaneous/EmptyTestsPkg") { fixturePath in
+            let xUnitOutput = fixturePath.appending("result.xml")
+            // Run tests in parallel with verbose output.
+            let stdout = try SwiftPM.Test.execute(["--parallel", "--verbose", "--xunit-output", xUnitOutput.pathString], packagePath: fixturePath).stdout
+            // in "swift test" test output goes to stdout
+            XCTAssertNoMatch(stdout, .contains("passed"))
+            XCTAssertNoMatch(stdout, .contains("failed"))
+
+            // Check the xUnit output.
+            XCTAssertFileExists(xUnitOutput)
+            let contents: String = try localFileSystem.readFileContents(xUnitOutput)
+            XCTAssertMatch(contents, .contains("tests=\"0\" failures=\"0\""))
+        }
+    }
+
     func testSwiftTestFilter() throws {
         try fixture(name: "Miscellaneous/SkipTests") { fixturePath in
             let (stdout, _) = try SwiftPM.Test.execute(["--filter", ".*1"], packagePath: fixturePath)