TestFileManager.swift

// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2020 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
//

#if NS_FOUNDATION_ALLOWS_TESTABLE_IMPORT
#if canImport(SwiftFoundation) && !DEPLOYMENT_RUNTIME_OBJC
@testableimport SwiftFoundation
#else
@testableimport Foundation
#endif
#endif

import Dispatch

classTestFileManager:XCTestCase{
#if os(Windows)
letpathSep="\\"
#else
letpathSep="/"
#endif

func test_NSTemporaryDirectory(){
#if os(Windows)
letvalidPathSeps:[Character]=["\\","/"]
#else
letvalidPathSeps:[Character]=["/"]
#endif

lettempDir=NSTemporaryDirectory()
XCTAssertTrue(validPathSeps.contains(where:{ tempDir.hasSuffix(String($0))}),"Temporary directory path must end with path separator")
}

func test_createDirectory(){
letfm=FileManager.default
letpath=NSTemporaryDirectory()+"testdir\(NSUUID().uuidString)"

try? fm.removeItem(atPath: path)

do{
try fm.createDirectory(atPath: path, withIntermediateDirectories:false, attributes:nil)
}catch{
XCTFail()
}

 // Ensure attempting to create the directory again fails gracefully.
XCTAssertNil(try? fm.createDirectory(atPath: path, withIntermediateDirectories:false, attributes:nil))

varisDir:ObjCBool=false
letexists= fm.fileExists(atPath: path, isDirectory:&isDir)
XCTAssertTrue(exists)
XCTAssertTrue(isDir.boolValue)

do{
try fm.removeItem(atPath: path)
}catch{
XCTFail("Failed to clean up file")
}

}

func test_createFile()throws{
letfm=FileManager.default
letpath=NSTemporaryDirectory()+"testfile\(NSUUID().uuidString)"

try? fm.removeItem(atPath: path)

XCTAssertTrue(fm.createFile(atPath: path, contents:Data(), attributes:nil))

varisDir:ObjCBool=false
letexists= fm.fileExists(atPath: path, isDirectory:&isDir)
XCTAssertTrue(exists)
XCTAssertFalse(isDir.boolValue)

try fm.removeItem(atPath: path)

#if os(Windows)
letpermissions=NSNumber(value:Int16(0o600))
#else
letpermissions=NSNumber(value:Int16(0o753))
#endif
letattributes=[FileAttributeKey.posixPermissions: permissions]
XCTAssertTrue(fm.createFile(atPath: path, contents:Data(),
 attributes: attributes))
letretrievedAtributes=try fm.attributesOfItem(atPath: path)

letretrievedPermissions=tryXCTUnwrap(retrievedAtributes[.posixPermissions]as?NSNumber)
XCTAssertEqual(retrievedPermissions, permissions)

try fm.removeItem(atPath: path)
}

func test_creatingDirectoryWithShortIntermediatePath(){
letfileManager=FileManager.default
letcwd= fileManager.currentDirectoryPath
 _ = fileManager.changeCurrentDirectoryPath(NSTemporaryDirectory())

letrelativePath=NSUUID().uuidString

do{
try fileManager.createDirectory(atPath: relativePath, withIntermediateDirectories:true, attributes:nil)
try fileManager.removeItem(atPath: relativePath)
}catch{
XCTFail("Failed to create and clean up directory")
}
 _ = fileManager.changeCurrentDirectoryPath(cwd)
}

func test_moveFile(){
letfm=FileManager.default
letpath=NSTemporaryDirectory()+"testfile\(NSUUID().uuidString)"
letpath2=NSTemporaryDirectory()+"testfile2\(NSUUID().uuidString)"

func cleanup(){
try? fm.removeItem(atPath: path)
try? fm.removeItem(atPath: path2)
}

cleanup()

XCTAssertTrue(fm.createFile(atPath: path, contents:Data(), attributes:nil))
defer{cleanup()}

do{
try fm.moveItem(atPath: path, toPath: path2)
}catch{
XCTFail("Failed to move file: \(error)")
}
}

func test_fileSystemRepresentation(){
letstr="☃"
letresult=FileManager.default.fileSystemRepresentation(withPath: str)
XCTAssertEqual(UInt8(bitPattern:result[0]),0xE2)
XCTAssertEqual(UInt8(bitPattern:result[1]),0x98)
XCTAssertEqual(UInt8(bitPattern:result[2]),0x83)

#if !DARWIN_COMPATIBILITY_TESTS // auto-released by Darwin's Foundation
 result.deallocate()
#endif
}

func test_fileExists(){
letfm=FileManager.default
lettmpDir= fm.temporaryDirectory.appendingPathComponent("testFileExistsDir")
lettestFile= tmpDir.appendingPathComponent("testFile")
letgoodSymLink= tmpDir.appendingPathComponent("goodSymLink")
letbadSymLink= tmpDir.appendingPathComponent("badSymLink")
letdirSymLink= tmpDir.appendingPathComponent("dirSymlink")

try? fm.removeItem(atPath: tmpDir.path)

do{
try fm.createDirectory(atPath: tmpDir.path, withIntermediateDirectories:false, attributes:nil)
XCTAssertTrue(fm.createFile(atPath: testFile.path, contents:Data()))
try fm.createSymbolicLink(atPath: goodSymLink.path, withDestinationPath: testFile.path)
try fm.createSymbolicLink(atPath: badSymLink.path, withDestinationPath:"no_such_file")
try fm.createSymbolicLink(atPath: dirSymLink.path, withDestinationPath:"..")

varisDirFlag:ObjCBool=false
XCTAssertTrue(fm.fileExists(atPath: tmpDir.path))
XCTAssertTrue(fm.fileExists(atPath: tmpDir.path, isDirectory:&isDirFlag))
XCTAssertTrue(isDirFlag.boolValue)

 isDirFlag =true
XCTAssertTrue(fm.fileExists(atPath: testFile.path))
XCTAssertTrue(fm.fileExists(atPath: testFile.path, isDirectory:&isDirFlag))
XCTAssertFalse(isDirFlag.boolValue)

 isDirFlag =true
XCTAssertTrue(fm.fileExists(atPath: goodSymLink.path))
XCTAssertTrue(fm.fileExists(atPath: goodSymLink.path, isDirectory:&isDirFlag))
XCTAssertFalse(isDirFlag.boolValue)

 isDirFlag =true
XCTAssertFalse(fm.fileExists(atPath: badSymLink.path))
XCTAssertFalse(fm.fileExists(atPath: badSymLink.path, isDirectory:&isDirFlag))

 isDirFlag =false
XCTAssertTrue(fm.fileExists(atPath: dirSymLink.path))
XCTAssertTrue(fm.fileExists(atPath: dirSymLink.path, isDirectory:&isDirFlag))
XCTAssertTrue(isDirFlag.boolValue)
}catch{
XCTFail(String(describing: error))
}
try? fm.removeItem(atPath: tmpDir.path)
}

func test_fileAttributes()throws{
letfm=FileManager.default
letpath=NSTemporaryDirectory()+"test_fileAttributes\(NSUUID().uuidString)"

try? fm.removeItem(atPath: path)

XCTAssertTrue(fm.createFile(atPath: path, contents:Data(), attributes:nil))

do{
letattrs=try fm.attributesOfItem(atPath: path)

XCTAssertTrue(attrs.count >0)

letfileSize=attrs[.size]as?NSNumber
XCTAssertEqual(fileSize!.int64Value,0)

letfileModificationDate=attrs[.modificationDate]as?Date
XCTAssertGreaterThan(Date().timeIntervalSince1970, fileModificationDate!.timeIntervalSince1970)

letfilePosixPermissions=attrs[.posixPermissions]as?NSNumber
XCTAssertNotEqual(filePosixPermissions!.int64Value,0)

letfileReferenceCount=attrs[.referenceCount]as?NSNumber
XCTAssertEqual(fileReferenceCount!.int64Value,1)

letfileSystemNumber=attrs[.systemNumber]as?NSNumber
XCTAssertNotEqual(fileSystemNumber!.int64Value,0)

#if !os(Windows)
letfileSystemFileNumber=attrs[.systemFileNumber]as?NSNumber
XCTAssertNotEqual(fileSystemFileNumber!.int64Value,0)
#endif

letfileType=attrs[.type]as?FileAttributeType
XCTAssertEqual(fileType!,.typeRegular)

letfileOwnerAccountID=attrs[.ownerAccountID]as?NSNumber
XCTAssertNotNil(fileOwnerAccountID)

letfileGroupOwnerAccountID=attrs[.groupOwnerAccountID]as?NSNumber
XCTAssertNotNil(fileGroupOwnerAccountID)

 // .creationDate is not not available on all systems but if it is supported check the value is reasonable
iflet creationDate =attrs[.creationDate]as?Date{
XCTAssertGreaterThan(Date().timeIntervalSince1970, creationDate.timeIntervalSince1970)
}

iflet fileOwnerAccountName =attrs[.ownerAccountName]{
XCTAssertNotNil(fileOwnerAccountName as?String)
iflet fileOwnerAccountNameStr = fileOwnerAccountName as?String{
XCTAssertFalse(fileOwnerAccountNameStr.isEmpty)
}
}

iflet fileGroupOwnerAccountName =attrs[.groupOwnerAccountName]{
XCTAssertNotNil(fileGroupOwnerAccountName as?String)
iflet fileGroupOwnerAccountNameStr = fileGroupOwnerAccountName as?String{
XCTAssertFalse(fileGroupOwnerAccountNameStr.isEmpty)
}
}

}catch{
XCTFail("\(error)")
}

do{
try fm.removeItem(atPath: path)
}catch{
XCTFail("Failed to clean up files")
}
}

func test_fileSystemAttributes(){
letfm=FileManager.default
letpath=NSTemporaryDirectory()

do{
letattrs=try fm.attributesOfFileSystem(forPath: path)

XCTAssertTrue(attrs.count >0)

letsystemNumber=attrs[.systemNumber]as?NSNumber
XCTAssertNotNil(systemNumber)

letsystemFreeSize=attrs[.systemFreeSize]as?NSNumber
XCTAssertNotNil(systemFreeSize)
XCTAssertNotEqual(systemFreeSize!.uint64Value,0)

letsystemSize=attrs[.systemSize]as?NSNumber
XCTAssertNotNil(systemSize)
XCTAssertGreaterThan(systemSize!.uint64Value, systemFreeSize!.uint64Value)

ifshouldAttemptWindowsXFailTests("FileAttributes[.systemFreeNodes], FileAttributes[.systemNodes] not implemented"){
letsystemFreeNodes=attrs[.systemFreeNodes]as?NSNumber
XCTAssertNotNil(systemFreeNodes)
XCTAssertNotEqual(systemFreeNodes!.uint64Value,0)

letsystemNodes=attrs[.systemNodes]as?NSNumber
XCTAssertNotNil(systemNodes)
XCTAssertGreaterThan(systemNodes!.uint64Value, systemFreeNodes!.uint64Value)
}
}catch{
XCTFail("\(error)")
}
}

func test_setFileAttributes(){
letpath=NSTemporaryDirectory()+"test_setFileAttributes\(NSUUID().uuidString)"
letfm=FileManager.default

try? fm.removeItem(atPath: path)
XCTAssertTrue(fm.createFile(atPath: path, contents:Data(), attributes:nil))

letmodificationDate=NSDate(timeIntervalSince1970:1234567890.5) // 2009-02-13T23:31:30.500Z

do{
try fm.setAttributes([.posixPermissions :NSNumber(value:Int16(0o0600))], ofItemAtPath: path)
try fm.setAttributes([.modificationDate: modificationDate], ofItemAtPath: path)
}
catch{XCTFail("\(error)")}

 //read back the attributes
do{
letattributes=try fm.attributesOfItem(atPath: path)
XCTAssert((attributes[.posixPermissions]as?NSNumber)?.int16Value ==0o0600)
XCTAssertEqual((attributes[.modificationDate]as?NSDate)?.timeIntervalSince1970 ??.nan, modificationDate.timeIntervalSince1970, accuracy:1.0)
}
catch{XCTFail("\(error)")}

do{
try fm.removeItem(atPath: path)
}catch{
XCTFail("Failed to clean up files")
}

 // test non existent file
letnoSuchFile=NSTemporaryDirectory()+"fileThatDoesntExist"
try? fm.removeItem(atPath: noSuchFile)
do{
try fm.setAttributes([.posixPermissions:0], ofItemAtPath: noSuchFile)
XCTFail("Setting permissions of non-existent file should throw")
}catch{
}
}

func test_pathEnumerator(){
letfm=FileManager.default
lettestDirName="testdir\(NSUUID().uuidString)"
letbasePath=NSTemporaryDirectory()+"\(testDirName)"
letitemPath=NSTemporaryDirectory()+"\(testDirName)/item"
letbasePath2=NSTemporaryDirectory()+"\(testDirName)/path2"
letitemPath2=NSTemporaryDirectory()+"\(testDirName)/path2/item"
defer{
try? fm.removeItem(atPath: basePath)
}

do{
try fm.createDirectory(atPath: basePath, withIntermediateDirectories:false, attributes:nil)
try fm.createDirectory(atPath: basePath2, withIntermediateDirectories:false, attributes:nil)

if !fm.createFile(atPath: itemPath, contents:Data(count:123), attributes:nil){
throwCocoaError(.fileWriteUnknown)
}
if !fm.createFile(atPath: itemPath2, contents:Data(count:456), attributes:nil){
throwCocoaError(.fileWriteUnknown)
}
}catch{
XCTFail("Failed with error while creating temporary files: \(error)")
return
}

varitem1FileAttributes:[FileAttributeKey:Any]!
varitem2FileAttributes:[FileAttributeKey:Any]!
iflet e =FileManager.default.enumerator(atPath: basePath){
letattrs= e.directoryAttributes
XCTAssertNotNil(attrs)
XCTAssertEqual(attrs?[.type]as?FileAttributeType,.typeDirectory)

varfoundItems=Set<String>()
whilelet item = e.nextObject()as?String{
 foundItems.insert(item)
if item =="item"{
 item1FileAttributes = e.fileAttributes
}elseif item =="path2\(pathSep)item"{
 item2FileAttributes = e.fileAttributes
}
}
XCTAssertEqual(foundItems,Set(["item","path2","path2\(pathSep)item"]))
}else{
XCTFail()
}

XCTAssertNotNil(item1FileAttributes)
iflet size =item1FileAttributes[.size]as?NSNumber{
XCTAssertEqual(size.int64Value,123)
}else{
XCTFail("Cant get file size for 'item'")
}

XCTAssertNotNil(item2FileAttributes)
iflet size =item2FileAttributes[.size]as?NSNumber{
XCTAssertEqual(size.int64Value,456)
}else{
XCTFail("Cant get file size for 'path2/item'")
}

iflet e2 =FileManager.default.enumerator(atPath: basePath){
varfoundItems=Set<String>()
whilelet item = e2.nextObject()as?String{
 foundItems.insert(item)
if item =="path2"{
 e2.skipDescendants()
XCTAssertEqual(e2.level,1)
XCTAssertNotNil(e2.fileAttributes)
}
}
XCTAssertEqual(foundItems,Set(["item","path2"]))
}else{
XCTFail()
}
}

func test_directoryEnumerator(){
letfm=FileManager.default
letbasePath=NSTemporaryDirectory()+"testdir\(NSUUID().uuidString)/"
lethiddenDir1= basePath +"subdir1/subdir2/.hiddenDir/"
letsubDirs1= hiddenDir1 +"subdir3/"
letitemPath1= basePath +"itemFile1"
#if os(Windows)
 // Filenames ending with '.' are not valid on Windows, so don't bother testing them
lethiddenDir2= basePath +"subdir1/subdir2/subdir4.app/subdir5/.subdir6.ext/"
letsubDirs2= hiddenDir2 +"subdir7.ext/"
letitemPath2= subDirs1 +"itemFile2"
letitemPath3= subDirs1 +"itemFile3.ext"
#else
lethiddenDir2= basePath +"subdir1/subdir2/subdir4.app/subdir5./.subdir6.ext/"
letsubDirs2= hiddenDir2 +"subdir7.ext./"
letitemPath2= subDirs1 +"itemFile2."
letitemPath3= subDirs1 +"itemFile3.ext."
#endif
lethiddenItem1= basePath +".hiddenFile1"
lethiddenItem2= subDirs1 +".hiddenFile2"
lethiddenItem3= subDirs2 +".hiddenFile3"
lethiddenItem4= subDirs2 +".hiddenFile4.ext"

varfileLevels:[String:Int]=[
"itemFile1":1,
".hiddenFile1":1,
"subdir1":1,
"subdir2":2,
"subdir4.app":3,
".subdir6.ext":5,
".hiddenFile4.ext":7,
".hiddenFile3":7,
".hiddenDir":3,
"subdir3":4,
".hiddenFile2":5,
]
#if os(Windows)
fileLevels["itemFile2"]=5
fileLevels["subdir5"]=4
fileLevels["subdir7.ext"]=6
fileLevels["itemFile3.ext"]=5
#else
fileLevels["itemFile2."]=5
fileLevels["subdir5."]=4
fileLevels["subdir7.ext."]=6
fileLevels["itemFile3.ext."]=5
#endif

func directoryItems(options:FileManager.DirectoryEnumerationOptions)->[String:Int]?{
guardlet enumerator =
FileManager.default.enumerator(at:URL(fileURLWithPath: basePath),
 includingPropertiesForKeys:nil,
 options: options, errorHandler:nil)else{
returnnil
}

varfoundItems=[String:Int]()
whilelet item = enumerator.nextObject()as?URL{
foundItems[item.lastPathComponent]= enumerator.level
}
return foundItems
}

try? fm.removeItem(atPath: basePath)
defer{try? fm.removeItem(atPath: basePath)}

XCTAssertNotNil(try? fm.createDirectory(atPath: subDirs1, withIntermediateDirectories:true, attributes:nil))
XCTAssertNotNil(try? fm.createDirectory(atPath: subDirs2, withIntermediateDirectories:true, attributes:nil))
forfilenamein[itemPath1, itemPath2, itemPath3]{
XCTAssertTrue(fm.createFile(atPath: filename, contents:Data(), attributes:nil),"Cant create file '\(filename)'")
}

varresourceValues=URLResourceValues()
 resourceValues.isHidden =true
forfilenamein[ hiddenItem1, hiddenItem2, hiddenItem3, hiddenItem4]{
XCTAssertTrue(fm.createFile(atPath: filename, contents:Data(), attributes:nil),"Cant create file '\(filename)'")
#if os(Windows)
do{
varurl=URL(fileURLWithPath: filename)
try url.setResourceValues(resourceValues)
}catch{
XCTFail("Couldn't make \(filename) a hidden file")
}
#endif
}

#if os(Windows)
do{
varhiddenURL1=URL(fileURLWithPath: hiddenDir1)
varhiddenURL2=URL(fileURLWithPath: hiddenDir2)
try hiddenURL1.setResourceValues(resourceValues)
try hiddenURL2.setResourceValues(resourceValues)
}catch{
XCTFail("Couldn't make \(hiddenDir1) and \(hiddenDir2) hidden directories")
}
#endif

iflet foundItems =directoryItems(options:[]){
XCTAssertEqual(foundItems.count, fileLevels.count)
for(name, level)in foundItems {
XCTAssertEqual(fileLevels[name], level,"File level for \(name) is wrong")
}
}else{
XCTFail("Cant enumerate directory at \(basePath) with options: []")
}

iflet foundItems =directoryItems(options:[.skipsHiddenFiles]){
XCTAssertEqual(foundItems.count,5)
}else{
XCTFail("Cant enumerate directory at \(basePath) with options: [.skipsHiddenFiles]")
}

iflet foundItems =directoryItems(options:[.skipsSubdirectoryDescendants]){
XCTAssertEqual(foundItems.count,3)
}else{
XCTFail("Cant enumerate directory at \(basePath) with options: [.skipsSubdirectoryDescendants]")
}

iflet foundItems =directoryItems(options:[.skipsHiddenFiles,.skipsSubdirectoryDescendants]){
XCTAssertEqual(foundItems.count,2)
}else{
XCTFail("Cant enumerate directory at \(basePath) with options: [.skipsHiddenFiles, .skipsSubdirectoryDescendants]")
}

iflet foundItems =directoryItems(options:[.skipsPackageDescendants]){
#if DARWIN_COMPATIBILITY_TESTS
XCTAssertEqual(foundItems.count,10) // Only native Foundation does not gnore .skipsPackageDescendants
#else
XCTAssertEqual(foundItems.count,15)
#endif
}else{
XCTFail("Cant enumerate directory at \(basePath) with options: [.skipsHiddenFiles, .skipsSubdirectoryDescendants]")
}

vardidGetError=false
lethandler:(URL,Error)->Bool={(URL, Error)in
 didGetError =true
returntrue
}
iflet e =FileManager.default.enumerator(at:URL(fileURLWithPath:"/nonexistent-path"), includingPropertiesForKeys:nil, options:[], errorHandler: handler){
XCTAssertNil(e.nextObject())
}else{
XCTFail()
}
XCTAssertTrue(didGetError)

do{
letcontents=tryFileManager.default.contentsOfDirectory(at:URL(fileURLWithPath: basePath), includingPropertiesForKeys:nil, options:[]).map{
return $0.path
}
XCTAssertEqual(contents.count,3)
}catch{
XCTFail()
}
}

func test_contentsOfDirectoryAtPath(){
letfm=FileManager.default
lettestDirName="testdir\(NSUUID().uuidString)"
letpath=NSTemporaryDirectory()+"\(testDirName)"
letitemPath1=NSTemporaryDirectory()+"\(testDirName)/item"
letitemPath2=NSTemporaryDirectory()+"\(testDirName)/item2"

try? fm.removeItem(atPath: path)

do{
try fm.createDirectory(atPath: path, withIntermediateDirectories:false, attributes:nil)
let _ = fm.createFile(atPath: itemPath1, contents:Data(), attributes:nil)
let _ = fm.createFile(atPath: itemPath2, contents:Data(), attributes:nil)
}catch{
XCTFail()
}

do{
letentries=try fm.contentsOfDirectory(atPath: path)

XCTAssertEqual(2, entries.count)
XCTAssertTrue(entries.contains("item"))
XCTAssertTrue(entries.contains("item2"))
}
catch{
XCTFail()
}

do{
 // Check a bad path fails
let _ =try fm.contentsOfDirectory(atPath:"/...")
XCTFail()
}
catch{
 // Invalid directories should fail.
}

do{
try fm.removeItem(atPath: path)
}catch{
XCTFail("Failed to clean up files")
}
}

func test_contentsOfDirectoryEnumeration()throws{
letfm=FileManager.default

letroot=URL(fileURLWithPath:NSTemporaryDirectory()).appendingPathComponent(NSUUID().uuidString, isDirectory:true)
letsubdirectory= root.appendingPathComponent("subdirectory", isDirectory:true)
letfile= subdirectory.appendingPathComponent("file", isDirectory:false)
try? fm.removeItem(at: root)

tryXCTAssertNoThrow(fm.createDirectory(at: subdirectory, withIntermediateDirectories:true, attributes:nil))
 _ = fm.createFile(atPath: file.path, contents:Data(), attributes:nil)
letcontents=tryXCTUnwrap(fm.contentsOfDirectory(at: root, includingPropertiesForKeys:[.isDirectoryKey], options:[.skipsHiddenFiles]))
XCTAssertEqual(contents.count,1)
XCTAssertEqual(contents,[subdirectory])
}

func test_subpathsOfDirectoryAtPath(){
letfm=FileManager.default
letpath=NSTemporaryDirectory()+"testdir"
letpath2=NSTemporaryDirectory()+"testdir/sub"
letitemPath1=NSTemporaryDirectory()+"testdir/item"
letitemPath2=NSTemporaryDirectory()+"testdir/item2"
letitemPath3=NSTemporaryDirectory()+"testdir/sub/item3"

try? fm.removeItem(atPath: path)

do{
try fm.createDirectory(atPath: path, withIntermediateDirectories:false, attributes:nil)
let _ = fm.createFile(atPath: itemPath1, contents:Data(), attributes:nil)
let _ = fm.createFile(atPath: itemPath2, contents:Data(), attributes:nil)

try fm.createDirectory(atPath: path2, withIntermediateDirectories:false, attributes:nil)
let _ = fm.createFile(atPath: itemPath3, contents:Data(), attributes:nil)
}catch{
XCTFail()
}

do{
letentries=try fm.subpathsOfDirectory(atPath: path)

XCTAssertEqual(4, entries.count)
XCTAssertTrue(entries.contains("item"))
XCTAssertTrue(entries.contains("item2"))
XCTAssertTrue(entries.contains("sub"))
XCTAssertTrue(entries.contains("sub/item3"))
XCTAssertEqual(fm.subpaths(atPath: path), entries)
}
catch{
XCTFail()
}

do{
 // Check a bad path fails
XCTAssertNil(fm.subpaths(atPath:"/does-not-exist"))

let _ =try fm.subpathsOfDirectory(atPath:"/does-not-exist")
XCTFail()
}
catch{
 // Invalid directories should fail.
}

do{
try fm.removeItem(atPath: path)
}catch{
XCTFail("Failed to clean up files")
}
}

privatefunc directoryExists(atPath path:String)->Bool{
varisDir:ObjCBool=false
letexists=FileManager.default.fileExists(atPath: path, isDirectory:&isDir)
return exists && isDir.boolValue
}

func test_copyItemAtPathToPath(){
letfm=FileManager.default
letsrcPath=NSTemporaryDirectory()+"testdir\(NSUUID().uuidString)"
letdestPath=NSTemporaryDirectory()+"testdir\(NSUUID().uuidString)"

func cleanup(){
try? fm.removeItem(atPath: srcPath)
try? fm.removeItem(atPath: destPath)
}

defer{
cleanup()
}

func createDirectory(atPath path:String){
do{
try fm.createDirectory(atPath: path, withIntermediateDirectories:false, attributes:nil)
}catch{
XCTFail("Unable to create directory: \(error)")
}
XCTAssertTrue(directoryExists(atPath: path))
}

func createFile(atPath path:String){
XCTAssertTrue(fm.createFile(atPath: path, contents:Data(), attributes:nil))
}

cleanup()
createFile(atPath: srcPath)
do{
try fm.copyItem(atPath: srcPath, toPath: destPath)
}catch{
XCTFail("Failed to copy file: \(error)")
}

cleanup()
createDirectory(atPath: srcPath)
createDirectory(atPath:"\(srcPath)/tempdir")
createDirectory(atPath:"\(srcPath)/tempdir/subdir")
createDirectory(atPath:"\(srcPath)/tempdir/subdir/otherdir")
createDirectory(atPath:"\(srcPath)/tempdir/subdir/otherdir/extradir")
createFile(atPath:"\(srcPath)/tempdir/tempfile")
createFile(atPath:"\(srcPath)/tempdir/tempfile2")
createFile(atPath:"\(srcPath)/tempdir/subdir/otherdir/extradir/tempfile2")

#if false
 // TODO: re-enable when URLResourceValues are supported in swift-foundation
do{
try fm.copyItem(atPath: srcPath, toPath: destPath)
}catch{
XCTFail("Unable to copy directory: \(error)")
}
XCTAssertTrue(directoryExists(atPath: destPath))
XCTAssertTrue(directoryExists(atPath:"\(destPath)/tempdir"))
XCTAssertTrue(fm.fileExists(atPath:"\(destPath)/tempdir/tempfile"))
XCTAssertTrue(fm.fileExists(atPath:"\(destPath)/tempdir/tempfile2"))
XCTAssertTrue(directoryExists(atPath:"\(destPath)/tempdir/subdir/otherdir/extradir"))
XCTAssertTrue(fm.fileExists(atPath:"\(destPath)/tempdir/subdir/otherdir/extradir/tempfile2"))
#endif
if(false==directoryExists(atPath: destPath)){
return
}
do{
try fm.copyItem(atPath: srcPath, toPath: destPath)
XCTFail("Copy overwrites a file/folder that already exists")
}catch{
 // ignore
}

 // Test copying a symlink
letsrcLink= srcPath +"/testlink"
letdestLink= destPath +"/testlink"
do{
#if os(Windows)
 fm.createFile(atPath: srcPath.appendingPathComponent("linkdest"), contents:Data(), attributes:nil)
#endif
try fm.createSymbolicLink(atPath: srcLink, withDestinationPath:"linkdest")
try fm.copyItem(atPath: srcLink, toPath: destLink)
XCTAssertEqual(try fm.destinationOfSymbolicLink(atPath: destLink),"linkdest")
}catch{
XCTFail("\(error)")
}

do{
try fm.copyItem(atPath: srcLink, toPath: destLink)
XCTFail("Creating link where one already exists")
}catch{
 // ignore
}
}

func test_linkItemAtPathToPath(){
letfm=FileManager.default
letbasePath=NSTemporaryDirectory()+"linkItemAtPathToPath/"
letsrcPath= basePath +"testdir\(NSUUID().uuidString)"
letdestPath= basePath +"testdir\(NSUUID().uuidString)"
defer{try? fm.removeItem(atPath: basePath)}

func getFileInfo(atPath path:String, _ body:(String,Bool,UInt64,UInt64)->()){
guardlet enumerator = fm.enumerator(atPath: path)else{
XCTFail("Cant enumerate \(path)")
return
}
whilelet item = enumerator.nextObject()as?String{
letfname="\(path)/\(item)"
do{
letattrs=try fm.attributesOfItem(atPath: fname)
letinode=(attrs[.systemFileNumber]as?NSNumber)?.uint64Value
letlinkCount=(attrs[.referenceCount]as?NSNumber)?.uint64Value
letftype=attrs[.type]as?FileAttributeType

if inode ==nil || linkCount ==nil || ftype ==nil{
XCTFail("Unable to get attributes of \(fname)")
return
}
letisDir=(ftype ==.typeDirectory)
body(item, isDir, inode!, linkCount!)
}catch{
XCTFail("Unable to get attributes of \(fname): \(error)")
return
}
}
}

try? fm.removeItem(atPath: basePath)
XCTAssertNotNil(try? fm.createDirectory(atPath:"\(srcPath)/tempdir/subdir/otherdir/extradir", withIntermediateDirectories:true, attributes:nil))
XCTAssertTrue(fm.createFile(atPath:"\(srcPath)/tempdir/tempfile", contents:Data(), attributes:nil))
XCTAssertTrue(fm.createFile(atPath:"\(srcPath)/tempdir/tempfile2", contents:Data(), attributes:nil))
XCTAssertTrue(fm.createFile(atPath:"\(srcPath)/tempdir/subdir/otherdir/extradir/tempfile2", contents:Data(), attributes:nil))

varfileInfos:[String:(Bool,UInt64,UInt64)]=[:]
getFileInfo(atPath: srcPath,{ name, isDir, inode, linkCount in
fileInfos[name]=(isDir, inode, linkCount)
})
XCTAssertEqual(fileInfos.count,7)
#if false
 // TODO: re-enable when URLResourceValues are supported in swift-foundation
XCTAssertNotNil(try? fm.linkItem(atPath: srcPath, toPath: destPath),"Unable to link directory")

getFileInfo(atPath: destPath,{ name, isDir, inode, linkCount in
guardlet srcFileInfo = fileInfos.removeValue(forKey: name)else{
XCTFail("Cant find \(name) in \(destPath)")
return
}
let(srcIsDir, srcInode, srcLinkCount)= srcFileInfo
XCTAssertEqual(srcIsDir, isDir,"Directory/File type mismatch")
if isDir {
XCTAssertEqual(srcLinkCount, linkCount)
}else{
XCTAssertEqual(srcInode, inode)
XCTAssertEqual(srcLinkCount +1, linkCount)
}
})

XCTAssertEqual(fileInfos.count,0)
 // linkItem should fail a 2nd time
XCTAssertNil(try? fm.linkItem(atPath: srcPath, toPath: destPath),"Copy overwrites a file/folder that already exists")

 // Test 'linking' a symlink, which actually does a copy
letsrcLink= srcPath +"/testlink"
letdestLink= destPath +"/testlink"
do{
#if os(Windows)
 fm.createFile(atPath: srcPath.appendingPathComponent("linkdest"), contents:Data(), attributes:nil)
#endif
try fm.createSymbolicLink(atPath: srcLink, withDestinationPath:"linkdest")
try fm.linkItem(atPath: srcLink, toPath: destLink)
XCTAssertEqual(try fm.destinationOfSymbolicLink(atPath: destLink),"linkdest")
}catch{
XCTFail("\(error)")
}
XCTAssertNil(try? fm.linkItem(atPath: srcLink, toPath: destLink),"Creating link where one already exists")
#endif
}

func test_resolvingSymlinksInPath()throws{
trywithTemporaryDirectory{(temporaryDirectoryURL, _)in
 // Initialization
varbaseURL= temporaryDirectoryURL
.appendingPathComponent("test_resolvingSymlinksInPath")
.appendingPathComponent(UUID().uuidString)

tryFileManager.default.createDirectory(at: baseURL, withIntermediateDirectories:true)
lettestData=Data([0x01])

 baseURL.resolveSymlinksInPath()
 baseURL.standardize()

letlink1URL= baseURL.appendingPathComponent("link1")
letlink2URL= baseURL.appendingPathComponent("link2")
letlink3URL= baseURL.appendingPathComponent("link3")
lettestFileURL= baseURL.appendingPathComponent("test").standardized.absoluteURL

tryFileManager.default.removeItem(at: baseURL)

 // A) Check non-symbolic linking resolution
tryFileManager.default.createDirectory(at: baseURL, withIntermediateDirectories:true)
try testData.write(to: testFileURL)
letresolvedURL_A= testFileURL.resolvingSymlinksInPath().standardized.absoluteURL
XCTAssertEqual(resolvedURL_A.path, testFileURL.path)
tryFileManager.default.removeItem(at: baseURL)

 // B) Check simple symbolic linking resolution
tryFileManager.default.createDirectory(at: baseURL, withIntermediateDirectories:true)
try testData.write(to: testFileURL)
tryFileManager.default.createSymbolicLink(at: link1URL, withDestinationURL: testFileURL)
letresolvedURL_B= link1URL.resolvingSymlinksInPath().standardized.absoluteURL
XCTAssertEqual(resolvedURL_B.path, testFileURL.path)
tryFileManager.default.removeItem(at: baseURL)

 // C) Check recursive symbolic linking resolution
 //
 // Note: The symbolic link creation order is important as in some platforms like Windows
 // symlinks can only be created pointing to existing targets.
tryFileManager.default.createDirectory(at: baseURL, withIntermediateDirectories:true)
try testData.write(to: testFileURL)
tryFileManager.default.createSymbolicLink(at: link2URL, withDestinationURL: testFileURL)
tryFileManager.default.createSymbolicLink(at: link1URL, withDestinationURL: link2URL)
letresolvedURL_C= link1URL.resolvingSymlinksInPath().standardized.absoluteURL
XCTAssertEqual(resolvedURL_C.path, testFileURL.path)

 // C-2) And that FileManager.destinationOfSymbolicLink(atPath:) does not recursively resolves them
letdestinationOfSymbolicLink1=tryFileManager.default.destinationOfSymbolicLink(atPath: link1URL.path)
letdestinationOfSymbolicLink1URL=URL(fileURLWithPath: destinationOfSymbolicLink1).standardized.absoluteURL
XCTAssertEqual(destinationOfSymbolicLink1URL.path, link2URL.path)
tryFileManager.default.removeItem(at: baseURL)

#if !os(Windows)
 // D) Check infinite recursion loops are stopped and the function returns the intial symlink
 //
 // Note: This cannot be tested on platforms which only support creating symlinks pointing to existing targets.
tryFileManager.default.createDirectory(at: baseURL, withIntermediateDirectories:true)
tryFileManager.default.createSymbolicLink(at: link1URL, withDestinationURL: link2URL)
tryFileManager.default.createSymbolicLink(at: link2URL, withDestinationURL: link3URL)
tryFileManager.default.createSymbolicLink(at: link3URL, withDestinationURL: link1URL)
letresolvedURL_D= link1URL.resolvingSymlinksInPath()
XCTAssertEqual(resolvedURL_D.lastPathComponent, link1URL.lastPathComponent)
#endif
}
}

func test_homedirectoryForUser(){
letfilemanger=FileManager.default
XCTAssertNil(filemanger.homeDirectory(forUser:"someuser"))
XCTAssertNil(filemanger.homeDirectory(forUser:""))
XCTAssertNotNil(filemanger.homeDirectoryForCurrentUser)
}

func test_temporaryDirectoryForUser(){
letfilemanger=FileManager.default
lettmpDir= filemanger.temporaryDirectory
lettmpFileUrl= tmpDir.appendingPathComponent("test.bin")
lettmpFilePath= tmpFileUrl.path

do{
if filemanger.fileExists(atPath: tmpFilePath){
try filemanger.removeItem(at: tmpFileUrl)
}

try"hello world".write(to: tmpFileUrl, atomically:false, encoding:.utf8)
XCTAssert(filemanger.fileExists(atPath: tmpFilePath))

try filemanger.removeItem(at: tmpFileUrl)
}catch{
XCTFail("Unable to write a file to the temporary directory: \(tmpDir), err: \(error)")
}
}

func test_mountedVolumeURLs(){
guardlet volumes =FileManager.default.mountedVolumeURLs(includingResourceValuesForKeys:[], options:[])else{
XCTFail("mountedVolumeURLs returned nil")
return
}
XCTAssertNotEqual(0, volumes.count)
#if os(Windows)
guardlet url:URL=FileManager.default.urls(for:.applicationSupportDirectory, in:.localDomainMask).first else{
XCTFail("unable to query a system directory")
return
}
letroot:String= url.withUnsafeFileSystemRepresentation{
String(String(cString: $0!).prefix(3))
}
XCTAssertTrue(volumes.contains(URL(fileURLWithPath: root)))
#else
XCTAssertTrue(volumes.contains(URL(fileURLWithPath:"/")))
#endif
#if os(macOS)
 // On macOS, .skipHiddenVolumes should hide 'nobrowse' volumes of which there should be at least one
guardlet visibleVolumes =FileManager.default.mountedVolumeURLs(includingResourceValuesForKeys:[], options:[.skipHiddenVolumes])else{
XCTFail("mountedVolumeURLs returned nil")
return
}
XCTAssertTrue(visibleVolumes.count >0)
XCTAssertTrue(visibleVolumes.count < volumes.count)
#endif
}

func test_contentsEqual(){
letfm=FileManager.default
lettmpParentDirURL=URL(fileURLWithPath:NSTemporaryDirectory()+"test_contentsEqualdir", isDirectory:true)
lettestDir1= tmpParentDirURL.appendingPathComponent("testDir1")
lettestDir2= tmpParentDirURL.appendingPathComponent("testDir2")
lettestDir3= testDir1.appendingPathComponent("subDir/anotherDir/extraDir/lastDir")

defer{try? fm.removeItem(atPath: tmpParentDirURL.path)}

func testFileURL(_ name:String, _ ext:String)->URL?{
guardlet url =testBundle().url(forResource: name, withExtension: ext)else{
XCTFail("Cant open \(name).\(ext)")
returnnil
}
return url