Test sanitizers with build plans.

Tests/BuildTests/BuildPlanTests.swift

@@ -2351,6 +2351,73 @@ final class BuildPlanTests: XCTestCase {
         let dynamicLibraryPathExtension = try result.buildProduct(for: "Library").binary.extension
         XCTAssertMatch(dynamicLibraryPathExtension, "dylib")
     }
+
+    func testAddressSanitizer() throws {
+        try sanitizerTest(.address, expectedName: "address")
+    }
+
+    func testThreadSanitizer() throws {
+        try sanitizerTest(.thread, expectedName: "thread")
+    }
+
+    func testUndefinedSanitizer() throws {
+        try sanitizerTest(.undefined, expectedName: "undefined")
+    }
+
+    func testScudoSanitizer() throws {
+        try sanitizerTest(.scudo, expectedName: "scudo")
+    }
+
+    private func sanitizerTest(_ sanitizer: Sanitizer, expectedName: String) throws {
+        let fs = InMemoryFileSystem(emptyFiles:
+            "/Pkg/Sources/exe/main.swift",
+            "/Pkg/Sources/lib/lib.swift",
+            "/Pkg/Sources/clib/clib.c",
+            "/Pkg/Sources/clib/include/clib.h"
+        )
+
+        let diagnostics = DiagnosticsEngine()
+        let graph = loadPackageGraph(fs: fs, diagnostics: diagnostics,
+            manifests: [
+                Manifest.createV4Manifest(
+                    name: "Pkg",
+                    path: "/Pkg",
+                    url: "/Pkg",
+                    packageKind: .root,
+                    targets: [
+                        TargetDescription(name: "exe", dependencies: ["lib", "clib"]),
+                        TargetDescription(name: "lib", dependencies: []),
+                        TargetDescription(name: "clib", dependencies: []),
+                    ]),
+            ]
+        )
+        XCTAssertNoDiagnostics(diagnostics)
+
+        // Unrealistic: we can't enable all of these at once on all platforms.
+        // This test codifies current behaviour, not ideal behaviour, and
+        // may need to be amended if we change it.
+        var parameters = mockBuildParameters(shouldLinkStaticSwiftStdlib: true)
+        parameters.sanitizers = EnabledSanitizers([sanitizer])
+
+        let result = BuildPlanResult(plan: try BuildPlan(
+            buildParameters: parameters,
+            graph: graph, diagnostics: diagnostics, fileSystem: fs)
+        )
+
+        result.checkProductsCount(1)
+        result.checkTargetsCount(3)
+
+        let exe = try result.target(for: "exe").swiftTarget().compileArguments()
+        XCTAssertTrue(exe.contains("-sanitize=\(expectedName)"))
+
+        let lib = try result.target(for: "lib").swiftTarget().compileArguments()
+        XCTAssertTrue(lib.contains("-sanitize=\(expectedName)"))
+
+        let clib  = try result.target(for: "clib").clangTarget().basicArguments()
+        XCTAssertTrue(clib.contains("-fsanitize=\(expectedName)"))
+
+        XCTAssertTrue(try result.buildProduct(for: "exe").linkArguments().contains("-sanitize=\(expectedName)"))
+    }
 }
 
 // MARK:- Test Helpers

Tests/CommandsTests/RunToolTests.swift

@@ -103,52 +103,4 @@ final class RunToolTests: XCTestCase {
             }
         }
     }
-
-    // Test that thread sanitizer works.
-    func testSanitizeThread() throws {
-        // FIXME: We need to figure out how to test this for linux.
-      #if os(macOS)
-        fixture(name: "Miscellaneous/ThreadRace") { path in
-            // Ensure that we don't abort() when we find the race. This avoids
-            // generating the crash report on macOS.
-            let env = ["TSAN_OPTIONS": "abort_on_error=0"]
-            let cmdline = {
-                try SwiftPMProduct.SwiftRun.execute(
-                    ["--sanitize=thread"], packagePath: path, env: env)
-            }
-            XCTAssertThrows(try cmdline()) { (error: SwiftPMProductError) in
-                switch error {
-                case .executionFailure(_, _, let error):
-                    XCTAssertMatch(error, .contains("ThreadSanitizer: data race"))
-                    return true
-                default:
-                    return false
-                }
-            }
-        }
-      #endif
-    }
-
-    func testSanitizeScudo() throws {
-        // Scudo is only supported on Linux.
-      #if os(Linux)
-        fixture(name: "Miscellaneous/DoubleFree") { path in
-            // Ensure that we don't abort() when we find the race. This avoids
-            // generating the crash report on macOS.
-            let cmdline = {
-                try SwiftPMProduct.SwiftRun.execute(
-                    ["--sanitize=scudo"], packagePath: path)
-            }
-            XCTAssertThrows(try cmdline()) { (error: SwiftPMProductError) in
-                switch error {
-                case .executionFailure(_, _, let error):
-                    XCTAssertMatch(error, .contains("invalid chunk state"))
-                    return true
-                default:
-                    return false
-                }
-            }
-        }
-      #endif
-    }
 }

Tests/CommandsTests/TestToolTests.swift

@@ -30,32 +30,6 @@ final class TestToolTests: XCTestCase {
         XCTAssert(try execute(["--version"]).stdout.contains("Swift Package Manager"))
     }
 
-    // Test that thread sanitizer works.
-    func testSanitizeThread() throws {
-        // FIXME: We need to figure out how to test this for linux.
-        // Disabled because of https://bugs.swift.org/browse/SR-7272
-      #if false
-        fixture(name: "Miscellaneous/ThreadRace") { path in
-            // Ensure that we don't abort() when we find the race. This avoids
-            // generating the crash report on macOS.
-            let env = ["TSAN_OPTIONS": "abort_on_error=0"]
-            let cmdline = {
-                try SwiftPMProduct.SwiftTest.execute(
-                    ["--sanitize=thread"], packagePath: path, env: env)
-            }
-            XCTAssertThrows(try cmdline()) { (error: SwiftPMProductError) in
-                switch error {
-                case .executionFailure(_, _, let error):
-                    XCTAssertMatch(error, .contains("ThreadSanitizer: data race"))
-                    return true
-                default:
-                    return false
-                }
-            }
-        }
-      #endif
-    }
-
     func testNumWorkersParallelRequeriment() throws {
         // Running swift-test fixtures on linux is not yet possible.
         #if os(macOS)
@@ -80,25 +54,4 @@ final class TestToolTests: XCTestCase {
         }
         #endif
     }
-
-    func testSanitizeScudo() throws {
-        // This test only runs on Linux because Scudo only runs on Linux
-      #if os(Linux)
-        fixture(name: "Miscellaneous/DoubleFree") { path in
-            let cmdline = {
-                try SwiftPMProduct.SwiftTest.execute(
-                    ["--sanitize=scudo"], packagePath: path)
-            }
-            XCTAssertThrows(try cmdline()) { (error: SwiftPMProductError) in
-                switch error {
-                case .executionFailure(_, _, let error):
-                    XCTAssertMatch(error, .contains("invalid chunk state"))
-                    return true
-                default:
-                    return false
-                }
-            }
-        }
-      #endif
-    }
 }