TestProcess.swift

// This source file is part of the Swift.org open source project
//
// Copyright (c) 2015 - 2016, 2018 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//

import Synchronization
#if canImport(Android)
@preconcurrencyimport Android
#endif

classTestProcess:XCTestCase{

func test_exit0()throws{
letprocess=Process()
letexecutableURL=tryxdgTestHelperURL()
if #available(macOS 10.13,*){
 process.executableURL = executableURL
}else{
 // Fallback on earlier versions
 process.launchPath = executableURL.path
}
XCTAssertEqual(executableURL.path, process.executableURL?.path)
 process.arguments =["--exit","0"]
try process.run()
 process.waitUntilExit()

XCTAssertEqual(process.terminationStatus,0)
XCTAssertEqual(process.terminationReason,.exit)
}

func test_exit1()throws{
letprocess=Process()
 process.executableURL =tryxdgTestHelperURL()
 process.arguments =["--exit","1"]

try process.run()
 process.waitUntilExit()
XCTAssertEqual(process.terminationStatus,1)
XCTAssertEqual(process.terminationReason,.exit)
}

func test_exit100()throws{
letprocess=Process()
 process.executableURL =tryxdgTestHelperURL()
 process.arguments =["--exit","100"]

try process.run()
 process.waitUntilExit()
XCTAssertEqual(process.terminationStatus,100)
XCTAssertEqual(process.terminationReason,.exit)
}

func test_sleep2()throws{
letprocess=Process()
 process.executableURL =tryxdgTestHelperURL()
 process.arguments =["--sleep","2"]

try process.run()
 process.waitUntilExit()
XCTAssertEqual(process.terminationStatus,0)
XCTAssertEqual(process.terminationReason,.exit)
}

func test_terminationReason_uncaughtSignal()throws{
letprocess=Process()
 process.executableURL =tryxdgTestHelperURL()
 process.arguments =["--signal-self",SIGTERM.description]
try process.run()
 process.waitUntilExit()
XCTAssertEqual(process.terminationStatus, SIGTERM)
XCTAssertEqual(process.terminationReason,.uncaughtSignal)
}

func test_pipe_stdin()throws{
letprocess=Process()

 process.executableURL =tryxdgTestHelperURL()
 process.arguments =["--cat"]
letoutputPipe=Pipe()
 process.standardOutput = outputPipe

letinputPipe=Pipe()
 process.standardInput = inputPipe
 process.standardError =FileHandle.nullDevice
try process.run()
letmsg=tryXCTUnwrap("Hello, 🐶.\n".data(using:.utf8))
do{
try inputPipe.fileHandleForWriting.write(contentsOf: msg)
}catch{
XCTFail("Cant write to pipe: \(error)")
return
}

 // Close the input pipe to send EOF to cat.
 inputPipe.fileHandleForWriting.closeFile()

 process.waitUntilExit()
XCTAssertEqual(process.terminationStatus,0)

letdata= outputPipe.fileHandleForReading.availableData
guardlet string =String(data: data, encoding:.utf8)else{
XCTFail("Could not read stdout")
return
}
XCTAssertEqual(string,"Hello, 🐶.\n")
}

func test_pipe_stdout()throws{
letprocess=Process()

 process.executableURL =tryxdgTestHelperURL()
 process.arguments =["--getcwd"]
letpipe=Pipe()
 process.standardOutput = pipe
 process.standardError =nil

try process.run()
 process.waitUntilExit()
XCTAssertEqual(process.terminationStatus,0)

letdata= pipe.fileHandleForReading.availableData
guardlet string =String(data: data, encoding:.ascii)else{
XCTFail("Could not read stdout")
return
}

XCTAssertEqual(string.trimmingCharacters(in:CharacterSet(["\n","\r"])),FileManager.default.currentDirectoryPath)
}

func test_pipe_stderr()throws{
letprocess=Process()

 process.executableURL =tryxdgTestHelperURL()
 process.arguments =["--cat","invalid_file_name"]

leterrorPipe=Pipe()
 process.standardError = errorPipe

try process.run()
 process.waitUntilExit()
XCTAssertEqual(process.terminationStatus,1)

letdata= errorPipe.fileHandleForReading.availableData
guardlet string =String(data: data, encoding:.ascii)else{
XCTFail("Could not read stdout")
return
}
 // Ignore messages from malloc debug etc on macOs
leterrMsg= string.trimmingCharacters(in:CharacterSet(["\n"])).components(separatedBy:"\n").last
XCTAssertEqual(errMsg,"cat: invalid_file_name: No such file or directory")
}

