Update xUnit to display output on failures (XCTest only)

For XCTest, the generated xUnit XML file is not helpful when tests fail
as it contains the message "failure", which is redundant with the test
results.

Add a hidden flag (--xunit-message-failure) that will update the XML
output to dipslay the result output instead of static "failure" message.

Author: bkhouri

Fixtures/Miscellaneous/TestMultipleFailureSwiftTesting/Package.swift

@@ -0,0 +1,13 @@
+// swift-tools-version: 6.0
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "TestMultipleFailureSwiftTesting",
+    targets: [
+        .testTarget(
+            name: "TestMultipleFailureSwiftTestingTests"
+        )
+    ]
+)

Fixtures/Miscellaneous/TestMultipleFailureSwiftTesting/Tests/TestMultipleFailureSwiftTestingTests/TestMultipleFailureSwiftTestingTests.swift

@@ -0,0 +1,41 @@
+import Testing
+
+@Test func testFailure1() async throws {
+    #expect(Bool(false), "ST Test failure 1")
+}
+
+@Test func testFailure2() async throws {
+    #expect(Bool(false), "ST Test failure 2")
+}
+
+@Test func testFailure3() async throws {
+    #expect(Bool(false), "ST Test failure 3")
+}
+
+@Test func testFailure4() async throws {
+    #expect(Bool(false), "ST Test failure 4")
+}
+
+@Test func testFailure5() async throws {
+    #expect(Bool(false), "ST Test failure 5")
+}
+
+@Test func testFailure6() async throws {
+    #expect(Bool(false), "ST Test failure 6")
+}
+
+@Test func testFailure7() async throws {
+    #expect(Bool(false), "ST Test failure 7")
+}
+
+@Test func testFailure8() async throws {
+    #expect(Bool(false), "ST Test failure 8")
+}
+
+@Test func testFailure9() async throws {
+    #expect(Bool(false), "ST Test failure 9")
+}
+
+@Test func testFailure10() async throws {
+    #expect(Bool(false), "ST Test failure 10")
+}

Fixtures/Miscellaneous/TestMultipleFailureXCTest/Package.swift

@@ -0,0 +1,13 @@
+// swift-tools-version: 5.9
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "TestMultipleFailureXCTest",
+    targets: [
+        .testTarget(
+            name: "TestMultipleFailureXCTestTests"
+        )
+    ]
+)

Fixtures/Miscellaneous/TestMultipleFailureXCTest/Tests/TestMultipleFailureXCTestTests/TestMultipleFailureXCTestTests.swift

@@ -0,0 +1,44 @@
+import XCTest
+
+final class TestMultipleFailureXCTestTests: XCTestCase {
+    func testFailure1() throws {
+        XCTAssertFalse(true, "Test failure 1")
+    }
+
+    func testFailure2() throws {
+        XCTAssertFalse(true, "Test failure 2")
+    }
+
+    func testFailure3() throws {
+        XCTAssertFalse(true, "Test failure 3")
+    }
+
+    func testFailure4() throws {
+        XCTAssertFalse(true, "Test failure 4")
+    }
+
+    func testFailure5() throws {
+        XCTAssertFalse(true, "Test failure 5")
+    }
+
+    func testFailure6() throws {
+        XCTAssertFalse(true, "Test failure 6")
+    }
+
+    func testFailure7() throws {
+        XCTAssertFalse(true, "Test failure 7")
+    }
+
+    func testFailure8() throws {
+        XCTAssertFalse(true, "Test failure 8")
+    }
+
+    func testFailure9() throws {
+        XCTAssertFalse(true, "Test failure 9")
+    }
+
+    func testFailure10() throws {
+        XCTAssertFalse(true, "Test failure 10")
+    }
+
+}

Fixtures/Miscellaneous/TestSingleFailureSwiftTesting/Package.swift

@@ -0,0 +1,13 @@
+// swift-tools-version: 5.9
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "TestFailuresSwiftTesting",
+    targets: [
+        .testTarget(
+            name: "TestFailuresSwiftTestingTests"
+        )
+    ]
+)

Fixtures/Miscellaneous/TestSingleFailureSwiftTesting/Tests/TestFailuresSwiftTestingTests/TestFailuresSwiftTestingTests.swift

@@ -0,0 +1,5 @@
+import Testing
+
+@Test func example() async throws {
+    #expect(Bool(false), "Purposely failing & validating XML espace \"'<>")
+}

Fixtures/Miscellaneous/TestSingleFailureXCTest/Package.swift

@@ -0,0 +1,13 @@
+// swift-tools-version: 5.9
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "TestFailures",
+    targets: [
+        .testTarget(
+            name: "TestFailuresTests"
+        )
+    ]
+)

