Fixes for running tests on Redhat.

- Process: When setting the current directory for a sub-process,
  set the PWD environment variable to this directory if the
  default environment is used. This matches Darwin's behaviour.

- Use xdgTestHelper as an external test program for TestProcess,
  taking options for getcwd() and getenv("PWD").

- SR-7748: Use /tmp as a test directory and run it through realpath()
  to test against the result of getcwd(). On macOS, /tmp is a symlink
  to private/tmp.

- SR-7747: FileManager.attributesOfFileSystem(forPath:) may return
  .systemNumber as 0 on some systems (eg tmpfs on Redhat). Remove
  this invalid test.

Author: spevans

Foundation/Process.swift

@@ -292,25 +292,25 @@ open class Process: NSObject {
             }
             argv.deallocate()
         }
-        
-        let envp: UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>
-        
-        if let env = environment {
-            let nenv = env.count
-            envp = UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>.allocate(capacity: 1 + nenv)
-            envp.initialize(from: env.map { strdup("\($0)=\($1)") }, count: nenv)
-            envp[env.count] = nil
+
+        var env: [String: String]
+        if let e = environment {
+            env = e
         } else {
-            envp = _CFEnviron()
+            env = ProcessInfo.processInfo.environment
+            env["PWD"] = currentDirectoryURL.path
         }
 
+        let nenv = env.count
+        let envp = UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>.allocate(capacity: 1 + nenv)
+        envp.initialize(from: env.map { strdup("\($0)=\($1)") }, count: nenv)
+        envp[env.count] = nil
+
         defer {
-            if let env = environment {
-                for pair in envp ..< envp + env.count {
-                    free(UnsafeMutableRawPointer(pair.pointee))
-                }
-                envp.deallocate()
+            for pair in envp ..< envp + env.count {
+                free(UnsafeMutableRawPointer(pair.pointee))
             }
+            envp.deallocate()
         }
 
         var taskSocketPair : [Int32] = [0, 0]

TestFoundation/TestFileManager.swift

@@ -279,7 +279,6 @@ class TestFileManager : XCTestCase {
 
             let systemNumber = attrs[.systemNumber] as? NSNumber
             XCTAssertNotNil(systemNumber)
-            XCTAssertNotEqual(systemNumber!.uint64Value, 0)
 
             let systemFreeSize = attrs[.systemFreeSize] as? NSNumber
             XCTAssertNotNil(systemFreeSize)

TestFoundation/TestHTTPCookieStorage.swift

@@ -299,6 +299,7 @@ class TestHTTPCookieStorage: XCTestCase {
         // Test by setting the environmental variable
         let task = Process()
         task.executableURL = xdgTestHelperURL()
+        task.arguments = ["--xdgcheck"]
         var environment = ProcessInfo.processInfo.environment
         let testPath = NSHomeDirectory() + "/TestXDG"
         environment["XDG_DATA_HOME"] = testPath

TestFoundation/TestProcess.swift

@@ -275,17 +275,72 @@ class TestProcess : XCTestCase {
         }
     }
 
+    private func realpathOf(path: String) -> String? {
+        let fm = FileManager.default
+        let length = Int(PATH_MAX) + 1
+        var buf = [Int8](repeating: 0, count: length)
+        let fsRep = fm.fileSystemRepresentation(withPath: path)
+#if !DARWIN_COMPATIBILITY_TESTS
+       defer { fsRep.deallocate() }
+#endif
+        guard let result = realpath(fsRep, &buf) else {
+            return nil
+        }
+        return fm.string(withFileSystemRepresentation: result, length: strlen(result))
+    }
+
     func test_current_working_directory() {
+        let tmpDir = "/tmp"
+
+        guard let resolvedTmpDir = realpathOf(path: tmpDir) else {
+            XCTFail("Cant find realpath of /tmp")
+            return
+        }
+
+        let fm = FileManager.default
+        let previousWorkingDirectory = fm.currentDirectoryPath
+
+        // Test that getcwd() returns the currentDirectoryPath
+        do {
+            let (pwd, _) = try runTask([xdgTestHelperURL().path, "--getcwd"], currentDirectoryPath: tmpDir)
+            // Check the sub-process used the correct directory
+            XCTAssertEqual(pwd.trimmingCharacters(in: .newlines), resolvedTmpDir)
+        } catch let error {
+            XCTFail("Test failed: \(error)")
+        }
+
+        // Test that $PWD by default is set to currentDirectoryPath
         do {
-            let previousWorkingDirectory = FileManager.default.currentDirectoryPath
+            let (pwd, _) = try runTask([xdgTestHelperURL().path, "--echo-PWD"], currentDirectoryPath: tmpDir)
+            // Check the sub-process used the correct directory
+            XCTAssertEqual(pwd.trimmingCharacters(in: .newlines), tmpDir)
+        } catch let error {
+            XCTFail("Test failed: \(error)")
+        }
 
-            // Darwin Foundation requires the full path to the executable (.launchPath)
-            let (output, _) = try runTask(["/bin/bash", "-c", "pwd"], currentDirectoryPath: "/bin")
-            XCTAssertEqual(output.trimmingCharacters(in: .newlines), "/bin")
-            XCTAssertEqual(previousWorkingDirectory, FileManager.default.currentDirectoryPath)
+        // Test that $PWD can be over-ridden
+        do {
+            var env = ProcessInfo.processInfo.environment
+            env["PWD"] = "/bin"
+            let (pwd, _) = try runTask([xdgTestHelperURL().path, "--echo-PWD"], environment: env, currentDirectoryPath: tmpDir)
+            // Check the sub-process used the correct directory
+            XCTAssertEqual(pwd.trimmingCharacters(in: .newlines), "/bin")
         } catch let error {
             XCTFail("Test failed: \(error)")
         }
+
+        // Test that $PWD can be set to empty
+        do {
+            var env = ProcessInfo.processInfo.environment
+            env["PWD"] = ""
+            let (pwd, _) = try runTask([xdgTestHelperURL().path, "--echo-PWD"], environment: env, currentDirectoryPath: tmpDir)
+            // Check the sub-process used the correct directory
+            XCTAssertEqual(pwd.trimmingCharacters(in: .newlines), "")
+        } catch let error {
+            XCTFail("Test failed: \(error)")
+        }
+
+        XCTAssertEqual(previousWorkingDirectory, fm.currentDirectoryPath)
     }
 
     func test_run() {
@@ -360,7 +415,7 @@ private func runTask(_ arguments: [String], environment: [String: String]? = nil
     let stderrPipe = Pipe()
     process.standardOutput = stdoutPipe
     process.standardError = stderrPipe
-    process.launch()
+    try process.run()
     process.waitUntilExit()
 
     guard process.terminationStatus == 0 else {

TestFoundation/xdgTestHelper/main.swift

@@ -50,5 +50,15 @@ class XDGCheck {
     }
 }
 
-XDGCheck.run()
+if let arg = ProcessInfo.processInfo.arguments.last {
+    if arg == "--xdgcheck" {
+        XDGCheck.run()
+    }
+    if arg == "--getcwd" {
+        print(FileManager.default.currentDirectoryPath)
+    }
+    if arg == "--echo-PWD" {
+        print(ProcessInfo.processInfo.environment["PWD"] ?? "")
+    }
+}