func test_pipe_stdout_and_stderr_same_pipe()throws{
letprocess=Process()

 process.executableURL =tryxdgTestHelperURL()
 process.arguments =["--cat","invalid_file_name"]

letpipe=Pipe()
 process.standardOutput = pipe
 process.standardError = pipe

 // Clear the environment to stop the malloc debug flags used in Xcode debug being
 // set in the subprocess.
 process.environment =[:]
#if os(Android)
 // In Android, we have to provide at least an LD_LIBRARY_PATH, or
 // xdgTestHelper will not be able to find the Swift libraries.
iflet ldLibraryPath =ProcessInfo.processInfo.environment["LD_LIBRARY_PATH"]{
 process.environment?["LD_LIBRARY_PATH"]= ldLibraryPath
}
#endif
try process.run()
 process.waitUntilExit()
XCTAssertEqual(process.terminationStatus,1)

letdata= pipe.fileHandleForReading.availableData
guardlet string =String(data: data, encoding:.ascii)else{
XCTFail("Could not read stdout")
return
}

 // Ignore messages from malloc debug etc on macOS
leterrMsg= string.trimmingCharacters(in:CharacterSet(["\n"])).components(separatedBy:"\n").last
XCTAssertEqual(errMsg,"cat: invalid_file_name: No such file or directory")
}

func test_file_stdout()throws{
letprocess=Process()

 process.executableURL =tryxdgTestHelperURL()
 process.arguments =["--getcwd"]

leturl:URL=URL(fileURLWithPath:NSTemporaryDirectory()).appendingPathComponent(ProcessInfo.processInfo.globallyUniqueString, isDirectory:false)
 _ =FileManager.default.createFile(atPath: url.path, contents:Data())
defer{ _ =try?FileManager.default.removeItem(at: url)}

lethandle:FileHandle=FileHandle(forUpdatingAtPath: url.path)!

 process.standardOutput = handle

try process.run()
 process.waitUntilExit()
XCTAssertEqual(process.terminationStatus,0)

 handle.seek(toFileOffset:0)
letdata= handle.readDataToEndOfFile()
guardlet string =String(data: data, encoding:.ascii)else{
XCTFail("Could not read stdout")
return
}
XCTAssertEqual(string.trimmingCharacters(in:CharacterSet(["\r","\n"])),FileManager.default.currentDirectoryPath)
}

func test_passthrough_environment()throws{
let(output, _)=tryrunTask([tryxdgTestHelperURL().path,"--env"], environment:nil)
letenv=tryparseEnv(output)
#if os(Windows)
 // On Windows, Path is always passed to the sub process
XCTAssertGreaterThan(env.count,1)
#else
XCTAssertGreaterThan(env.count,0)
#endif
}

func test_no_environment()throws{
let(output, _)=tryrunTask([tryxdgTestHelperURL().path,"--env"], environment:[:])
letenv=tryparseEnv(output)
#if os(Windows)
 // On Windows, Path is always passed to the sub process
XCTAssertEqual(env.count,1)
#else
XCTAssertEqual(env.count,0)
#endif
}

func test_custom_environment()throws{
letinput=["HELLO":"WORLD","HOME":"CUPERTINO"]
let(output, _)=tryrunTask([tryxdgTestHelperURL().path,"--env"], environment: input)
varenv=tryparseEnv(output)
#if os(Windows)
 // On Windows, Path is always passed to the sub process, remove it
 // before comparing.
 env.removeValue(forKey:"Path")
#endif
XCTAssertEqual(env, input)
}

