Apply toolset's testRunner property in swift test (#8254)

### Motivation:

Per [SE-0378 toolsets can specify an optional `testRunner` property](https://github.com/swiftlang/swift-evolution/blob/main/proposals/0387-cross-compilation-destinations.md#toolsetjson-files), which so far had no effect. We should respect this property in `swift test` invocations when any toolsets or Swift SDKs are selected.

This property specifies a path to a test harness that has implementation-specific knowledge of interpreting produced test bundles.

This allows testing cross-compiled products in an environment other than the host, e.g. a container runtime when cross-compiled to Linux, qemu or a firmware flasher and serial port setup script with Swift Embedded for microcontrollers, or in a Wasm runtime for a WASI binary.

### Modifications:

Updated SwiftRunCommand to check for the debugger property in toolsets or Swift SDKs when such are specified. Its value is then used to launch a freshly built binary.

Changed test bundle extension from `.wasm` to `.xctest` used for other platforms to reduce special casing in corresponding code paths. Without this change, initial implementation crashed here in the `bundlePath`
property, triggering `fatalError`, as lookup logic always assumes `.xctest` extension: https://github.com/swiftlang/swift-package-manager/blob/6aa009fd30992c3cba9af3fcb439ef57b61b75da/Sources/SPMBuildCore/BuiltTestProduct.swift#L35

### Result:

Cross-compiled tests can be directly launched with a `swift test` invocation.

Author: MaxDesiatov

Fixtures/Miscellaneous/EchoExecutable/Package.swift

@@ -7,5 +7,6 @@ let package = Package(
         .executable(name: "secho", targets: ["secho"])
     ],
     targets: [
-        .target(name: "secho", dependencies: [])
-    ])
+        .target(name: "secho", dependencies: []),
+        .testTarget(name: "TestSuite")
+    ])

Fixtures/Miscellaneous/EchoExecutable/Tests/TestSuite/Tests.swift

@@ -0,0 +1,7 @@
+import XCTest
+
+final class TestCase: XCTestCase {
+    func testFoo() {
+        XCTAssertTrue(true)
+    }
+}

Fixtures/Miscellaneous/EchoExecutable/echo.sh

@@ -1,3 +1,4 @@
 #!/bin/sh
 
+echo sentinel
 echo "$@"

Fixtures/Miscellaneous/EchoExecutable/toolset.json

@@ -1,5 +1,6 @@
 {
   "debugger": { "path": "echo.sh" },
+  "testRunner": { "path": "echo.sh" },
   "schemaVersion" : "1.0",
   "rootPath" : "."
 }

Sources/Commands/SwiftTestCommand.swift

