Tests: Enable more WorkspaceTests on Windows

Many WorkspaceTests instantiate a MockWorkspace, which takes a path as
an input. The tests were defining a POSIX-like path as the sandbox
directory, however, some assertions were incorrect as, on these *nix like
filesystem, the canonical path name and the path were identical.

Update the WorkspaceTests expectation accordingly, and add some
automated tests to cover the InMemoryFileSystem.

Author: bkhouri

Sources/_InternalTestSupport/MockWorkspace.swift

@@ -185,12 +185,14 @@ public final class MockWorkspace {
 
     private func create() async throws {
         // Remove the sandbox if present.
-        try self.fileSystem.removeFileTree(self.sandbox)
+        if self.fileSystem.exists(self.sandbox) {
+            try self.fileSystem.removeFileTree(self.sandbox)
+        }
 
         // Create directories.
         try self.fileSystem.createDirectory(self.sandbox, recursive: true)
-        try self.fileSystem.createDirectory(self.rootsDir)
-        try self.fileSystem.createDirectory(self.packagesDir)
+        try self.fileSystem.createDirectory(self.rootsDir, recursive: true)
+        try self.fileSystem.createDirectory(self.packagesDir, recursive: true)
 
         var manifests: [MockManifestLoader.Key: Manifest] = [:]
 

Sources/_InternalTestSupport/misc.swift

@@ -285,7 +285,7 @@ public func skipOnWindowsAsTestCurrentlyFails(because reason: String? = nil) thr
     } else {
         failureCause = ""
     }
-    throw XCTSkip("Test fails on windows\(failureCause)")
+    throw XCTSkip("Skipping tests on windows\(failureCause)")
     #endif
 }
 

Tests/BasicsTests/FileSystem/InMemoryFilesSystemTests.swift

