FIX - several tests to run on linux target.

Removes several target specific arguments or platform conditional checks in some SwiftDriverTests. We still need to determine what to do with tests that use specific macOS tooling such as dsymutil or libtool.

Author: JhonnyBillM

Sources/SwiftDriver/Jobs/Toolchain+LinkerSupport.swift

@@ -23,8 +23,9 @@ extension Toolchain {
     let resourceDirBase: AbsolutePath
     if let resourceDir = parsedOptions.getLastArgument(.resourceDir) {
       resourceDirBase = try AbsolutePath(validating: resourceDir.asSingle)
-    } else if let sdk = parsedOptions.getLastArgument(.sdk), !triple.isDarwin {
-      resourceDirBase = try AbsolutePath(validating: sdk.asSingle)
+    } else if let sdk = parsedOptions.getLastArgument(.sdk),
+      let sdkPath = try? AbsolutePath(validating: sdk.asSingle) {
+      resourceDirBase = sdkPath
         .appending(components: "usr", "lib",
                    isShared ? "swift" : "swift_static")
     } else {

Tests/SwiftDriverTests/SwiftDriverTests.swift

@@ -211,13 +211,9 @@ final class SwiftDriverTests: XCTestCase {
 
       XCTAssertNil(try Driver(args: ["swiftc", "-j", "0"]).numParallelJobs)
 
-      XCTAssertEqual(
-        try Driver(
-          args: ["swiftc", "-j", "4", "-target", "x86_64-apple-macosx10.15"],
-          env: ["SWIFTC_MAXIMUM_DETERMINISM": "1"]
-        ).numParallelJobs,
-        1
-      )
+      var env = ProcessEnv.vars
+      env["SWIFTC_MAXIMUM_DETERMINISM"] = "1"
+      XCTAssertEqual(try Driver(args: ["swiftc", "-j", "4"], env: env).numParallelJobs, 1)
     }
 
     func testMultithreadingDiagnostics() throws {
@@ -234,10 +230,9 @@ final class SwiftDriverTests: XCTestCase {
         $1.expect(.error("invalid value '0' in '-j'"))
       }
 
-      try assertDriverDiagnostics(
-        args: "swiftc", "-j", "8", "-target", "x86_64-apple-macosx10.15",
-        env: ["SWIFTC_MAXIMUM_DETERMINISM": "1"]
-      ) {
+      var env = ProcessEnv.vars
+      env["SWIFTC_MAXIMUM_DETERMINISM"] = "1"
+      try assertDriverDiagnostics(args: "swiftc", "-j", "8", env: env) {
         $1.expect(.remark("SWIFTC_MAXIMUM_DETERMINISM overriding -j"))
       }
     }
@@ -323,27 +318,27 @@ final class SwiftDriverTests: XCTestCase {
   }
 
   func testStandardCompileJobs() throws {
-    var driver1 = try Driver(args: ["swiftc", "foo.swift", "bar.swift", "-module-name", "Test", "-target", "x86_64-apple-macosx10.15"])
+    var driver1 = try Driver(args: ["swiftc", "foo.swift", "bar.swift", "-module-name", "Test"])
     let plannedJobs = try driver1.planBuild()
     XCTAssertEqual(plannedJobs.count, 3)
     XCTAssertEqual(plannedJobs[0].outputs.count, 1)
     XCTAssertEqual(plannedJobs[0].outputs.first!.file, VirtualPath.temporary(RelativePath("foo.o")))
     XCTAssertEqual(plannedJobs[1].outputs.count, 1)
     XCTAssertEqual(plannedJobs[1].outputs.first!.file, VirtualPath.temporary(RelativePath("bar.o")))
-    XCTAssertTrue(plannedJobs[2].tool.name.contains("ld"))
+    XCTAssertTrue(plannedJobs[2].tool.name.contains(driver1.targetTriple.isDarwin ? "ld" : "clang"))
     XCTAssertEqual(plannedJobs[2].outputs.count, 1)
     XCTAssertEqual(plannedJobs[2].outputs.first!.file, VirtualPath.relative(RelativePath("Test")))
 
     // Forwarding of arguments.
-    var driver2 = try Driver(args: ["swiftc", "-color-diagnostics", "foo.swift", "bar.swift", "-working-directory", "/tmp", "-api-diff-data-file", "diff.txt", "-Xfrontend", "-HI", "-no-color-diagnostics", "-target", "powerpc-apple-macosx10.4", "-g"])
+    var driver2 = try Driver(args: ["swiftc", "-color-diagnostics", "foo.swift", "bar.swift", "-working-directory", "/tmp", "-api-diff-data-file", "diff.txt", "-Xfrontend", "-HI", "-no-color-diagnostics", "-g"])
     let plannedJobs2 = try driver2.planBuild()
     XCTAssert(plannedJobs2[0].commandLine.contains(Job.ArgTemplate.path(.absolute(try AbsolutePath(validating: "/tmp/diff.txt")))))
     XCTAssert(plannedJobs2[0].commandLine.contains(.flag("-HI")))
     XCTAssert(!plannedJobs2[0].commandLine.contains(.flag("-Xfrontend")))
     XCTAssert(plannedJobs2[0].commandLine.contains(.flag("-no-color-diagnostics")))
     XCTAssert(!plannedJobs2[0].commandLine.contains(.flag("-color-diagnostics")))
     XCTAssert(plannedJobs2[0].commandLine.contains(.flag("-target")))
-    XCTAssert(plannedJobs2[0].commandLine.contains(.flag("powerpc-apple-macosx10.4")))
+    XCTAssert(plannedJobs2[0].commandLine.contains(.flag(driver2.targetTriple.triple)))
     XCTAssert(plannedJobs2[0].commandLine.contains(.flag("-enable-anonymous-context-mangled-names")))
 
     var driver3 = try Driver(args: ["swiftc", "foo.swift", "bar.swift", "-emit-library", "-module-name", "Test"])
@@ -752,7 +747,7 @@ final class SwiftDriverTests: XCTestCase {
   }
 
   func testBatchModeCompiles() throws {
-    var driver1 = try Driver(args: ["swiftc", "foo1.swift", "bar1.swift", "foo2.swift", "bar2.swift", "foo3.swift", "bar3.swift", "foo4.swift", "bar4.swift", "foo5.swift", "bar5.swift", "wibble.swift", "-module-name", "Test", "-target", "x86_64-apple-macosx10.15", "-enable-batch-mode", "-driver-batch-count", "3"])
+    var driver1 = try Driver(args: ["swiftc", "foo1.swift", "bar1.swift", "foo2.swift", "bar2.swift", "foo3.swift", "bar3.swift", "foo4.swift", "bar4.swift", "foo5.swift", "bar5.swift", "wibble.swift", "-module-name", "Test", "-enable-batch-mode", "-driver-batch-count", "3"])
     let plannedJobs = try driver1.planBuild()
     XCTAssertEqual(plannedJobs.count, 4)
     XCTAssertEqual(plannedJobs[0].outputs.count, 4)
@@ -761,7 +756,7 @@ final class SwiftDriverTests: XCTestCase {
     XCTAssertEqual(plannedJobs[1].outputs.first!.file, VirtualPath.temporary(RelativePath("foo3.o")))
     XCTAssertEqual(plannedJobs[2].outputs.count, 3)
     XCTAssertEqual(plannedJobs[2].outputs.first!.file, VirtualPath.temporary(RelativePath("foo5.o")))
-    XCTAssertTrue(plannedJobs[3].tool.name.contains("ld"))
+    XCTAssertTrue(plannedJobs[3].tool.name.contains(driver1.targetTriple.isDarwin ? "ld" : "clang"))
     XCTAssertEqual(plannedJobs[3].outputs.count, 1)
     XCTAssertEqual(plannedJobs[3].outputs.first!.file, VirtualPath.relative(RelativePath("Test")))
   }
@@ -899,12 +894,7 @@ final class SwiftDriverTests: XCTestCase {
       XCTAssertTrue(job.commandLine.contains(.flag("foo")))
 
       XCTAssertFalse(job.commandLine.contains(.flag("--")))
-
-      #if os(macOS)
-      XCTAssertTrue(job.extraEnvironment.keys.contains("DYLD_LIBRARY_PATH"))
-      #elseif os(Linux)
-      XCTAssertTrue(job.extraEnvironment.keys.contains("LD_LIBRARY_PATH"))
-      #endif
+      XCTAssertTrue(job.extraEnvironment.keys.contains("\(driver.targetTriple.isDarwin ? "DYLD" : "LD")_LIBRARY_PATH"))
     }
 
     do {
@@ -924,7 +914,7 @@ final class SwiftDriverTests: XCTestCase {
       XCTAssertTrue(job.commandLine.contains(.flag("args")))
       XCTAssertTrue(job.commandLine.contains(.flag("-for=foo")))
     }
-    #if os(macOS)
+    
     do {
       var driver = try Driver(args: ["swift", "-L/path/to/lib", "-F/path/to/framework", "foo.swift"])
       let plannedJobs = try driver.planBuild()
@@ -933,21 +923,13 @@ final class SwiftDriverTests: XCTestCase {
       XCTAssertEqual(job.inputs.count, 1)
       XCTAssertEqual(job.inputs[0].file, .relative(RelativePath("foo.swift")))
       XCTAssertEqual(job.outputs.count, 0)
-      XCTAssertTrue(job.extraEnvironment.contains { $0 == "DYLD_LIBRARY_PATH" && $1.contains("/path/to/lib") })
-      XCTAssertTrue(job.extraEnvironment.contains { $0 == "DYLD_FRAMEWORK_PATH" && $1.contains("/path/to/framework") })
-    }
-    #elseif os(Linux)
-    do {
-      var driver = try Driver(args: ["swift", "-L/path/to/lib", "foo.swift"])
-      let plannedJobs = try driver.planBuild()
-      XCTAssertEqual(plannedJobs.count, 1)
-      let job = plannedJobs[0]
-      XCTAssertEqual(job.inputs.count, 1)
-      XCTAssertEqual(job.inputs[0].file, .relative(RelativePath("foo.swift")))
-      XCTAssertEqual(job.outputs.count, 0)
-      XCTAssertTrue(job.extraEnvironment.contains { $0 == "LD_LIBRARY_PATH" && $1.contains("/path/to/lib") })
+      XCTAssertTrue(job.extraEnvironment.contains {
+        $0 == "\(driver.targetTriple.isDarwin ? "DYLD" : "LD")_LIBRARY_PATH" && $1.contains("/path/to/lib")
+      })
+      if driver.targetTriple.isDarwin {
+        XCTAssertTrue(job.extraEnvironment.contains { $0 == "DYLD_FRAMEWORK_PATH" && $1.contains("/path/to/framework") })
+      }
     }
-    #endif
   }
 
   func testTargetTriple() throws {
@@ -974,9 +956,8 @@ final class SwiftDriverTests: XCTestCase {
 
   func testDSYMGeneration() throws {
     let commonArgs = [
-      "swiftc", "-target", "x86_64-apple-macosx",
-      "foo.swift", "bar.swift", "-emit-executable",
-      "-module-name", "Test"
+      "swiftc", "foo.swift", "bar.swift",
+      "-emit-executable", "-module-name", "Test"
     ]
 
     do {
@@ -1001,29 +982,32 @@ final class SwiftDriverTests: XCTestCase {
       // dSYM generation (-g)
       var driver = try Driver(args: commonArgs + ["-g"])
       let plannedJobs = try driver.planBuild()
-
-      XCTAssertEqual(plannedJobs.count, 5)
+      
       let generateDSYMJob = plannedJobs.last!
-      XCTAssertEqual(generateDSYMJob.kind, .generateDSYM)
-
-      XCTAssertEqual(generateDSYMJob.outputs.last?.file, try VirtualPath(path: "Test.dSYM"))
-
       let cmd = generateDSYMJob.commandLine
+      
+      if generateDSYMJob.kind == .generateDSYM {
+        XCTAssertEqual(plannedJobs.count, 5)
+        XCTAssertEqual(generateDSYMJob.outputs.last?.file, try VirtualPath(path: "Test.dSYM"))
+      } else {
+        XCTAssertEqual(plannedJobs.count, 4)
+      }
+      
       XCTAssertTrue(cmd.contains(.path(try VirtualPath(path: "Test"))))
     }
   }
 
   func testDOTFileEmission() throws {
     var driver = try Driver(args: [
-      "swiftc", "-emit-executable", "test.swift", "-emit-module",
-      "-target", "x86_64-apple-macosx"
+      "swiftc", "-emit-executable", "test.swift", "-emit-module"
     ])
     let plannedJobs = try driver.planBuild()
 
     var serializer = DOTJobGraphSerializer(jobs: plannedJobs)
     var output = ""
     serializer.writeDOT(to: &output)
 
+    let dynamicLinker = driver.targetTriple.isDarwin ? "ld" : "clang"
     XCTAssertEqual(output,
     """
     digraph Jobs {
@@ -1040,26 +1024,25 @@ final class SwiftDriverTests: XCTestCase {
       "test.swiftmodule" -> "mergeModule (swift)" [color=blue];
       "mergeModule (swift)" -> "test.swiftmodule" [color=green];
       "mergeModule (swift)" -> "test.swiftdoc" [color=green];
-      "link (ld)" [style=bold];
-      "test.o" -> "link (ld)" [color=blue];
+      "link (\(dynamicLinker))" [style=bold];
+      "test.o" -> "link (\(dynamicLinker))" [color=blue];
       "test" [fontsize=12];
-      "link (ld)" -> "test" [color=green];
+      "link (\(dynamicLinker))" -> "test" [color=green];
     }
 
     """)
   }
 
   func testRegressions() throws {
-    // FIXME: This doesn't work on Linux.
-  #if os(macOS)
     var driverWithEmptySDK = try Driver(args: ["swiftc", "-sdk", "", "file.swift"])
     _ = try driverWithEmptySDK.planBuild()
-  #endif
   }
 
   func testToolchainUtilities() throws {
-    let swiftVersion = try DarwinToolchain(env: ProcessEnv.vars).swiftCompilerVersion()
-    assertString(swiftVersion, contains: "Swift version ")
+    let darwinSwiftVersion = try DarwinToolchain(env: ProcessEnv.vars).swiftCompilerVersion()
+    let unixSwiftVersion = try GenericUnixToolchain(env: ProcessEnv.vars).swiftCompilerVersion()
+    assertString(darwinSwiftVersion, contains: "Swift version ")
+    assertString(unixSwiftVersion, contains: "Swift version ")
   }
 
   func testToolchainClangPath() {

Tests/SwiftDriverTests/XCTestManifests.swift

@@ -39,6 +39,17 @@ extension ParsableMessageTests {
     static let __allTests__ParsableMessageTests = [
         ("testBeganMessage", testBeganMessage),
         ("testFinishedMessage", testFinishedMessage),
+        ("testSignalledMessage", testSignalledMessage),
+    ]
+}
+
+extension PredictableRandomNumberGeneratorTests {
+    // DO NOT MODIFY: This is autogenerated, use:
+    //   `swift test --generate-linuxmain`
+    // to regenerate.
+    static let __allTests__PredictableRandomNumberGeneratorTests = [
+        ("testPredictability", testPredictability),
+        ("testUnusualSeeds", testUnusualSeeds),
     ]
 }
 
@@ -76,11 +87,14 @@ extension SwiftDriverTests {
         ("testDOTFileEmission", testDOTFileEmission),
         ("testDriverKindParsing", testDriverKindParsing),
         ("testDSYMGeneration", testDSYMGeneration),
+        ("testImmediateMode", testImmediateMode),
         ("testInputFiles", testInputFiles),
+        ("testInvocationRunModes", testInvocationRunModes),
         ("testLinking", testLinking),
         ("testMergeModulesOnly", testMergeModulesOnly),
         ("testModuleNameFallbacks", testModuleNameFallbacks),
         ("testModuleSettings", testModuleSettings),
+        ("testMultiThreadedWholeModuleOptimizationCompiles", testMultiThreadedWholeModuleOptimizationCompiles),
         ("testMultithreading", testMultithreading),
         ("testMultithreadingDiagnostics", testMultithreadingDiagnostics),
         ("testOutputFileMapLoading", testOutputFileMapLoading),
@@ -93,10 +107,13 @@ extension SwiftDriverTests {
         ("testResponseFileExpansion", testResponseFileExpansion),
         ("testResponseFileTokenization", testResponseFileTokenization),
         ("testSanitizerArgs", testSanitizerArgs),
+        ("testSingleThreadedWholeModuleOptimizationCompiles", testSingleThreadedWholeModuleOptimizationCompiles),
         ("testStandardCompileJobs", testStandardCompileJobs),
+        ("testSubcommandsHandling", testSubcommandsHandling),
         ("testTargetTriple", testTargetTriple),
         ("testToolchainClangPath", testToolchainClangPath),
         ("testToolchainUtilities", testToolchainUtilities),
+        ("testWholeModuleOptimizationOutputFileMap", testWholeModuleOptimizationOutputFileMap),
     ]
 }
 
@@ -124,6 +141,7 @@ public func __allTests() -> [XCTestCaseEntry] {
         testCase(IncrementalCompilationTests.__allTests__IncrementalCompilationTests),
         testCase(JobExecutorTests.__allTests__JobExecutorTests),
         testCase(ParsableMessageTests.__allTests__ParsableMessageTests),
+        testCase(PredictableRandomNumberGeneratorTests.__allTests__PredictableRandomNumberGeneratorTests),
         testCase(PrefixTrieTests.__allTests__PrefixTrieTests),
         testCase(StringAdditionsTests.__allTests__StringAdditionsTests),
         testCase(SwiftDriverTests.__allTests__SwiftDriverTests),