func test_current_working_directory()throws{
lettmpDir={()->Stringin
 // NSTemporaryDirectory might return a final slash, but
 // FileManager.currentDirectoryPath seems to avoid it.
vardir=NSTemporaryDirectory()
if(dir.hasSuffix("/") && dir !="/") || dir.hasSuffix("\\"){
 dir.removeLast()
}
return dir.standardizePath()
}()

letfm=FileManager.default
letpreviousWorkingDirectory= fm.currentDirectoryPath
XCTAssertNotEqual(previousWorkingDirectory.standardizePath(), tmpDir)

 // Test that getcwd() returns the currentDirectoryPath
do{
let(pwd, _)=tryrunTask([tryxdgTestHelperURL().path,"--getcwd"], currentDirectoryPath: tmpDir)
 // Check the sub-process used the correct directory
XCTAssertEqual(pwd.trimmingCharacters(in:.newlines).standardizePath(), tmpDir)
}

 // Test that $PWD by default is set to currentDirectoryPath
do{
let(pwd, _)=tryrunTask([tryxdgTestHelperURL().path,"--echo-PWD"], currentDirectoryPath: tmpDir)
 // Check the sub-process used the correct directory
letcwd=FileManager.default.currentDirectoryPath.standardizePath()
XCTAssertNotEqual(cwd, tmpDir)
XCTAssertNotEqual(pwd.trimmingCharacters(in:.newlines).standardizePath(), tmpDir)
}

 // Test that $PWD can be over-ridden
do{
varenv=ProcessInfo.processInfo.environment
env["PWD"]="/bin"
let(pwd, _)=tryrunTask([tryxdgTestHelperURL().path,"--echo-PWD"], environment: env, currentDirectoryPath: tmpDir)
 // Check the sub-process used the correct directory
XCTAssertEqual(pwd.trimmingCharacters(in:.newlines),"/bin")
}

 // Test that $PWD can be set to empty
do{
varenv=ProcessInfo.processInfo.environment
env["PWD"]=""
let(pwd, _)=tryrunTask([tryxdgTestHelperURL().path,"--echo-PWD"], environment: env, currentDirectoryPath: tmpDir)
 // Check the sub-process used the correct directory
XCTAssertEqual(pwd.trimmingCharacters(in:.newlines),"")
}

XCTAssertEqual(previousWorkingDirectory, fm.currentDirectoryPath)
}

func test_run()throws{
letfm=FileManager.default
letcwd= fm.currentDirectoryPath

do{
letprocess=tryProcess.run(tryxdgTestHelperURL(), arguments:["--exit","123"], terminationHandler:nil)
 process.waitUntilExit()
XCTAssertEqual(process.terminationReason,.exit)
XCTAssertEqual(process.terminationStatus,123)
}
XCTAssertEqual(fm.currentDirectoryPath, cwd)

do{
 // Check running the process twice throws an error.
letprocess=Process()
 process.executableURL =tryxdgTestHelperURL()
 process.arguments =["--exit","0"]
XCTAssertNoThrow(try process.run())
 process.waitUntilExit()
XCTAssertThrowsError(try process.run()){
letnserror=($0 asNSError)
XCTAssertEqual(nserror.domain, NSCocoaErrorDomain)
letcode=CocoaError(_nsError: nserror).code
XCTAssertEqual(code,.executableLoad)
}
}

do{
letprocess=Process()
 process.executableURL =tryxdgTestHelperURL()
 process.arguments =["--exit","0"]
 process.currentDirectoryURL =URL(fileURLWithPath:"/.../_no_such_directory", isDirectory:true)
XCTAssertThrowsError(try process.run())
}
XCTAssertEqual(fm.currentDirectoryPath, cwd)

do{
letprocess=Process()
 process.executableURL =URL(fileURLWithPath:"/..", isDirectory:false)
 process.arguments =[]
 process.currentDirectoryURL =URL(fileURLWithPath:NSTemporaryDirectory())
XCTAssertThrowsError(try process.run())
}
XCTAssertEqual(fm.currentDirectoryPath, cwd)
 _ = fm.changeCurrentDirectoryPath(cwd)
}

func test_preStartEndState()throws{
letprocess=Process()
XCTAssertNil(process.executableURL)
XCTAssertNotNil(process.currentDirectoryURL)
XCTAssertNil(process.arguments)
XCTAssertNil(process.environment)
XCTAssertFalse(process.isRunning)
XCTAssertEqual(process.processIdentifier,0)
XCTAssertEqual(process.qualityOfService,.default)

 process.executableURL =tryxdgTestHelperURL()
 process.arguments =["--cat"]
 _ =try? process.run()
XCTAssertTrue(process.isRunning)
XCTAssertTrue(process.processIdentifier >0)
 process.terminate()
 process.waitUntilExit()
XCTAssertFalse(process.isRunning)
XCTAssertTrue(process.processIdentifier >0)
XCTAssertEqual(process.terminationReason,.uncaughtSignal)
XCTAssertEqual(process.terminationStatus, SIGTERM)
}

