Skip to content

Commit 08ece27

Browse files
stevapplestevapple
committed
Fix some tests on Windows
1 parent d27bd63 commit 08ece27

File tree

11 files changed

+187
-181
lines changed

11 files changed

+187
-181
lines changed

‎Sources/TSCBasic/FileSystem.swift‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -706,7 +706,7 @@ public class InMemoryFileSystem: FileSystem {
706706

707707
/// Virtualized current working directory.
708708
public var currentWorkingDirectory: AbsolutePath? {
709-
return AbsolutePath("/")
709+
return AbsolutePath.withPOSIX(path: "/")
710710
}
711711

712712
public func changeCurrentWorkingDirectory(to path: AbsolutePath) throws {
@@ -715,7 +715,7 @@ public class InMemoryFileSystem: FileSystem {
715715

716716
public var homeDirectory: AbsolutePath {
717717
// FIXME: Maybe we should allow setting this when creating the fs.
718-
return AbsolutePath("/home/user")
718+
return AbsolutePath.withPOSIX(path: "/home/user")
719719
}
720720

721721
public var cachesDirectory: AbsolutePath? {

‎Sources/TSCBasic/Path.swift‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -291,6 +291,7 @@ public struct AbsolutePath: Path {
291291
public static func withPOSIX(path: String) -> AbsolutePath {
292292
#if os(Windows)
293293
var filepath = FilePath(path)
294+
precondition(filepath.root != nil)
294295
if !filepath.isAbsolute {
295296
filepath.root = root.filepath.root
296297
}

‎Sources/TSCTestSupport/FileSystemExtensions.swift‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@ extension InMemoryFileSystem {
2525
self.init()
2626

2727
for (path, contents) in files {
28-
let path = AbsolutePath(path)
28+
let path = AbsolutePath.withPOSIX(path: path)
2929
try! createDirectory(path.parentDirectory, recursive: true)
3030
try! writeFileContents(path, bytes: contents)
3131
}
@@ -52,7 +52,8 @@ extension FileSystem {
5252
do {
5353
try createDirectory(root, recursive: true)
5454
for path in files {
55-
let path = root.appending(RelativePath(String(path.dropFirst())))
55+
let components = AbsolutePath.withPOSIX(path: path).components
56+
let path = root.appending(components: components)
5657
try createDirectory(path.parentDirectory, recursive: true)
5758
try writeFileContents(path, bytes: "")
5859
}

‎Sources/TSCUtility/Archiver.swift‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -62,7 +62,7 @@ public struct ZipArchiver: Archiver {
6262

6363
DispatchQueue.global(qos: .userInitiated).async {
6464
do {
65-
let result = try Process.popen(args: "unzip", archivePath.pathString, "-d", destinationPath.pathString)
65+
let result = try Process.popen(args: "unzip\(executableFileSuffix)", archivePath.pathString, "-d", destinationPath.pathString)
6666
guard result.exitStatus == .terminated(code: 0) else {
6767
throw try StringError(result.utf8stderrOutput())
6868
}

‎Tests/TSCBasicTests/FileSystemTests.swift‎

Lines changed: 52 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -17,23 +17,26 @@ import TSCLibc
1717
class FileSystemTests: XCTestCase {
1818

1919
// MARK: LocalFS Tests
20-
2120
func testLocalBasics() throws {
2221
let fs = TSCBasic.localFileSystem
22+
#if os(Windows)
23+
XCTSkip("FIXME: withTemporaryDirectory(removeTreeOnDeinit: true) will throw on Windows")
24+
return
25+
#endif
2326
try! withTemporaryFile { file in
2427
try! withTemporaryDirectory(removeTreeOnDeinit: true) { tempDirPath in
2528
// exists()
26-
XCTAssert(fs.exists(AbsolutePath("/")))
27-
XCTAssert(!fs.exists(AbsolutePath("/does-not-exist")))
29+
XCTAssert(fs.exists(AbsolutePath.withPOSIX(path: "/")))
30+
XCTAssert(!fs.exists(AbsolutePath.withPOSIX(path: "/does-not-exist")))
2831

2932
// isFile()
3033
XCTAssertTrue(fs.exists(file.path))
3134
XCTAssertTrue(fs.isFile(file.path))
3235
XCTAssertEqual(try fs.getFileInfo(file.path).fileType, .typeRegular)
3336
XCTAssertFalse(fs.isDirectory(file.path))
34-
XCTAssertFalse(fs.isFile(AbsolutePath("/does-not-exist")))
35-
XCTAssertFalse(fs.isSymlink(AbsolutePath("/does-not-exist")))
36-
XCTAssertThrowsError(try fs.getFileInfo(AbsolutePath("/does-not-exist")))
37+
XCTAssertFalse(fs.isFile(AbsolutePath.withPOSIX(path: "/does-not-exist")))
38+
XCTAssertFalse(fs.isSymlink(AbsolutePath.withPOSIX(path: "/does-not-exist")))
39+
XCTAssertThrowsError(try fs.getFileInfo(AbsolutePath.withPOSIX(path: "/does-not-exist")))
3740

3841
// isSymlink()
3942
let sym = tempDirPath.appending(component: "hello")
@@ -46,7 +49,7 @@ class FileSystemTests: XCTestCase {
4649
// isExecutableFile
4750
let executable = tempDirPath.appending(component: "exec-foo")
4851
let executableSym = tempDirPath.appending(component: "exec-sym")
49-
try! fs.createSymbolicLink(executableSym, pointingAt: executable, relative: false)
52+
try fs.createSymbolicLink(executableSym, pointingAt: executable, relative: false)
5053
let stream = BufferedOutputByteStream()
5154
stream <<< """
5255
#!/bin/sh
@@ -61,16 +64,16 @@ class FileSystemTests: XCTestCase {
6164
XCTAssertTrue(fs.isSymlink(executableSym))
6265
XCTAssertFalse(fs.isExecutableFile(sym))
6366
XCTAssertFalse(fs.isExecutableFile(file.path))
64-
XCTAssertFalse(fs.isExecutableFile(AbsolutePath("/does-not-exist")))
65-
XCTAssertFalse(fs.isExecutableFile(AbsolutePath("/")))
67+
XCTAssertFalse(fs.isExecutableFile(AbsolutePath.withPOSIX(path: "/does-not-exist")))
68+
XCTAssertFalse(fs.isExecutableFile(AbsolutePath.withPOSIX(path: "/")))
6669

6770
// isDirectory()
68-
XCTAssert(fs.isDirectory(AbsolutePath("/")))
69-
XCTAssert(!fs.isDirectory(AbsolutePath("/does-not-exist")))
71+
XCTAssert(fs.isDirectory(AbsolutePath.withPOSIX(path: "/")))
72+
XCTAssert(!fs.isDirectory(AbsolutePath.withPOSIX(path: "/does-not-exist")))
7073

7174
// getDirectoryContents()
7275
do {
73-
_ = try fs.getDirectoryContents(AbsolutePath("/does-not-exist"))
76+
_ = try fs.getDirectoryContents(AbsolutePath.withPOSIX(path: "/does-not-exist"))
7477
XCTFail("Unexpected success")
7578
} catch {
7679
XCTAssertEqual(error.localizedDescription, "The folder “does-not-exist” doesn’t exist.")
@@ -219,7 +222,7 @@ class FileSystemTests: XCTestCase {
219222
XCTAssertEqual(data, ByteString(testData))
220223

221224
// Atomic writes
222-
let inMemoryFilePath = AbsolutePath("/file.text")
225+
let inMemoryFilePath = AbsolutePath.withPOSIX(path: "/file.text")
223226
XCTAssertNoThrow(try TSCBasic.InMemoryFileSystem(files: [:]).writeFileContents(inMemoryFilePath, bytes: ByteString(testData), atomically: true))
224227
XCTAssertNoThrow(try TSCBasic.InMemoryFileSystem(files: [:]).writeFileContents(inMemoryFilePath, bytes: ByteString(testData), atomically: false))
225228
// Local file system does support atomic writes, so it doesn't throw.
@@ -255,9 +258,9 @@ class FileSystemTests: XCTestCase {
255258

256259
// Check read/write against root.
257260
#if os(Android)
258-
let root = AbsolutePath("/system/")
261+
let root = AbsolutePath.withPOSIX(path: "/system/")
259262
#else
260-
let root = AbsolutePath("/")
263+
let root = AbsolutePath.withPOSIX(path: "/")
261264
#endif
262265
XCTAssertThrows(FileSystemError(.ioError(code: TSCLibc.EPERM), root)) {
263266
_ = try fs.readFileContents(root)
@@ -376,7 +379,7 @@ class FileSystemTests: XCTestCase {
376379

377380
func testInMemoryBasics() throws {
378381
let fs = InMemoryFileSystem()
379-
let doesNotExist = AbsolutePath("/does-not-exist")
382+
let doesNotExist = AbsolutePath.withPOSIX(path: "/does-not-exist")
380383

381384
// exists()
382385
XCTAssert(!fs.exists(doesNotExist))
@@ -396,22 +399,22 @@ class FileSystemTests: XCTestCase {
396399
}
397400

398401
// createDirectory()
399-
XCTAssert(!fs.isDirectory(AbsolutePath("/new-dir")))
400-
try fs.createDirectory(AbsolutePath("/new-dir/subdir"), recursive: true)
401-
XCTAssert(fs.isDirectory(AbsolutePath("/new-dir")))
402-
XCTAssert(fs.isDirectory(AbsolutePath("/new-dir/subdir")))
403-
XCTAssertEqual(try fs.getDirectoryContents(AbsolutePath("/")), ["new-dir"])
404-
XCTAssertEqual(try fs.getDirectoryContents(AbsolutePath("/new-dir")), ["subdir"])
402+
XCTAssert(!fs.isDirectory(AbsolutePath.withPOSIX(path: "/new-dir")))
403+
try fs.createDirectory(AbsolutePath.withPOSIX(path: "/new-dir/subdir"), recursive: true)
404+
XCTAssert(fs.isDirectory(AbsolutePath.withPOSIX(path: "/new-dir")))
405+
XCTAssert(fs.isDirectory(AbsolutePath.withPOSIX(path: "/new-dir/subdir")))
406+
XCTAssertEqual(try fs.getDirectoryContents(AbsolutePath.withPOSIX(path: "/")), ["new-dir"])
407+
XCTAssertEqual(try fs.getDirectoryContents(AbsolutePath.withPOSIX(path: "/new-dir")), ["subdir"])
405408
}
406409

407410
func testInMemoryCreateDirectory() {
408411
let fs = InMemoryFileSystem()
409412
// Make sure root entry isn't created.
410-
try! fs.createDirectory(AbsolutePath("/"), recursive: true)
413+
try! fs.createDirectory(AbsolutePath.withPOSIX(path: "/"), recursive: true)
411414
let rootContents = try! fs.getDirectoryContents(.root)
412415
XCTAssertEqual(rootContents, [])
413416

414-
let subdir = AbsolutePath("/new-dir/subdir")
417+
let subdir = AbsolutePath.withPOSIX(path: "/new-dir/subdir")
415418
try! fs.createDirectory(subdir, recursive: true)
416419
XCTAssert(fs.isDirectory(subdir))
417420

@@ -426,7 +429,7 @@ class FileSystemTests: XCTestCase {
426429
XCTAssert(fs.isDirectory(subsubdir))
427430

428431
// Check non-recursive failing subdir case.
429-
let veryNewDir = AbsolutePath("/very-new-dir")
432+
let veryNewDir = AbsolutePath.withPOSIX(path: "/very-new-dir")
430433
let newsubdir = veryNewDir.appending(component: "subdir")
431434
XCTAssert(!fs.isDirectory(newsubdir))
432435
XCTAssertThrows(FileSystemError(.noEntry, veryNewDir)) {
@@ -435,7 +438,7 @@ class FileSystemTests: XCTestCase {
435438
XCTAssert(!fs.isDirectory(newsubdir))
436439

437440
// Check directory creation over a file.
438-
let filePath = AbsolutePath("/mach_kernel")
441+
let filePath = AbsolutePath.withPOSIX(path: "/mach_kernel")
439442
try! fs.writeFileContents(filePath, bytes: [0xCD, 0x0D])
440443
XCTAssert(fs.exists(filePath) && !fs.isDirectory(filePath))
441444
XCTAssertThrows(FileSystemError(.notDirectory, filePath)) {
@@ -480,10 +483,10 @@ class FileSystemTests: XCTestCase {
480483

481484
func testInMemoryReadWriteFile() {
482485
let fs = InMemoryFileSystem()
483-
try! fs.createDirectory(AbsolutePath("/new-dir/subdir"), recursive: true)
486+
try! fs.createDirectory(AbsolutePath.withPOSIX(path: "/new-dir/subdir"), recursive: true)
484487

485488
// Check read/write of a simple file.
486-
let filePath = AbsolutePath("/new-dir/subdir").appending(component: "new-file.txt")
489+
let filePath = AbsolutePath.withPOSIX(path: "/new-dir/subdir").appending(component: "new-file.txt")
487490
XCTAssert(!fs.exists(filePath))
488491
XCTAssertFalse(fs.isFile(filePath))
489492
try! fs.writeFileContents(filePath, bytes: "Hello, world!")
@@ -507,7 +510,7 @@ class FileSystemTests: XCTestCase {
507510
XCTAssertEqual(try! fs.readFileContents(filePath), "Hello, new world!")
508511

509512
// Check read/write against root.
510-
let root = AbsolutePath("/")
513+
let root = AbsolutePath.withPOSIX(path: "/")
511514
XCTAssertThrows(FileSystemError(.isDirectory, root)) {
512515
_ = try fs.readFileContents(root)
513516
}
@@ -528,7 +531,7 @@ class FileSystemTests: XCTestCase {
528531
XCTAssert(fs.exists(filePath))
529532

530533
// Check read/write into a missing directory.
531-
let missingParent = AbsolutePath("/does/not")
534+
let missingParent = AbsolutePath.withPOSIX(path: "/does/not")
532535
let missingFile = missingParent.appending(component: "exist")
533536
XCTAssertThrows(FileSystemError(.noEntry, missingFile)) {
534537
_ = try fs.readFileContents(missingFile)
@@ -541,8 +544,8 @@ class FileSystemTests: XCTestCase {
541544

542545
func testInMemoryFsCopy() throws {
543546
let fs = InMemoryFileSystem()
544-
try! fs.createDirectory(AbsolutePath("/new-dir/subdir"), recursive: true)
545-
let filePath = AbsolutePath("/new-dir/subdir").appending(component: "new-file.txt")
547+
try! fs.createDirectory(AbsolutePath.withPOSIX(path: "/new-dir/subdir"), recursive: true)
548+
let filePath = AbsolutePath.withPOSIX(path: "/new-dir/subdir").appending(component: "new-file.txt")
546549
try! fs.writeFileContents(filePath, bytes: "Hello, world!")
547550
XCTAssertEqual(try! fs.readFileContents(filePath), "Hello, world!")
548551

@@ -561,7 +564,7 @@ class FileSystemTests: XCTestCase {
561564

562565
func testInMemCopyAndMoveItem() throws {
563566
let fs = InMemoryFileSystem()
564-
let path = AbsolutePath("/tmp")
567+
let path = AbsolutePath.withPOSIX(path: "/tmp")
565568
try fs.createDirectory(path)
566569
let source = path.appending(component: "source")
567570
let destination = path.appending(component: "destination")
@@ -639,33 +642,33 @@ class FileSystemTests: XCTestCase {
639642
func testRootedFileSystem() throws {
640643
// Create the test file system.
641644
let baseFileSystem = InMemoryFileSystem() as FileSystem
642-
try baseFileSystem.createDirectory(AbsolutePath("/base/rootIsHere/subdir"), recursive: true)
643-
try baseFileSystem.writeFileContents(AbsolutePath("/base/rootIsHere/subdir/file"), bytes: "Hello, world!")
645+
try baseFileSystem.createDirectory(AbsolutePath.withPOSIX(path: "/base/rootIsHere/subdir"), recursive: true)
646+
try baseFileSystem.writeFileContents(AbsolutePath.withPOSIX(path: "/base/rootIsHere/subdir/file"), bytes: "Hello, world!")
644647

645648
// Create the rooted file system.
646-
let rerootedFileSystem = RerootedFileSystemView(baseFileSystem, rootedAt: AbsolutePath("/base/rootIsHere"))
649+
let rerootedFileSystem = RerootedFileSystemView(baseFileSystem, rootedAt: AbsolutePath.withPOSIX(path: "/base/rootIsHere"))
647650

648651
// Check that it has the appropriate view.
649-
XCTAssert(rerootedFileSystem.exists(AbsolutePath("/subdir")))
650-
XCTAssert(rerootedFileSystem.isDirectory(AbsolutePath("/subdir")))
651-
XCTAssert(rerootedFileSystem.exists(AbsolutePath("/subdir/file")))
652-
XCTAssertEqual(try rerootedFileSystem.readFileContents(AbsolutePath("/subdir/file")), "Hello, world!")
652+
XCTAssert(rerootedFileSystem.exists(AbsolutePath.withPOSIX(path: "/subdir")))
653+
XCTAssert(rerootedFileSystem.isDirectory(AbsolutePath.withPOSIX(path: "/subdir")))
654+
XCTAssert(rerootedFileSystem.exists(AbsolutePath.withPOSIX(path: "/subdir/file")))
655+
XCTAssertEqual(try rerootedFileSystem.readFileContents(AbsolutePath.withPOSIX(path: "/subdir/file")), "Hello, world!")
653656

654657
// Check that mutations work appropriately.
655-
XCTAssert(!baseFileSystem.exists(AbsolutePath("/base/rootIsHere/subdir2")))
656-
try rerootedFileSystem.createDirectory(AbsolutePath("/subdir2"))
657-
XCTAssert(baseFileSystem.isDirectory(AbsolutePath("/base/rootIsHere/subdir2")))
658+
XCTAssert(!baseFileSystem.exists(AbsolutePath.withPOSIX(path: "/base/rootIsHere/subdir2")))
659+
try rerootedFileSystem.createDirectory(AbsolutePath.withPOSIX(path: "/subdir2"))
660+
XCTAssert(baseFileSystem.isDirectory(AbsolutePath.withPOSIX(path: "/base/rootIsHere/subdir2")))
658661
}
659662

660663
func testRootedCreateSymlink() throws {
661664
// Create the test file system.
662665
let baseFileSystem = InMemoryFileSystem() as FileSystem
663-
try baseFileSystem.createDirectory(AbsolutePath("/base/rootIsHere/subdir"), recursive: true)
666+
try baseFileSystem.createDirectory(AbsolutePath.withPOSIX(path: "/base/rootIsHere/subdir"), recursive: true)
664667

665668
// Create the rooted file system.
666-
let fs = RerootedFileSystemView(baseFileSystem, rootedAt: AbsolutePath("/base/rootIsHere"))
669+
let fs = RerootedFileSystemView(baseFileSystem, rootedAt: AbsolutePath.withPOSIX(path: "/base/rootIsHere"))
667670

668-
let path = AbsolutePath("/test")
671+
let path = AbsolutePath.withPOSIX(path: "/test")
669672
try fs.createDirectory(path, recursive: true)
670673

671674
let source = path.appending(component: "source")
@@ -750,7 +753,7 @@ class FileSystemTests: XCTestCase {
750753

751754
func testInMemoryFileSystemFileLock() throws {
752755
let fs = InMemoryFileSystem()
753-
let path = AbsolutePath("/")
756+
let path = AbsolutePath.withPOSIX(path: "/")
754757
try fs.createDirectory(path)
755758

756759
let fileA = path.appending(component: "fileA")
@@ -772,11 +775,11 @@ class FileSystemTests: XCTestCase {
772775

773776
func testRerootedFileSystemViewFileLock() throws {
774777
let inMemoryFS = InMemoryFileSystem()
775-
let rootPath = AbsolutePath("/tmp")
778+
let rootPath = AbsolutePath.withPOSIX(path: "/tmp")
776779
try inMemoryFS.createDirectory(rootPath)
777780

778781
let fs = RerootedFileSystemView(inMemoryFS, rootedAt: rootPath)
779-
let path = AbsolutePath("/")
782+
let path = AbsolutePath.withPOSIX(path: "/")
780783
try fs.createDirectory(path)
781784

782785
let fileA = path.appending(component: "fileA")

‎Tests/TSCBasicTests/PathShimTests.swift‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -37,19 +37,19 @@ class WalkTests : XCTestCase {
3737
#if os(Android)
3838
let root = "/system"
3939
var expected = [
40-
AbsolutePath("\(root)/usr"),
41-
AbsolutePath("\(root)/bin"),
42-
AbsolutePath("\(root)/xbin")
40+
AbsolutePath.withPOSIX(path: "\(root)/usr"),
41+
AbsolutePath.withPOSIX(path: "\(root)/bin"),
42+
AbsolutePath.withPOSIX(path: "\(root)/xbin")
4343
]
4444
#else
4545
let root = ""
4646
var expected = [
47-
AbsolutePath("/usr"),
48-
AbsolutePath("/bin"),
49-
AbsolutePath("/sbin")
47+
AbsolutePath.withPOSIX(path: "/usr"),
48+
AbsolutePath.withPOSIX(path: "/bin"),
49+
AbsolutePath.withPOSIX(path: "/sbin")
5050
]
5151
#endif
52-
for x in try! walk(AbsolutePath("\(root)/"), recursively: false) {
52+
for x in try! walk(AbsolutePath.withPOSIX(path: "\(root)/"), recursively: false) {
5353
if let i = expected.firstIndex(of: x) {
5454
expected.remove(at: i)
5555
}

0 commit comments

Comments
 (0)