@@ -948,23 +948,31 @@ final class TestRunner {
     /// Constructs arguments to execute XCTest.
     private func args(forTestAt testPath: AbsolutePath) throws -> [String] {
         var args: [String] = []
+
+        if let runner = self.toolchain.swiftSDK.toolset.knownTools[.testRunner], let runnerPath = runner.path {
+            args.append(runnerPath.pathString)
+            args.append(contentsOf: runner.extraCLIOptions)
+            args.append(testPath.relative(to: localFileSystem.currentWorkingDirectory!).pathString)
+            args.append(contentsOf: self.additionalArguments)
+        } else {
 #if os(macOS)
-        switch library {
-        case .xctest:
-            guard let xctestPath = self.toolchain.xctestPath else {
-                throw TestError.xcodeNotInstalled
+            switch library {
+            case .xctest:
+                guard let xctestPath = self.toolchain.xctestPath else {
+                    throw TestError.xcodeNotInstalled
+                }
+                args += [xctestPath.pathString]
+            case .swiftTesting:
+                let helper = try self.toolchain.getSwiftTestingHelper()
+                args += [helper.pathString, "--test-bundle-path", testPath.pathString]
             }
-            args += [xctestPath.pathString]
-        case .swiftTesting:
-            let helper = try self.toolchain.getSwiftTestingHelper()
-            args += [helper.pathString, "--test-bundle-path", testPath.pathString]
+            args += self.additionalArguments
+            args += [testPath.pathString]
+    #else
+            args += [testPath.pathString]
+            args += self.additionalArguments
+    #endif
         }
-        args += additionalArguments
-        args += [testPath.pathString]
-#else
-        args += [testPath.pathString]
-        args += additionalArguments
-#endif
 
         if library == .swiftTesting {
             // HACK: tell the test bundle/executable that we want to run Swift Testing, not XCTest.

Sources/SPMBuildCore/BuildParameters/BuildParameters.swift

@@ -302,9 +302,6 @@ public struct BuildParameters: Encodable {
         case .library(.automatic), .plugin:
             fatalError()
         case .test:
-            guard !self.triple.isWasm else {
-                return try RelativePath(validating: "\(product.name).wasm")
-            }
             let base = "\(product.name).xctest"
             if self.triple.isDarwin() {
                 return try RelativePath(validating: "\(base)/Contents/MacOS/\(product.name)")

Tests/BuildTests/CrossCompilationBuildPlanTests.swift

@@ -210,7 +210,7 @@ final class CrossCompilationBuildPlanTests: XCTestCase {
             [
                 result.plan.destinationBuildParameters.toolchain.swiftCompilerPath.pathString,
                 "-L", buildPath.pathString,
-                "-o", buildPath.appending(components: "PkgPackageTests.wasm").pathString,
+                "-o", buildPath.appending(components: "PkgPackageTests.xctest").pathString,
                 "-module-name", "PkgPackageTests",
                 "-emit-executable",
                 "@\(buildPath.appending(components: "PkgPackageTests.product", "Objects.LinkFileList"))",
@@ -220,7 +220,7 @@ final class CrossCompilationBuildPlanTests: XCTestCase {
         )
 
         let testPathExtension = try testBuildDescription.binaryPath.extension
-        XCTAssertEqual(testPathExtension, "wasm")
+        XCTAssertEqual(testPathExtension, "xctest")
     }
 
     func testMacros() async throws {

Tests/CommandsTests/RunCommandTests.swift

@@ -48,9 +48,8 @@ final class RunCommandTests: CommandsTestCase {
                 ["--toolset", "\(fixturePath)/toolset.json"], packagePath: fixturePath)
 
             // We only expect tool's output on the stdout stream.
-            XCTAssertMatch(stdout, .contains("""
-                \(fixturePath)/.build
-                """))
+            XCTAssertMatch(stdout, .contains("\(fixturePath)/.build"))
+            XCTAssertMatch(stdout, .contains("sentinel"))
 
             // swift-build-tool output should go to stderr.
             XCTAssertMatch(stderr, .regex("Compiling"))

Tests/CommandsTests/TestCommandTests.swift

@@ -36,6 +36,24 @@ final class TestCommandTests: CommandsTestCase {
         XCTAssert(stdout.contains("Swift Package Manager"), "got stdout:\n" + stdout)
     }
 
+    // `runner.sh` script from the toolset won't work on Windows
+    #if !os(Windows)
+        func testToolsetRunner() async throws {
+            try await fixture(name: "Miscellaneous/EchoExecutable") { fixturePath in
+                let (stdout, stderr) = try await SwiftPM.Test.execute(
+                    ["--toolset", "\(fixturePath)/toolset.json"], packagePath: fixturePath)
+
+                // We only expect tool's output on the stdout stream.
+                XCTAssertMatch(stdout, .contains("sentinel"))
+                XCTAssertMatch(stdout, .contains("\(fixturePath)"))
+
+                // swift-build-tool output should go to stderr.
+                XCTAssertMatch(stderr, .regex("Compiling"))
+                XCTAssertMatch(stderr, .contains("Linking"))
+            }
+        }
+    #endif
+
     func testNumWorkersParallelRequirement() async throws {
         #if !os(macOS)
         // Running swift-test fixtures on linux is not yet possible.