func test_interrupt()throws{
#if os(Windows)
throwXCTSkip("Windows does not have signals")
#else
lethelper=try_SignalHelperRunner()
do{
try helper.start()
}catch{
XCTFail("Cant run xdgTestHelper: \(error)")
return
}
if !helper.waitForReady(){
XCTFail("Didnt receive Ready from sub-process")
return
}

letnow=DispatchTime.now().uptimeNanoseconds
lettimeout=DispatchTime(uptimeNanoseconds: now +2_000_000_000)

varcount=3
while count >0{
 helper.process.interrupt()
guard helper.semaphore.wait(timeout: timeout)==.success else{
 helper.process.terminate()
XCTFail("Timedout waiting for signal")
return
}

if helper.sigIntCount ==3{
break
}
 count -=1
}
 helper.process.terminate()
XCTAssertEqual(helper.sigIntCount,3)
 helper.process.waitUntilExit()
letterminationReason= helper.process.terminationReason
XCTAssertEqual(terminationReason,Process.TerminationReason.exit)
letstatus= helper.process.terminationStatus
XCTAssertEqual(status,99)
#endif
}

func test_terminate()throws{
letprocess=tryProcess.run(tryxdgTestHelperURL(), arguments:["--cat"])

 process.terminate()
 process.waitUntilExit()
letterminationReason= process.terminationReason
XCTAssertEqual(terminationReason,Process.TerminationReason.uncaughtSignal)
XCTAssertEqual(process.terminationStatus, SIGTERM)
}


func test_suspend_resume()throws{
#if os(Windows)
throwXCTSkip("Windows does not have signals")
#else
nonisolated(unsafe)lethelper=try_SignalHelperRunner()
do{
try helper.start()
}catch{
XCTFail("Cant run xdgTestHelper: \(error)")
return
}
if !helper.waitForReady(){
XCTFail("Didnt receive Ready from sub-process")
return
}
letnow=DispatchTime.now().uptimeNanoseconds
lettimeout=DispatchTime(uptimeNanoseconds: now +2_000_000_000)

func waitForSemaphore()->Bool{
guard helper.semaphore.wait(timeout: timeout)==.success else{
 helper.process.terminate()
XCTFail("Timedout waiting for signal")
returnfalse
}
returntrue
}

XCTAssertTrue(helper.process.isRunning)
XCTAssertTrue(helper.process.suspend())
XCTAssertTrue(helper.process.isRunning)
XCTAssertTrue(helper.process.resume())
ifwaitForSemaphore()==false{return}
XCTAssertEqual(helper.sigContCount,1)

XCTAssertTrue(helper.process.resume())
XCTAssertTrue(helper.process.suspend())
XCTAssertTrue(helper.process.resume())
XCTAssertEqual(helper.sigContCount,1)

XCTAssertTrue(helper.process.suspend())
XCTAssertTrue(helper.process.suspend())
XCTAssertTrue(helper.process.resume())
ifwaitForSemaphore()==false{return}

 _ = helper.process.suspend()
 _ = helper.process.resume()
ifwaitForSemaphore()==false{return}
XCTAssertEqual(helper.sigContCount,3)

 helper.process.terminate()
 helper.process.waitUntilExit()
XCTAssertFalse(helper.process.isRunning)
XCTAssertFalse(helper.process.suspend())
XCTAssertTrue(helper.process.resume())
XCTAssertTrue(helper.process.resume())
#endif
}


func test_redirect_stdin_using_null()throws{
lettask=Process()
 task.executableURL =tryxdgTestHelperURL()
 task.arguments =["--cat"]
 task.standardInput =FileHandle.nullDevice
XCTAssertNoThrow(try task.run())
 task.waitUntilExit()
}


func test_redirect_stdout_using_null()throws{
lettask=Process()
 task.executableURL =tryxdgTestHelperURL()
 task.arguments =["--env"]
 task.standardOutput =FileHandle.nullDevice
XCTAssertNoThrow(try task.run())
 task.waitUntilExit()
}

func test_redirect_stdin_stdout_using_null()throws{
lettask=Process()
 task.executableURL =tryxdgTestHelperURL()
 task.arguments =["--cat"]
 task.standardInput =FileHandle.nullDevice
 task.standardOutput =FileHandle.nullDevice
XCTAssertNoThrow(try task.run())
 task.waitUntilExit()
}


func test_redirect_stderr_using_null()throws{
lettask=Process()
 task.executableURL =tryxdgTestHelperURL()
 task.arguments =["--env"]
 task.standardError =FileHandle.nullDevice
XCTAssertNoThrow(try task.run())
 task.waitUntilExit()
}


