Fix more tests

Author: stevapple

Tests/TSCBasicTests/ProcessTests.swift

@@ -25,7 +25,11 @@ class ProcessTests: XCTestCase {
 
     func testBasics() throws {
         do {
+          #if os(Windows)
+            let process = Process(args: "cmd", "/c", "echo", "hello")
+          #else
             let process = Process(args: "echo", "hello")
+          #endif
             try process.launch()
             let result = try process.waitUntilExit()
             XCTAssertEqual(try result.utf8Output(), "hello\n")
@@ -34,46 +38,54 @@ class ProcessTests: XCTestCase {
         }
 
         do {
+          #if os(Windows)
+            let process = Process(args: "cmd.exe", "/c", "exit", "4")
+          #else
             let process = Process(args: script("exit4"))
+          #endif
             try process.launch()
             let result = try process.waitUntilExit()
             XCTAssertEqual(result.exitStatus, .terminated(code: 4))
         }
     }
 
     func testPopen() throws {
-        #if os(Windows)
-        let echo = "echo.exe"
-        #else
-        let echo = "echo"
-        #endif
+      #if os(Windows)
+        let echo = ["cmd.exe", "/c", "echo"]
+      #else
+        let echo = ["echo"]
+      #endif
         // Test basic echo.
-        XCTAssertEqual(try Process.popen(arguments: [echo, "hello"]).utf8Output(), "hello\n")
+        XCTAssertEqual(try Process.popen(arguments: echo + ["hello"]).utf8Output(), "hello\n")
 
         // Test buffer larger than that allocated.
         try withTemporaryFile { file in
             let count = 10_000
             let stream = BufferedOutputByteStream()
             stream <<< Format.asRepeating(string: "a", count: count)
             try localFileSystem.writeFileContents(file.path, bytes: stream.bytes)
-            #if os(Windows)
-            let cat = "cat.exe"
-            #else
-            let cat = "cat"
-            #endif
-            let outputCount = try Process.popen(args: cat, file.path.pathString).utf8Output().count
+          #if os(Windows)
+            let process = try Process.popen(args: "cmd.exe", "/c", "type", file.path.pathString)
+          #else
+            let process = try Process.popen(args: "cat", file.path.pathString)
+          #endif
+            let outputCount = try process.utf8Output().count
             XCTAssert(outputCount == count)
         }
     }
 
     func testPopenAsync() throws {
-        #if os(Windows)
+      #if os(Windows)
         let args = ["where.exe", "where"]
-        let answer = "C:\\Windows\\System32\\where.exe"
-        #else
+        var buffer = Array<WCHAR>(repeating: 0, count: Int(MAX_PATH + 1))
+        guard GetSystemDirectoryW(&buffer, .init(buffer.count)) > 0 else {
+            return XCTFail()
+        }
+        let answer = String(decodingCString: buffer, as: UTF16.self) + "\\where.exe"
+      #else
         let args = ["whoami"]
         let answer = NSUserName()
-        #endif
+      #endif
         var popenResult: Result<ProcessResult, Error>?
         let group = DispatchGroup()
         group.enter()
@@ -95,12 +107,20 @@ class ProcessTests: XCTestCase {
 
     func testCheckNonZeroExit() throws {
         do {
+          #if os(Windows)
+            let output = try Process.checkNonZeroExit(args: "cmd.exe", "/c", "echo", "hello")
+          #else
             let output = try Process.checkNonZeroExit(args: "echo", "hello")
+          #endif
             XCTAssertEqual(output, "hello\n")
         }
 
         do {
+          #if os(Windows)
+            let output = try Process.checkNonZeroExit(args: "cmd.exe", "/c", "exit", "4")
+          #else
             let output = try Process.checkNonZeroExit(args: script("exit4"))
+          #endif
             XCTFail("Unexpected success \(output)")
         } catch ProcessResult.Error.nonZeroExit(let result) {
             XCTAssertEqual(result.exitStatus, .terminated(code: 4))
@@ -176,7 +196,7 @@ class ProcessTests: XCTestCase {
                     let process = Process(args: "nonExecutableProgram")
                     try process.launch()
                     XCTFail("Should have failed to validate nonExecutableProgram")
-                } catch Process.Error.missingExecutableProgram (let program){
+                } catch Process.Error.missingExecutableProgram(let program) {
                     XCTAssert(program == "nonExecutableProgram")
                 }
             }
@@ -262,7 +282,11 @@ class ProcessTests: XCTestCase {
   #endif
 
     func testThreadSafetyOnWaitUntilExit() throws {
+      #if os(Windows)
+        let process = Process(args: "cmd", "/c", "echo", "hello")
+      #else
         let process = Process(args: "echo", "hello")
+      #endif
         try process.launch()
 
         var result1: String = ""
@@ -287,7 +311,12 @@ class ProcessTests: XCTestCase {
 
     func testStdin() throws {
         var stdout = [UInt8]()
-        let process = Process(args: script("in-to-out"), outputRedirection: .stream(stdout: { stdoutBytes in
+      #if os(Windows)
+        let inToOut = ["python.exe", script("in-to-out")]
+      #else
+        let inToOut = [script("in-to-out")]
+      #endif
+        let process = Process(arguments: inToOut, outputRedirection: .stream(stdout: { stdoutBytes in
             stdout += stdoutBytes
         }, stderr: { _ in }))
         let stdinStream = try process.launch()
@@ -305,14 +334,24 @@ class ProcessTests: XCTestCase {
     func testStdoutStdErr() throws {
         // A simple script to check that stdout and stderr are captured separatly.
         do {
-            let result = try Process.popen(args: script("simple-stdout-stderr"))
+          #if os(Windows)
+            let simpleStdoutStdErr = ["python.exe", script("simple-stdout-stderr")]
+          #else
+            let simpleStdoutStdErr = [script("simple-stdout-stderr")]
+          #endif
+            let result = try Process.popen(arguments: simpleStdoutStdErr)
             XCTAssertEqual(try result.utf8Output(), "simple output\n")
             XCTAssertEqual(try result.utf8stderrOutput(), "simple error\n")
         }
 
         // A long stdout and stderr output.
         do {
-            let result = try Process.popen(args: script("long-stdout-stderr"))
+          #if os(Windows)
+            let longStdoutStdErr = ["python.exe", script("long-stdout-stderr")]
+          #else
+            let longStdoutStdErr = [script("long-stdout-stderr")]
+          #endif
+            let result = try Process.popen(arguments: longStdoutStdErr)
             let count = 16 * 1024
             XCTAssertEqual(try result.utf8Output(), String(repeating: "1", count: count))
             XCTAssertEqual(try result.utf8stderrOutput(), String(repeating: "2", count: count))
@@ -330,7 +369,12 @@ class ProcessTests: XCTestCase {
     func testStdoutStdErrRedirected() throws {
         // A simple script to check that stdout and stderr are captured in the same location.
         do {
-            let process = Process(args: script("simple-stdout-stderr"), outputRedirection: .collect(redirectStderr: true))
+          #if os(Windows)
+            let simpleStdoutStdErr = ["python.exe", script("simple-stdout-stderr")]
+          #else
+            let simpleStdoutStdErr = [script("simple-stdout-stderr")]
+          #endif
+            let process = Process(arguments: simpleStdoutStdErr, outputRedirection: .collect(redirectStderr: true))
             try process.launch()
             let result = try process.waitUntilExit()
             XCTAssertEqual(try result.utf8Output(), "simple error\nsimple output\n")
@@ -339,7 +383,12 @@ class ProcessTests: XCTestCase {
 
         // A long stdout and stderr output.
         do {
-            let process = Process(args: script("long-stdout-stderr"), outputRedirection: .collect(redirectStderr: true))
+          #if os(Windows)
+            let longStdoutStdErr = ["python.exe", script("long-stdout-stderr")]
+          #else
+            let longStdoutStdErr = [script("long-stdout-stderr")]
+          #endif
+            let process = Process(arguments: longStdoutStdErr, outputRedirection: .collect(redirectStderr: true))
             try process.launch()
             let result = try process.waitUntilExit()
 
@@ -352,7 +401,12 @@ class ProcessTests: XCTestCase {
     func testStdoutStdErrStreaming() throws {
         var stdout = [UInt8]()
         var stderr = [UInt8]()
-        let process = Process(args: script("long-stdout-stderr"), outputRedirection: .stream(stdout: { stdoutBytes in
+      #if os(Windows)
+        let longStdoutStdErr = ["python.exe", script("long-stdout-stderr")]
+      #else
+        let longStdoutStdErr = [script("long-stdout-stderr")]
+      #endif
+        let process = Process(arguments: longStdoutStdErr, outputRedirection: .stream(stdout: { stdoutBytes in
             stdout += stdoutBytes
         }, stderr: { stderrBytes in
             stderr += stderrBytes
@@ -368,7 +422,12 @@ class ProcessTests: XCTestCase {
     func testStdoutStdErrStreamingRedirected() throws {
         var stdout = [UInt8]()
         var stderr = [UInt8]()
-        let process = Process(args: script("long-stdout-stderr"), outputRedirection: .stream(stdout: { stdoutBytes in
+      #if os(Windows)
+        let longStdoutStdErr = ["python.exe", script("long-stdout-stderr")]
+      #else
+        let longStdoutStdErr = [script("long-stdout-stderr")]
+      #endif
+        let process = Process(arguments: longStdoutStdErr, outputRedirection: .stream(stdout: { stdoutBytes in
             stdout += stdoutBytes
         }, stderr: { stderrBytes in
             stderr += stderrBytes
@@ -402,15 +461,21 @@ class ProcessTests: XCTestCase {
             try localFileSystem.createDirectory(childPath.parentDirectory, recursive: true)
             try localFileSystem.writeFileContents(childPath, bytes: ByteString("child"))
 
+          #if os(Windows)
+            let args = ["cmd.exe", "/c", "type", "file"]
+          #else
+            let args = ["cat", "file"]
+          #endif
+
             do {
-                let process = Process(arguments: ["cat", "file"], workingDirectory: tempDirPath)
+                let process = Process(arguments: args, workingDirectory: tempDirPath)
                 try process.launch()
                 let result = try process.waitUntilExit()
                 XCTAssertEqual(try result.utf8Output(), "parent")
             }
 
             do {
-                let process = Process(arguments: ["cat", "file"], workingDirectory: childPath.parentDirectory)
+                let process = Process(arguments: args, workingDirectory: childPath.parentDirectory)
                 try process.launch()
                 let result = try process.waitUntilExit()
                 XCTAssertEqual(try result.utf8Output(), "child")

Tests/TSCBasicTests/TemporaryFileTests.swift

@@ -143,13 +143,13 @@ class TemporaryFileTests: XCTestCase {
         // sequence of creating and destroying TemporaryFile objects. I don't
         // believe that this is guaranteed by POSIX, but it is true on all
         // platforms I know of.
-        #if !os(Windows)
+      #if !os(Windows) // `fileDescriptor` is currently unavailable in Windows
         let initialFD = try Int(withTemporaryFile { return $0.fileHandle.fileDescriptor })
         for _ in 0..<10 {
             _ = try withTemporaryFile { return $0.fileHandle }
         }
         let endFD = try Int(withTemporaryFile { return $0.fileHandle.fileDescriptor })
         XCTAssertEqual(initialFD, endFD)
-        #endif
+      #endif
     }
 }