Fixtures/Miscellaneous/TestSingleFailureXCTest/Tests/TestFailuresTests/TestFailuresTests.swift

@@ -0,0 +1,8 @@
+import XCTest
+
+final class TestFailuresTests: XCTestCase {
+    func testExample() throws {
+        XCTAssertFalse(true, "Purposely failing & validating XML espace \"'<>")
+    }
+}
+

Sources/Commands/SwiftTestCommand.swift

@@ -188,6 +188,15 @@ struct TestCommandOptions: ParsableArguments {
             help: "Path where the xUnit xml file should be generated.")
     var xUnitOutput: AbsolutePath?
 
+    @Flag(
+        name: .customLong("experimental-xunit-message-failure"),
+        help: ArgumentHelp(
+            "When Set, enabled an experimental message failure content (XCTest only).",
+            visibility: .hidden
+        )
+    )
+    var shouldShowDetailedFailureMessage: Bool = false
+
     /// Generate LinuxMain entries and exit.
     @Flag(name: .customLong("testable-imports"), inversion: .prefixedEnableDisable, help: "Enable or disable testable imports. Enabled by default.")
     var enableTestableImports: Bool = true
@@ -330,7 +339,11 @@ public struct SwiftTestCommand: AsyncSwiftCommand {
                     result = runner.ranSuccessfully ? .success : .failure
                 }
 
-                try generateXUnitOutputIfRequested(for: testResults, swiftCommandState: swiftCommandState)
+                try generateXUnitOutputIfRequested(
+                    for: testResults,
+                    swiftCommandState: swiftCommandState,
+                    detailedFailureMessage: self.options.shouldShowDetailedFailureMessage
+                )
                 results.append(result)
             }
         }
@@ -406,7 +419,8 @@ public struct SwiftTestCommand: AsyncSwiftCommand {
     /// Generate xUnit file if requested.
     private func generateXUnitOutputIfRequested(
         for testResults: [ParallelTestRunner.TestResult],
-        swiftCommandState: SwiftCommandState
+        swiftCommandState: SwiftCommandState,
+        detailedFailureMessage: Bool
     ) throws {
         guard let xUnitOutput = options.xUnitOutput else {
             return
@@ -416,7 +430,7 @@ public struct SwiftTestCommand: AsyncSwiftCommand {
             fileSystem: swiftCommandState.fileSystem,
             results: testResults
         )
-        try generator.generate(at: xUnitOutput)
+        try generator.generate(at: xUnitOutput, detailedFailureMessage: detailedFailureMessage)
     }
 
     // MARK: - Common implementation
@@ -1371,7 +1385,7 @@ final class XUnitGenerator {
     }
 
     /// Generate the file at the given path.
-    func generate(at path: AbsolutePath) throws {
+    func generate(at path: AbsolutePath, detailedFailureMessage: Bool) throws {
         var content =
             """
             <?xml version="1.0" encoding="UTF-8"?>
@@ -1404,7 +1418,15 @@ final class XUnitGenerator {
                 """
 
             if !result.success {
-                content += "<failure message=\"failed\"></failure>\n"
+                var failureMessage: String = "failed"
+                if detailedFailureMessage {
+                    failureMessage = result.output
+                    failureMessage.replace("&", with: "&amp;")
+                    failureMessage.replace("\"", with:"&quot;")
+                    failureMessage.replace(">", with: "&gt;")
+                    failureMessage.replace("<", with: "&lt;")
+                }
+                content += "<failure message=\"\(failureMessage)\"></failure>\n"
             }
 
             content += "</testcase>\n"

Sources/_InternalTestSupport/SwiftPMProduct.swift

@@ -82,7 +82,8 @@ extension SwiftPM {
     public func execute(
         _ args: [String] = [],
         packagePath: AbsolutePath? = nil,
-        env: Environment? = nil
+        env: Environment? = nil,
+        errorIfCommandUnsuccessful: Bool = true
     ) async throws -> (stdout: String, stderr: String) {
         let result = try await executeProcess(
             args,
@@ -93,8 +94,11 @@ extension SwiftPM {
         let stdout = try result.utf8Output()
         let stderr = try result.utf8stderrOutput()
 
+        let returnValue = (stdout: stdout, stderr: stderr)
+        if (!errorIfCommandUnsuccessful) { return returnValue }
+
         if result.exitStatus == .terminated(code: 0) {
-            return (stdout: stdout, stderr: stderr)
+            return returnValue
         }
         throw SwiftPMError.executionFailure(
             underlying: AsyncProcessResult.Error.nonZeroExit(result),