func test_redirect_all_using_null()throws{
lettask=Process()
 task.executableURL =tryxdgTestHelperURL()
 task.arguments =["--cat"]
 task.standardInput =FileHandle.nullDevice
 task.standardOutput =FileHandle.nullDevice
 task.standardError =FileHandle.nullDevice
XCTAssertNoThrow(try task.run())
 task.waitUntilExit()
}

func test_redirect_all_using_nil()throws{
lettask=Process()
 task.executableURL =tryxdgTestHelperURL()
 task.arguments =["--cat"]
 task.standardInput =nil
 task.standardOutput =nil
 task.standardError =nil
XCTAssertNoThrow(try task.run())
 task.waitUntilExit()
}


func test_plutil()throws{
#if os(Windows)
 // See explanation in xdgTestHelperURL() as to why this is unsupported
throwXCTSkip("Running plutil as part of unit tests is not supported on Windows")
#else
lettask=Process()

guardlet url =testBundle(executable:true).url(forAuxiliaryExecutable:"plutil")else{
throwError.ExternalBinaryNotFound("plutil")
}

 task.executableURL = url
 task.arguments =[]
letstdoutPipe=Pipe()
letstdoutData=Mutex(Data())
 task.standardError = stdoutPipe

 stdoutPipe.fileHandleForReading.readabilityHandler ={ fh in
 stdoutData.withLock{
 $0.append(fh.availableData)
}
}
try task.run()
 task.waitUntilExit()
 stdoutPipe.fileHandleForReading.readabilityHandler =nil

try stdoutData.withLock{
iflet d =try stdoutPipe.fileHandleForReading.readToEnd(){
 $0.append(d)
}
XCTAssertEqual(String(data: $0, encoding:.utf8)?.trimmingCharacters(in:.whitespacesAndNewlines),"No files specified.")
}
#endif
}

@available(*, deprecated) // test of deprecated API, suppress deprecation warning
func test_currentDirectory()throws{

letprocess=Process()
XCTAssertNil(process.executableURL)
XCTAssertNotNil(process.currentDirectoryURL)

 // Test currentDirectoryURL cannot be set to nil even though it is a URL?
letcwd=URL(fileURLWithPath:FileManager.default.currentDirectoryPath, isDirectory:true)
 process.currentDirectoryURL =nil
XCTAssertNotNil(process.currentDirectoryURL)
XCTAssertEqual(process.currentDirectoryURL, cwd)

letaFileURL=URL(fileURLWithPath:"/a_file", isDirectory:false)
XCTAssertFalse(aFileURL.hasDirectoryPath)
XCTAssertEqual(aFileURL.path,"/a_file")
 process.currentDirectoryURL = aFileURL
XCTAssertNotEqual(process.currentDirectoryURL, aFileURL)
XCTAssertEqual(process.currentDirectoryPath,"/a_file")
XCTAssertTrue(tryXCTUnwrap(process.currentDirectoryURL).hasDirectoryPath)
XCTAssertEqual(tryXCTUnwrap(process.currentDirectoryURL).absoluteString,"file:///a_file/")

letaDirURL=URL(fileURLWithPath:"/a_dir", isDirectory:true)
XCTAssertTrue(aDirURL.hasDirectoryPath)
XCTAssertEqual(aDirURL.path,"/a_dir")
 process.currentDirectoryURL = aDirURL
XCTAssertEqual(process.currentDirectoryURL, aDirURL)
XCTAssertEqual(process.currentDirectoryPath,"/a_dir")
XCTAssertTrue(tryXCTUnwrap(process.currentDirectoryURL).hasDirectoryPath)
XCTAssertEqual(tryXCTUnwrap(process.currentDirectoryURL).absoluteString,"file:///a_dir/")

 process.currentDirectoryPath =""
XCTAssertEqual(process.currentDirectoryPath,"")
XCTAssertNil(process.currentDirectoryURL)
 process.currentDirectoryURL =nil
XCTAssertEqual(process.currentDirectoryPath, cwd.withUnsafeFileSystemRepresentation{String(cString: $0!)})


 process.executableURL =URL(fileURLWithPath:"/some_file_that_doesnt_exist", isDirectory:false)
XCTAssertThrowsError(try process.run()){
letcode=CocoaError.Code(rawValue:($0 asNSError).code)
XCTAssertEqual(code,.fileReadNoSuchFile)
}

do{
let(stdout, _)=tryrunTask([tryxdgTestHelperURL().path,"--getcwd"], currentDirectoryPath:"/")
vardirectory= stdout.trimmingCharacters(in:CharacterSet(["\n","\r"]))
#if os(Windows)
letzero:String.Index= directory.startIndex
letone:String.Index= directory.index(zero, offsetBy:1)
XCTAssertTrue(directory[zero].isLetter)
XCTAssertEqual(directory[one],":")
 directory ="/"+ String(directory.dropFirst(2))
#endif
XCTAssertEqual(URL(fileURLWithPath: directory).absoluteURL,
URL(fileURLWithPath:"/").absoluteURL)
}

do{
 // NOTE: Windows does have an environment variable called `PWD`.
 // The closed thing is %CD% which is a property of the shell rather
 // than the environment. Simply ignore this test on Windows.
#if !os(Windows)
XCTAssertNotEqual("/",FileManager.default.currentDirectoryPath)
XCTAssertNotEqual(FileManager.default.currentDirectoryPath,"/")
let(stdout, _)=tryrunTask([tryxdgTestHelperURL().path,"--echo-PWD"], currentDirectoryPath:"/")
letdirectory= stdout.trimmingCharacters(in:CharacterSet(["\n","\r"]))
XCTAssertEqual(directory,ProcessInfo.processInfo.environment["PWD"])
XCTAssertNotEqual(directory,"/")
#endif
}

do{
letprocess=Process()
 process.executableURL =tryxdgTestHelperURL()
 process.arguments =["--getcwd"]
 process.currentDirectoryPath =""

letstdoutPipe=Pipe()
 process.standardOutput = stdoutPipe

try process.run()
 process.waitUntilExit()

guard process.terminationStatus ==0else{
throwError.TerminationStatus(process.terminationStatus)
}

varstdoutData=Data()
iflet d =try stdoutPipe.fileHandleForReading.readToEnd(){
 stdoutData.append(d)
}

guardlet stdout =String(data: stdoutData, encoding:.utf8)else{
throwError.UnicodeDecodingError(stdoutData)
}
letdirectory= stdout.trimmingCharacters(in:CharacterSet(["\n","\r"]))
XCTAssertEqual(directory,FileManager.default.currentDirectoryPath)
}

XCTAssertThrowsError(tryrunTask([tryxdgTestHelperURL().path,"--getcwd"], currentDirectoryPath:"/some_directory_that_doesnt_exsit")){ error in
letcode=CocoaError.Code(rawValue:(error asNSError).code)
XCTAssertEqual(code,.fileReadNoSuchFile)
}
}

