Fixes to many tests (plus skips) to get more tests running on windows

swiftlang#8606

Author: daveinglis

Fixtures/DependencyResolution/External/Complex/FisherYates/src/Fisher-Yates_Shuffle.swift

@@ -1,12 +1,3 @@
-#if os(macOS) || os(iOS)
-import Darwin
-#elseif canImport(Glibc)
-import Glibc
-#elseif canImport(Musl)
-import Musl
-#elseif canImport(Bionic)
-import Bionic
-#endif
 
 public extension Collection {
     func shuffle() -> [Iterator.Element] {
@@ -24,15 +15,13 @@ public extension MutableCollection {
         guard c > 1 else { return }
 
         for (firstUnshuffled, unshuffledCount) in zip(indices, stride(from: c, to: 1, by: -1)) {
-#if os(macOS) || os(iOS)
-            let d = arc4random_uniform(numericCast(unshuffledCount))
-#else
-            let d = numericCast(random()) % unshuffledCount
-#endif
-            let i = index(firstUnshuffled, offsetBy: numericCast(d))
+            var g = SystemRandomNumberGenerator()
+            let d = Int.random(in: 1...unshuffledCount, using: &g)
+            let i = index(firstUnshuffled, offsetBy: d)
             swapAt(firstUnshuffled, i)
         }
     }
 }
 
+
 public let shuffle = false

Fixtures/Miscellaneous/EchoExecutable/Sources/secho/main.swift

@@ -4,11 +4,14 @@
 	import Musl
 #elseif canImport(Android)
 	import Android
-#else
+#elseif canImport(Darwin.C)
 	import Darwin.C
+#elseif canImport(ucrt)
+	import ucrt
+	let PATH_MAX = MAX_PATH
 #endif
 
-let cwd = getcwd(nil, Int(PATH_MAX))
+let cwd = getcwd(nil, Int32(PATH_MAX))
 defer { free(cwd) }
 let workingDirectory = String(validatingUTF8: cwd!)!
 let values = [workingDirectory] + Array(CommandLine.arguments.dropFirst())

Sources/Build/LLBuildProgressTracker.swift

@@ -559,9 +559,14 @@ private struct CommandTaskTracker {
     }
 
     private func progressText(of command: SPMLLBuild.Command, targetName: String?) -> String {
+#if os(Windows)
+    let pathSep: Character = "\\"
+#else
+    let pathSep: Character = "/"
+#endif
         // Transforms descriptions like "Linking ./.build/x86_64-apple-macosx/debug/foo" into "Linking foo".
         if let firstSpaceIndex = command.description.firstIndex(of: " "),
-           let lastDirectorySeparatorIndex = command.description.lastIndex(of: "/")
+           let lastDirectorySeparatorIndex = command.description.lastIndex(of: pathSep)
         {
             let action = command.description[..<firstSpaceIndex]
             let fileNameStartIndex = command.description.index(after: lastDirectorySeparatorIndex)

Sources/_InternalTestSupport/misc.swift

@@ -548,3 +548,25 @@ public func getNumberOfMatches(of match: String, in value: String) -> Int {
     guard match.count != 0 else { return 0 }
     return value.ranges(of: match).count
 }
+
+public extension String {
+    
+    var withPlatformNewLine: String {
+#if os(Windows)
+        return replacingOccurrences(of: "\n", with: "\r\n")
+#else
+        return self
+#endif
+    }
+}
+
+public func executableName(_ name: String) -> String {
+#if os(Windows)
+  if name.count > 4, name.suffix(from: name.index(name.endIndex, offsetBy: -4)) == ".exe" {
+    return name
+  }
+  return "\(name).exe"
+#else
+  return name
+#endif
+}

Tests/BasicsTests/Archiver/TarArchiverTests.swift

@@ -25,6 +25,7 @@ final class TarArchiverTests: XCTestCase {
     }
 
     func testSuccess() async throws {
+        try XCTSkipOnWindows(because: "requires tar")
         try await testWithTemporaryDirectory { tmpdir in
             let archiver = TarArchiver(fileSystem: localFileSystem)
             let inputArchivePath = AbsolutePath(#file).parentDirectory
@@ -64,6 +65,7 @@ final class TarArchiverTests: XCTestCase {
     }
 
     func testInvalidArchive() async throws {
+        try XCTSkipOnWindows(because: "requires tar")
         try await testWithTemporaryDirectory { tmpdir in
             let archiver = TarArchiver(fileSystem: localFileSystem)
             let inputArchivePath = AbsolutePath(#file).parentDirectory
@@ -79,6 +81,7 @@ final class TarArchiverTests: XCTestCase {
     }
 
     func testValidation() async throws {
+        try XCTSkipOnWindows(because: "requires tar")
         // valid
         try await testWithTemporaryDirectory { _ in
             let archiver = TarArchiver(fileSystem: localFileSystem)
@@ -104,6 +107,7 @@ final class TarArchiverTests: XCTestCase {
     }
 
     func testCompress() async throws {
+        try XCTSkipOnWindows(because: "requires tar")
         #if os(Linux)
         guard SPM_posix_spawn_file_actions_addchdir_np_supported() else {
             throw XCTSkip("working directory not supported on this platform")

Tests/BasicsTests/Archiver/UniversalArchiverTests.swift

@@ -37,6 +37,7 @@ final class UniversalArchiverTests: XCTestCase {
     }
 
     func testSuccess() async throws {
+        try XCTSkipOnWindows(because: "requires tar")
         try await testWithTemporaryDirectory { tmpdir in
             let archiver = UniversalArchiver(localFileSystem)
             let inputArchivePath = AbsolutePath(#file).parentDirectory
@@ -85,6 +86,7 @@ final class UniversalArchiverTests: XCTestCase {
     }
 
     func testInvalidArchive() async throws {
+        try XCTSkipOnWindows(because: "requires tar")
         try await testWithTemporaryDirectory { tmpdir in
             let archiver = UniversalArchiver(localFileSystem)
             var inputArchivePath = AbsolutePath(#file).parentDirectory
@@ -110,6 +112,7 @@ final class UniversalArchiverTests: XCTestCase {
     }
 
     func testValidation() async throws {
+        try XCTSkipOnWindows(because: "requires tar")
         // valid
         try await testWithTemporaryDirectory { _ in
             let archiver = UniversalArchiver(localFileSystem)
@@ -135,6 +138,7 @@ final class UniversalArchiverTests: XCTestCase {
     }
 
     func testCompress() async throws {
+        try XCTSkipOnWindows(because: "requires tar")
         #if os(Linux)
         guard SPM_posix_spawn_file_actions_addchdir_np_supported() else {
             throw XCTSkip("working directory not supported on this platform")

Tests/BasicsTests/SandboxTests.swift

@@ -20,6 +20,7 @@ import Darwin
 
 final class SandboxTest: XCTestCase {
     func testSandboxOnAllPlatforms() throws {
+        try XCTSkipOnWindows(because: "requires tar")
         try withTemporaryDirectory { path in
 #if os(Windows)
             let command = try Sandbox.apply(command: ["tar.exe", "-h"], strictness: .default, writableDirectories: [])

Tests/CommandsTests/BuildCommandTests.swift

@@ -233,7 +233,7 @@ class BuildCommandTestCases: CommandsBuildProviderTestCase {
 
             do {
                 let result = try await build(["--product", "exec1"], packagePath: fullPath)
-                XCTAssertMatch(result.binContents, ["exec1"])
+                XCTAssertMatch(result.binContents, [.equal(executableName("exec1"))])
                 XCTAssertNoMatch(result.binContents, ["exec2.build"])
             }
 
@@ -306,6 +306,8 @@ class BuildCommandTestCases: CommandsBuildProviderTestCase {
     }
 
     func testAtMainSupport() async throws {
+        try XCTSkipOnWindows(because: "lld-link: error: undefined symbol: __declspec(dllimport) swift_addNewDSOImage, needs investigation")
+
         try await fixture(name: "Miscellaneous/AtMainSupport") { fixturePath in
             let fullPath = try resolveSymlinks(fixturePath)
 
@@ -316,12 +318,12 @@ class BuildCommandTestCases: CommandsBuildProviderTestCase {
 
             do {
                 let result = try await build(["--product", "SwiftExecSingleFile"], packagePath: fullPath)
-                XCTAssertMatch(result.binContents, ["SwiftExecSingleFile"])
+                XCTAssertMatch(result.binContents, [.equal(executableName("SwiftExecSingleFile"))])
             }
 
             do {
                 let result = try await build(["--product", "SwiftExecMultiFile"], packagePath: fullPath)
-                XCTAssertMatch(result.binContents, ["SwiftExecMultiFile"])
+                XCTAssertMatch(result.binContents, [.equal(executableName("SwiftExecMultiFile"))])
             }
         }
     }
@@ -343,8 +345,8 @@ class BuildCommandTestCases: CommandsBuildProviderTestCase {
             do {
                 let result = try await build(["--product", "bexec"], packagePath: aPath)
                 XCTAssertMatch(result.binContents, ["BTarget2.build"])
-                XCTAssertMatch(result.binContents, ["bexec"])
-                XCTAssertNoMatch(result.binContents, ["aexec"])
+                XCTAssertMatch(result.binContents, [.equal(executableName("bexec"))])
+                XCTAssertNoMatch(result.binContents, [.equal(executableName("aexec"))])
                 XCTAssertNoMatch(result.binContents, ["ATarget.build"])
                 XCTAssertNoMatch(result.binContents, ["BLibrary.a"])
 
@@ -380,6 +382,8 @@ class BuildCommandTestCases: CommandsBuildProviderTestCase {
     }
 
     func testAutomaticParseableInterfacesWithLibraryEvolution() async throws {
+        try XCTSkipOnWindows(because:  "swift-package-manager hangs, needs investigation")
+
         try await fixture(name: "Miscellaneous/LibraryEvolution") { fixturePath in
             do {
                 let result = try await build([], packagePath: fixturePath)
@@ -541,6 +545,8 @@ class BuildCommandTestCases: CommandsBuildProviderTestCase {
     }
 
     func testSwiftGetVersion() async throws {
+        try XCTSkipOnWindows(because: "SWIFT_EXEC override is not working, needs investigation")
+
         try await fixture(name: "Miscellaneous/Simple") { fixturePath in
             func findSwiftGetVersionFile() throws -> AbsolutePath {
                 let buildArenaPath = fixturePath.appending(components: ".build", "debug")
@@ -774,15 +780,10 @@ class BuildCommandNativeTests: BuildCommandTestCases {
                 components: ".build",
                 UserToolchain.default.targetTriple.platformBuildPathComponent
             )
-            try await XCTAssertAsyncEqual(
-                try await self.execute(["--show-bin-path"], packagePath: fullPath).stdout,
-                "\(targetPath.appending("debug").pathString)\n"
-            )
-            try await XCTAssertAsyncEqual(
-                try await self.execute(["-c", "release", "--show-bin-path"], packagePath: fullPath)
-                    .stdout,
-                "\(targetPath.appending("release").pathString)\n"
-            )
+            let debugPath = try await self.execute(["--show-bin-path"], packagePath: fullPath).stdout.trimmingCharacters(in: .whitespacesAndNewlines)
+            XCTAssertEqual(AbsolutePath(debugPath).pathString, targetPath.appending("debug").pathString)
+            let releasePath = try await self.execute(["-c", "release", "--show-bin-path"], packagePath: fullPath).stdout.trimmingCharacters(in: .whitespacesAndNewlines)
+            XCTAssertEqual(AbsolutePath(releasePath).pathString, targetPath.appending("release").pathString)
         }
     }
 }
@@ -861,6 +862,7 @@ class BuildCommandSwiftBuildTests: BuildCommandTestCases {
     override func testParseableInterfaces() async throws {
         try XCTSkipIfWorkingDirectoryUnsupported()
 
+        try XCTSkipOnWindows(because: "build errors, needs investigation")
         try await fixture(name: "Miscellaneous/ParseableInterfaces") { fixturePath in
             do {
                 let result = try await build(["--enable-parseable-module-interfaces"], packagePath: fixturePath)
@@ -885,9 +887,9 @@ class BuildCommandSwiftBuildTests: BuildCommandTestCases {
                 UserToolchain.default.targetTriple.platformBuildPathComponent
             )
             let debugPath = try await self.execute(["--show-bin-path"], packagePath: fullPath).stdout
-            XCTAssertMatch(debugPath, .regex(targetPath.appending(components: "Products", "Debug").pathString + "(\\-linux|\\-Windows)?\\n"))
+            XCTAssertMatch(AbsolutePath(debugPath).pathString, .regex(targetPath.appending(components: "Products", "Debug").escapedPathString + "(\\-linux|\\-Windows)?"))
             let releasePath = try await self.execute(["-c", "release", "--show-bin-path"], packagePath: fullPath).stdout
-            XCTAssertMatch(releasePath, .regex(targetPath.appending(components: "Products", "Release").pathString + "(\\-linux|\\-Windows)?\\n"))
+            XCTAssertMatch(AbsolutePath(releasePath).pathString, .regex(targetPath.appending(components: "Products", "Release").escapedPathString + "(\\-linux|\\-Windows)?"))
         }
     }
 
@@ -942,6 +944,7 @@ class BuildCommandSwiftBuildTests: BuildCommandTestCases {
     override func testBuildSystemDefaultSettings() async throws {
         try XCTSkipIfWorkingDirectoryUnsupported()
 
+        try XCTSkipOnWindows(because: "build errors, needs investigation")
         if ProcessInfo.processInfo.environment["SWIFTPM_NO_SWBUILD_DEPENDENCY"] != nil {
             throw XCTSkip("SWIFTPM_NO_SWBUILD_DEPENDENCY is set so skipping because SwiftPM doesn't have the swift-build capability built inside.")
         }
@@ -952,6 +955,7 @@ class BuildCommandSwiftBuildTests: BuildCommandTestCases {
     override func testBuildCompleteMessage() async throws {
         try XCTSkipIfWorkingDirectoryUnsupported()
 
+        try XCTSkipOnWindows(because: "Build fails on windows, needs investigation") 
         try await super.testBuildCompleteMessage()
     }
 

Tests/CommandsTests/MultiRootSupportTests.swift

@@ -42,6 +42,6 @@ final class MultiRootSupportTests: CommandsTestCase {
         let result = try XcodeWorkspaceLoader(fileSystem: fs, observabilityScope: observability.topScope).load(workspace: path)
 
         XCTAssertNoDiagnostics(observability.diagnostics)
-        XCTAssertEqual(result.map{ $0.pathString }.sorted(), ["/tmp/test/dep", "/tmp/test/local"])
+        XCTAssertEqual(result.map{ $0.pathString }.sorted(), [AbsolutePath("/tmp/test/dep").pathString, AbsolutePath("/tmp/test/local").pathString])
     }
 }