@@ -0,0 +1,229 @@
+/*
+ This source file is part of the Swift.org open source project
+
+ Copyright (c) 2025 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 Swift project authors
+ */
+
+import Basics
+import struct TSCBasic.ByteString
+import struct TSCBasic.FileSystemError
+
+import Testing
+import _InternalTestSupport
+
+struct InMemoryFileSystemTests {
+    @Test(
+        arguments: [
+            (
+                path: "/",
+                recurvise: true,
+                expectedFiles: [
+                    (p: "/", shouldExist: true),
+                ],
+                expectError: false,
+            ),
+            (
+                path: "/tmp",
+                recurvise: true,
+                expectedFiles: [
+                    (p: "/", shouldExist: true),
+                    (p: "/tmp", shouldExist: true),
+                ],
+                expectError: false,
+            ),
+            (
+                path: "/tmp/ws",
+                recurvise: true,
+                expectedFiles: [
+                    (p: "/", shouldExist: true),
+                    (p: "/tmp", shouldExist: true),
+                    (p: "/tmp/ws", shouldExist: true),
+                ],
+                expectError: false,
+            ),
+            (
+                path: "/tmp/ws",
+                recurvise: false,
+                expectedFiles: [
+                    (p: "/", shouldExist: true),
+                    (p: "/tmp", shouldExist: true),
+                    (p: "/tmp/ws", shouldExist: true),
+                ],
+                expectError: true,
+            ),
+        ]
+    )
+    func creatingDirectoryCreatesInternalFiles(
+        path: String,
+        recursive: Bool,
+        expectedFiles: [(String, Bool) ],
+        expectError: Bool
+    ) async throws {
+        let fs = InMemoryFileSystem()
+        let pathUnderTest = AbsolutePath(path)
+
+        func errorMessage(_ pa: AbsolutePath, _ exists: Bool) -> String {
+            return "Path '\(pa) \(exists ? "should exists, but doesn't" : "should not exist, but does.")"
+        }
+
+        try withKnownIssue {
+            try fs.createDirectory(pathUnderTest, recursive: recursive)
+
+            for (p, shouldExist) in expectedFiles {
+                let expectedPath = AbsolutePath(p)
+                #expect(fs.exists(expectedPath) == shouldExist, "\(errorMessage(expectedPath, shouldExist))")
+            }
+        } when: {
+            expectError
+        }
+    }
+
+
+    @Test(
+        arguments: [
+            "/",
+            "/tmp",
+            "/tmp/",
+            "/something/ws",
+            "/something/ws/",
+            "/what/is/this",
+            "/what/is/this/",
+        ]
+    )
+    func callingCreateDirectoryOnAnExistingDirectoryIsSuccessful(path: String) async throws {
+        let root = AbsolutePath(path)
+        let fs = InMemoryFileSystem()
+
+        #expect(throws: Never.self) {
+            try fs.createDirectory(root, recursive: true)
+        }
+
+        #expect(throws: Never.self) {
+            try fs.createDirectory(root.appending("more"), recursive: true)
+        }
+    }
+
+    struct writeFileContentsTests {
+
+        @Test
+        func testWriteFileContentsSuccessful() async throws {
+            // GIVEN we have a filesytstem
+            let fs = InMemoryFileSystem()
+            // and a path
+            let pathUnderTest = AbsolutePath("/myFile.zip")
+            let expectedContents = ByteString([0xAA, 0xBB, 0xCC])
+
+            // WHEN we write contents to the file
+            try fs.writeFileContents(pathUnderTest, bytes: expectedContents)
+
+            // THEN we expect the file to exist
+            #expect(fs.exists(pathUnderTest), "Path \(pathUnderTest.pathString) does not exists when it should")
+        }
+
+        @Test
+        func testWritingAFileWithANonExistingParentDirectoryFails() async throws {
+            // GIVEN we have a filesytstem
+            let fs = InMemoryFileSystem()
+            // and a path
+            let pathUnderTest = AbsolutePath("/tmp/myFile.zip")
+            let expectedContents = ByteString([0xAA, 0xBB, 0xCC])
+
+            // WHEN we write contents to the file
+            // THEn we expect an error to occus
+            try withKnownIssue {
+                try fs.writeFileContents(pathUnderTest, bytes: expectedContents)
+            }
+
+            // AND we expect the file to not exist
+            #expect(!fs.exists(pathUnderTest), "Path \(pathUnderTest.pathString) does exists when it should not")
+        }
+
+        @Test
+        func errorOccursWhenWritingToRootDirectory() async throws {
+            // GIVEN we have a filesytstem
+            let fs = InMemoryFileSystem()
+            // and a path
+            let pathUnderTest = AbsolutePath("/")
+            let expectedContents = ByteString([0xAA, 0xBB, 0xCC])
+
+            // WHEN we write contents to the file
+            // THEN we expect an error to occur
+            try withKnownIssue {
+                try fs.writeFileContents(pathUnderTest, bytes: expectedContents)
+            }
+
+        }
+
+        @Test
+        func testErrorOccursIfParentIsNotADirectory() async throws {
+            // GIVEN we have a filesytstem
+            let fs = InMemoryFileSystem()
+            // AND an existing file
+            let aFile = AbsolutePath("/foo")
+            try fs.writeFileContents(aFile, bytes: "")
+
+            // AND a the path under test that has an existing file as a parent
+            let pathUnderTest = aFile.appending("myFile")
+            let expectedContents = ByteString([0xAA, 0xBB, 0xCC])
+
+            // WHEN we write contents to the file
+            // THEN we expect an error to occur
+            withKnownIssue {
+                try fs.writeFileContents(pathUnderTest, bytes: expectedContents)
+            }
+
+        }
+    }
+
+
+    struct testReadFileContentsTests {
+        @Test
+        func readingAFileThatDoesNotExistsRaisesAnError()async throws {
+            // GIVEN we have a filesystem
+            let fs = InMemoryFileSystem()
+
+            // WHEN we read a non-existing file
+            // THEN an error occurs
+            try withKnownIssue {
+                let _ = try fs.readFileContents("/file/does/not/exists")
+            }
+        }
+
+        @Test
+        func readingExistingFileReturnsExpectedContents() async throws {
+            // GIVEN we have a filesytstem
+            let fs = InMemoryFileSystem()
+            // AND a file a path
+            let pathUnderTest = AbsolutePath("/myFile.zip")
+            let expectedContents = ByteString([0xAA, 0xBB, 0xCC])
+            try fs.writeFileContents(pathUnderTest, bytes: expectedContents)
+
+            // WHEN we read contents if the file
+            let actualContents = try fs.readFileContents(pathUnderTest)
+
+            // THEN the actual contents should match the expected to match the
+            #expect(actualContents == expectedContents, "Actual is not as expected")
+        }
+
+        @Test
+        func readingADirectoryFailsWithAnError() async throws {
+            // GIVEN we have a filesytstem
+            let fs = InMemoryFileSystem()
+            // AND a file a path
+            let pathUnderTest = AbsolutePath("/myFile.zip")
+            let expectedContents = ByteString([0xAA, 0xBB, 0xCC])
+            try fs.writeFileContents(pathUnderTest, bytes: expectedContents)
+
+            // WHEN we read the contents of a directory
+            // THEN we expect a failure to occur
+            withKnownIssue {
+                let _ = try fs.readFileContents(pathUnderTest.parentDirectory)
+            }
+        }
+    }
+
+}