#if !os(Windows)
func test_fileDescriptorsAreNotInherited()throws{
lettask=Process()
letsomeExtraFDs=[dup(1),dup(1),dup(1),dup(1),dup(1),dup(1),dup(1)]
 task.executableURL =tryxdgTestHelperURL()
 task.arguments =["--print-open-file-descriptors"]
 task.standardInput =FileHandle.nullDevice
letstdoutPipe=Pipe()
 task.standardOutput = stdoutPipe.fileHandleForWriting
 task.standardError =FileHandle.nullDevice
XCTAssertNoThrow(try task.run())

try stdoutPipe.fileHandleForWriting.close()
letstdoutData=try stdoutPipe.fileHandleForReading.readToEnd()
 task.waitUntilExit()
letstdoutString=String(decoding: stdoutData ??Data(), as:Unicode.UTF8.self)
#if os(macOS)
XCTAssertEqual("0\n1\n2\n", stdoutString)
#else
 // on Linux we may also have a /dev/urandom open as well as some socket that Process uses for something.

 // we should definitely have stdin (0), stdout (1), and stderr (2) open
XCTAssert(stdoutString.utf8.starts(with:"0\n1\n2\n".utf8))

 // in total we should have 6 or fewer lines:
 // 1. stdin
 // 2. stdout
 // 3. stderr
 // 4. /dev/urandom (optional)
 // 5. communication socket (optional)
 // 6. trailing new line
XCTAssertLessThanOrEqual(stdoutString.components(separatedBy:"\n").count,6,"\(stdoutString)")
#endif
forfdin someExtraFDs {
close(fd)
}
}
#endif

func test_pipeCloseBeforeLaunch()throws{
letprocess=Process()
letstdInput=Pipe()
letstdOutput=Pipe()

 process.executableURL =tryxdgTestHelperURL()
 process.arguments =["--cat"]
 process.standardInput = stdInput
 process.standardOutput = stdOutput

letstring="Hello, World"
letstdInputPipe= stdInput.fileHandleForWriting
XCTAssertNoThrow(try stdInputPipe.write(XCTUnwrap(string.data(using:.utf8))))
 stdInputPipe.closeFile()

XCTAssertNoThrow(try process.run())
 process.waitUntilExit()

letstdOutputPipe= stdOutput.fileHandleForReading
do{
letreadData=tryXCTUnwrap(stdOutputPipe.readToEnd())
letreadString=String(data: readData, encoding:.utf8)
XCTAssertEqual(string, readString)
}catch{
XCTFail("\(error)")
}
}

func test_multiProcesses()throws{
letsource=Process()
 source.executableURL =tryxdgTestHelperURL()
 source.arguments =["--getcwd"]

letcat1=Process()
 cat1.executableURL =tryxdgTestHelperURL()
 cat1.arguments =["--cat"]

letcat2=Process()
 cat2.executableURL =tryxdgTestHelperURL()
 cat2.arguments =["--cat"]

letpipe1=Pipe()
 source.standardOutput = pipe1
 cat1.standardInput = pipe1

letpipe2=Pipe()
 cat1.standardOutput = pipe2
 cat2.standardInput = pipe2

letpipe3=Pipe()
 cat2.standardOutput = pipe3

XCTAssertNoThrow(try source.run())
XCTAssertNoThrow(try cat1.run())
XCTAssertNoThrow(try cat2.run())
 cat2.waitUntilExit()
 cat1.waitUntilExit()
 source.waitUntilExit()

do{
letdata=tryXCTUnwrap(pipe3.fileHandleForReading.readToEnd())
letpwd=String.init(decoding: data, as:UTF8.self).trimmingCharacters(in:CharacterSet(["\n","\r"]))
XCTAssertEqual(pwd,FileManager.default.currentDirectoryPath)
}catch{
XCTFail("\(error)")
}
}

#if !os(Windows)
func test_processGroup()throws{
 // The process group of the child process should be different to the parent's.
letprocess=Process()

 process.executableURL =tryxdgTestHelperURL()
 process.arguments =["--pgrp"]
letpipe=Pipe()
 process.standardOutput = pipe
 process.standardError =nil

try process.run()
 process.waitUntilExit()
XCTAssertEqual(process.terminationStatus,0)

letdata= pipe.fileHandleForReading.availableData
guardlet string =String(data: data, encoding:.ascii)else{
XCTFail("Could not read stdout")
return
}

letparts= string.trimmingCharacters(in:.newlines).components(separatedBy:": ")
guard parts.count ==2,parts[0]=="pgrp",let childPgrp =Int(parts[1])else{
XCTFail("Could not pgrp fron stdout")
return
}
letparentPgrp=Int(getpgrp())
XCTAssertNotEqual(parentPgrp, childPgrp,"Child process group \(parentPgrp) should not equal parent process group \(childPgrp)")
}
#endif
}

privateenumError:Swift.Error{
case TerminationStatus(Int32)
case UnicodeDecodingError(Data)
case InvalidEnvironmentVariable(String)
case ExternalBinaryNotFound(String)
}

// Run xdgTestHelper, wait for 'Ready' from the sub-process, then signal a semaphore.
// Read lines from a pipe and store in a queue.
class_SignalHelperRunner{
letprocess=Process()
letsemaphore=DispatchSemaphore(value:0)

privateletoutputPipe=Pipe()
privateletsQueue=DispatchQueue(label:"signal queue")

privatevargotReady=false
privatevarbytesIn=Data()
privatevar_sigIntCount=0
privatevar_sigContCount=0
varsigIntCount:Int{return sQueue.sync{return _sigIntCount }}
varsigContCount:Int{return sQueue.sync{return _sigContCount }}


init()throws{
 process.executableURL =tryxdgTestHelperURL()
 process.environment =ProcessInfo.processInfo.environment
 process.arguments =["--signal-test"]
 process.standardOutput = outputPipe.fileHandleForWriting

nonisolated(unsafe)letnonisolatedSelf=self
 outputPipe.fileHandleForReading.readabilityHandler ={ fh in
letnewLine=UInt8(ascii:"\n")

 nonisolatedSelf.bytesIn.append(fh.availableData)
if nonisolatedSelf.bytesIn.isEmpty {
return
}
 // Split the incoming data into lines.
whilelet index = nonisolatedSelf.bytesIn.firstIndex(of: newLine){
if index >= nonisolatedSelf.bytesIn.startIndex {
 // don't include the newline when converting to string
letline=String(data: nonisolatedSelf.bytesIn[nonisolatedSelf.bytesIn.startIndex..<index], encoding:String.Encoding.utf8)??""
 nonisolatedSelf.bytesIn.removeSubrange(nonisolatedSelf.bytesIn.startIndex...index)

if nonisolatedSelf.gotReady ==false && line =="Ready"{
 nonisolatedSelf.semaphore.signal()
 nonisolatedSelf.gotReady =true;
}
elseif nonisolatedSelf.gotReady ==true{
if line =="Signal: SIGINT"{
 nonisolatedSelf.sQueue.sync{ nonisolatedSelf._sigIntCount +=1}
 nonisolatedSelf.semaphore.signal()
}
elseif line =="Signal: SIGCONT"{
 nonisolatedSelf.sQueue.sync{ nonisolatedSelf._sigContCount +=1}
 nonisolatedSelf.semaphore.signal()
}
}
}
}
}
}

deinit{
 process.terminate()
 process.waitUntilExit()
}

func start()throws{
try process.run()
}

func waitForReady()->Bool{
letnow=DispatchTime.now().uptimeNanoseconds
lettimeout=DispatchTime(uptimeNanoseconds: now +2_000_000_000)
guard semaphore.wait(timeout: timeout)==.success else{
 process.terminate()
returnfalse
}
returntrue
}
}

@discardableResult
internalfunc runTask(_ arguments:[String], environment:[String:String]?=nil, currentDirectoryPath:String?=nil)throws->(String,String){
letprocess=Process()

vararguments= arguments
letfirstArg= arguments.removeFirst()
 process.executableURL =URL(fileURLWithPath: firstArg)
 process.arguments = arguments
 // Darwin Foundation doesnt allow .environment to be set to nil although the documentation
 // says it is an optional. https://developer.apple.com/documentation/foundation/process/1409412-environment
ifvar e = environment {
#if os(Android)
 // In Android, we have to provide at least an LD_LIBRARY_PATH, or
 // xdgTestHelper will not be able to find the Swift libraries.
ife["LD_LIBRARY_PATH"]==nil{
iflet ldLibraryPath =ProcessInfo.processInfo.environment["LD_LIBRARY_PATH"]{
e["LD_LIBRARY_PATH"]= ldLibraryPath
}
}
#endif
 process.environment = e
}

iflet dirPath = currentDirectoryPath {
 process.currentDirectoryURL =URL(fileURLWithPath: dirPath, isDirectory:true)
}

letstdoutPipe=Pipe()
letstderrPipe=Pipe()
structOutput{
varstdoutData=Data()
varstderrData=Data()
}
letdataLock=Mutex(Output())
 process.standardOutput = stdoutPipe
 process.standardError = stderrPipe

 stdoutPipe.fileHandleForReading.readabilityHandler ={ fh in
 dataLock.withLock{
 $0.stdoutData.append(fh.availableData)
}
}

 stderrPipe.fileHandleForReading.readabilityHandler ={ fh in
 dataLock.withLock{
 $0.stderrData.append(fh.availableData)
}
}

try process.run()
 process.waitUntilExit()
 stdoutPipe.fileHandleForReading.readabilityHandler =nil
 stderrPipe.fileHandleForReading.readabilityHandler =nil

guard process.terminationStatus ==0else{
throwError.TerminationStatus(process.terminationStatus)
}

returntry dataLock.withLock{
 // Drain any data remaining in the pipes
iflet d =try stdoutPipe.fileHandleForReading.readToEnd(){
 $0.stdoutData.append(d)
}

iflet d =try stderrPipe.fileHandleForReading.readToEnd(){
 $0.stderrData.append(d)
}

guardlet stdout =String(data: $0.stdoutData, encoding:.utf8)else{
throwError.UnicodeDecodingError($0.stdoutData)
}

guardlet stderr =String(data: $0.stderrData, encoding:.utf8)else{
throwError.UnicodeDecodingError($0.stderrData)
}

return(stdout, stderr)
}
}

privatefunc parseEnv(_ env:String)throws->[String:String]{
varresult=[String: String]()
forlinein env.components(separatedBy:.newlines)where line !=""{
guardlet range = line.range(of:"=")else{
throwError.InvalidEnvironmentVariable(line)
}