Remove dependencies on Foundation's file handling APIs. (#356)

Author: grynspan

Sources/Testing/Support/FileHandle.swift

@@ -71,6 +71,16 @@ struct FileHandle: ~Copyable, Sendable {
     self.init(unsafeCFILEHandle: fileHandle, closeWhenDone: true)
   }
 
+  /// Initialize an instance of this type to read from the given path.
+  ///
+  /// - Parameters:
+  ///   - path: The path to read from.
+  ///
+  /// - Throws: Any error preventing the stream from being opened.
+  init(forReadingAtPath path: String) throws {
+    try self.init(atPath: path, mode: "rb")
+  }
+
   /// Initialize an instance of this type to write to the given path.
   ///
   /// - Parameters:
@@ -208,6 +218,62 @@ struct FileHandle: ~Copyable, Sendable {
   }
 }
 
+// MARK: - Reading
+
+extension FileHandle {
+  /// Read to the end of the file handle.
+  ///
+  /// - Returns: A copy of the contents of the file handle starting at the
+  ///   current offset and ending at the end of the file.
+  ///
+  /// - Throws: Any error that occurred while reading the file.
+  func readToEnd() throws -> [UInt8] {
+    var result = [UInt8]()
+
+    // If possible, reserve enough space in the resulting buffer to contain
+    // the contents of the file being read.
+    var size: Int?
+#if SWT_TARGET_OS_APPLE || os(Linux)
+    withUnsafePOSIXFileDescriptor { fd in
+      var s = stat()
+      if let fd, 0 == fstat(fd, &s) {
+        size = Int(exactly: s.st_size)
+      }
+    }
+#elseif os(Windows)
+    withUnsafeWindowsHANDLE { handle in
+      var liSize = LARGE_INTEGER(QuadPart: 0)
+      if let handle, GetFileSizeEx(handle, &liSize) {
+        size = Int(exactly: liSize.QuadPart)
+      }
+    }
+#endif
+    if let size, size > 0 {
+      result.reserveCapacity(size)
+    }
+
+    try withUnsafeCFILEHandle { file in
+      try withUnsafeTemporaryAllocation(byteCount: 1024, alignment: 1) { buffer in
+        while true {
+          let countRead = fread(buffer.baseAddress, 1, buffer.count, file)
+          if 0 != ferror(file) {
+            throw CError(rawValue: swt_errno())
+          }
+          if countRead > 0 {
+            let endIndex = buffer.index(buffer.startIndex, offsetBy: countRead)
+            result.append(contentsOf: buffer[..<endIndex])
+          }
+          if 0 != feof(file) {
+            break
+          }
+        }
+      }
+    }
+
+    return result
+  }
+}
+
 // MARK: - Writing
 
 extension FileHandle {
@@ -357,4 +423,30 @@ extension FileHandle {
 #endif
   }
 }
+
+// MARK: - General path utilities
+
+/// Append a path component to a path.
+///
+/// - Parameters:
+///   - pathComponent: The path component to append.
+///   - path: The path to which `pathComponent` should be appended.
+///
+/// - Returns: The full path to `pathComponent`, or `nil` if the resulting
+///   string could not be created.
+func appendPathComponent(_ pathComponent: String, to path: String) -> String {
+#if os(Windows)
+  path.withCString(encodedAs: UTF16.self) { path in
+    pathComponent.withCString(encodedAs: UTF16.self) { pathComponent in
+      withUnsafeTemporaryAllocation(of: wchar_t.self, capacity: (wcslen(path) + wcslen(pathComponent)) * 2 + 1) { buffer in
+        _ = wcscpy_s(buffer.baseAddress, buffer.count, path)
+        _ = PathCchAppendEx(buffer.baseAddress, buffer.count, pathComponent, ULONG(PATHCCH_ALLOW_LONG_PATHS.rawValue))
+        return (String.decodeCString(buffer.baseAddress, as: UTF16.self)?.result)!
+      }
+    }
+  }
+#else
+  "\(path)/\(pathComponent)"
+#endif
+}
 #endif

Sources/Testing/Traits/Tags/Tag.Color+Loading.swift

@@ -10,25 +10,22 @@
 
 private import TestingInternals
 
-#if canImport(Foundation)
-private import Foundation
-#endif
-
 #if !SWT_NO_FILE_IO
 #if os(macOS) || (os(iOS) && targetEnvironment(macCatalyst)) || os(Linux)
 /// The path to the current user's home directory, if known.
 private var _homeDirectoryPath: String? {
-#if canImport(Foundation)
-  NSHomeDirectory()
-#else
-  if let homeVariable = Environment.variable(named: "HOME") {
+#if SWT_TARGET_OS_APPLE
+  if let fixedHomeVariable = Environment.variable(named: "CFFIXED_USER_HOME") {
+    return fixedHomeVariable
+  }
+#endif
+  return if let homeVariable = Environment.variable(named: "HOME") {
     homeVariable
   } else if let pwd = getpwuid(geteuid()) {
     String(validatingUTF8: pwd.pointee.pw_dir)
   } else {
     nil
   }
-#endif
 }
 #endif
 
@@ -58,11 +55,11 @@ var swiftTestingDirectoryPath: String {
 
 #if os(macOS) || (os(iOS) && targetEnvironment(macCatalyst)) || os(Linux)
   if let homeDirectoryPath = _homeDirectoryPath {
-    return "\(homeDirectoryPath)/\(swiftTestingDirectoryName)"
+    return appendPathComponent(swiftTestingDirectoryName, to: homeDirectoryPath)
   }
 #elseif os(Windows)
   if let appDataDirectoryPath = _appDataDirectoryPath {
-    return "\(appDataDirectoryPath)\\\(swiftTestingDirectoryName)"
+    return appendPathComponent(swiftTestingDirectoryName, to: appDataDirectoryPath)
   }
 #else
 #warning("Platform-specific implementation missing: swift-testing directory location unavailable")
@@ -88,9 +85,9 @@ var swiftTestingDirectoryPath: String {
 /// supported formats for tag colors in this dictionary, see <doc:AddingTags>.
 func loadTagColors(fromFileInDirectoryAtPath swiftTestingDirectoryPath: String = swiftTestingDirectoryPath) throws -> [Tag: Tag.Color] {
   // Find the path to the tag-colors.json file and try to load its contents.
-  let tagColorsURL = URL(fileURLWithPath: swiftTestingDirectoryPath, isDirectory: true)
-    .appendingPathComponent("tag-colors.json", isDirectory: false)
-  let tagColorsData = try Data(contentsOf: tagColorsURL, options: [.mappedIfSafe])
+  let tagColorsPath = appendPathComponent("tag-colors.json", to: swiftTestingDirectoryPath)
+  let fileHandle = try FileHandle(forReadingAtPath: tagColorsPath)
+  let tagColorsData = try fileHandle.readToEnd()
 
   // By default, a dictionary with non-string keys is encoded to and decoded
   // from JSON as an array, so we decode the dictionary as if its keys are plain

Sources/TestingInternals/include/Includes.h

@@ -75,6 +75,10 @@
 #include <pty.h>
 #endif
 
+#if __has_include(<pwd.h>)
+#include <pwd.h>
+#endif
+
 #if __has_include(<limits.h>)
 #include <limits.h>
 #endif

Tests/TestingTests/Support/FileHandleTests.swift

@@ -56,23 +56,27 @@ struct FileHandleTests {
 
   @Test("Can write to a file")
   func canWrite() throws {
-    // NOTE: we are not trying to test mkstemp() here. We are trying to test the
-    // capacity of FileHandle to open a file for writing, and need a temporary
-    // file to write to.
-#if os(Windows)
-    let path = try String(unsafeUninitializedCapacity: 1024) { buffer in
-      try #require(0 == tmpnam_s(buffer.baseAddress!, buffer.count))
-      return strnlen(buffer.baseAddress!, buffer.count)
+    try withTemporaryPath { path in
+      let fileHandle = try FileHandle(forWritingAtPath: path)
+      try fileHandle.write([0, 1, 2, 3, 4, 5])
+      try fileHandle.write("Hello world!")
     }
-#else
-    let path = "/tmp/can_write_to_file_\(UInt64.random(in: 0 ..< .max))"
-#endif
-    defer {
-      remove(path)
+  }
+
+  @Test("Can read from a file")
+  func canRead() throws {
+    let bytes: [UInt8] = (0 ..< 8192).map { _ in
+      UInt8.random(in: .min ... .max)
+    }
+    try withTemporaryPath { path in
+      do {
+        let fileHandle = try FileHandle(forWritingAtPath: path)
+        try fileHandle.write(bytes)
+      }
+      let fileHandle = try FileHandle(forReadingAtPath: path)
+      let bytes2 = try fileHandle.readToEnd()
+      #expect(bytes == bytes2)
     }
-    let fileHandle = try FileHandle(forWritingAtPath: path)
-    try fileHandle.write([0, 1, 2, 3, 4, 5])
-    try fileHandle.write("Hello world!")
   }
 
   @Test("Cannot write bytes to a read-only file")
@@ -160,6 +164,45 @@ struct FileHandleTests {
 
 // MARK: - Fixtures
 
+func temporaryDirectory() throws -> String {
+#if SWT_TARGET_OS_APPLE
+  try withUnsafeTemporaryAllocation(of: CChar.self, capacity: Int(PATH_MAX)) { buffer in
+    if 0 != confstr(_CS_DARWIN_USER_TEMP_DIR, buffer.baseAddress, buffer.count) {
+      return String(cString: buffer.baseAddress!)
+    }
+    return try #require(Environment.variable(named: "TMPDIR"))
+  }
+#elseif os(Linux)
+  "/tmp"
+#elseif os(Windows)
+  try withUnsafeTemporaryAllocation(of: wchar_t.self, capacity: Int(MAX_PATH + 1)) { buffer in
+    // NOTE: GetTempPath2W() was introduced in Windows 10 Build 20348.
+    if 0 == GetTempPathW(DWORD(buffer.count), buffer.baseAddress) {
+      throw Win32Error(rawValue: GetLastError())
+    }
+    return try #require(String.decodeCString(buffer.baseAddress, as: UTF16.self)?.result)
+  }
+#endif
+}
+
+func withTemporaryPath<R>(_ body: (_ path: String) throws -> R) throws -> R {
+  // NOTE: we are not trying to test mkstemp() here. We are trying to test the
+  // capacity of FileHandle to open a file for reading or writing and we need a
+  // temporary file to write to.
+#if os(Windows)
+  let path = try String(unsafeUninitializedCapacity: 1024) { buffer in
+    try #require(0 == tmpnam_s(buffer.baseAddress!, buffer.count))
+    return strnlen(buffer.baseAddress!, buffer.count)
+  }
+#else
+  let path = appendPathComponent("file_named_\(UInt64.random(in: 0 ..< .max))", to: try temporaryDirectory())
+#endif
+  defer {
+    _ = remove(path)
+  }
+  return try body(path)
+}
+
 extension FileHandle {
   static func temporary() throws -> FileHandle {
 #if os(Windows)

Tests/TestingTests/SwiftPMTests.swift

@@ -9,9 +9,6 @@
 //
 
 @testable @_spi(Experimental) @_spi(ForToolsIntegrationOnly) import Testing
-#if canImport(Foundation)
-import Foundation
-#endif
 private import TestingInternals
 
 @Suite("Swift Package Manager Integration Tests")
@@ -130,26 +127,32 @@ struct SwiftPMTests {
     }
   }
 
-#if canImport(Foundation)
   @Test("--xunit-output argument (writes to file)")
   func xunitOutputIsWrittenToFile() throws {
     // Test that a file is opened when requested. Testing of the actual output
     // occurs in ConsoleOutputRecorderTests.
-    let temporaryFileURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: false)
+    let tempDirPath = try temporaryDirectory()
+    let temporaryFilePath = appendPathComponent("\(UInt64.random(in: 0 ..< .max))", to: tempDirPath)
     defer {
-      try? FileManager.default.removeItem(at: temporaryFileURL)
+      _ = remove(temporaryFilePath)
     }
     do {
-      let configuration = try configurationForSwiftPMEntryPoint(withArguments: ["PATH", "--xunit-output", temporaryFileURL.path])
+      let configuration = try configurationForSwiftPMEntryPoint(withArguments: ["PATH", "--xunit-output", temporaryFilePath])
       let eventContext = Event.Context()
       configuration.eventHandler(Event(.runStarted, testID: nil, testCaseID: nil), eventContext)
       configuration.eventHandler(Event(.runEnded, testID: nil, testCaseID: nil), eventContext)
     }
-    #expect(try temporaryFileURL.checkResourceIsReachable())
+
+    let fileHandle = try FileHandle(forReadingAtPath: temporaryFilePath)
+    let fileContents = try fileHandle.readToEnd()
+    #expect(!fileContents.isEmpty)
+    #expect(fileContents.contains(UInt8(ascii: "<")))
+    #expect(fileContents.contains(UInt8(ascii: ">")))
   }
 
-  func decodeEventStream(fromFileAt url: URL) throws -> [EventAndContextSnapshot] {
-    try Data(contentsOf: url, options: [.mappedIfSafe])
+#if canImport(Foundation)
+  func decodeEventStream(fromFileAtPath path: String) throws -> [EventAndContextSnapshot] {
+    try FileHandle(forReadingAtPath: path).readToEnd()
       .split(separator: 10) // "\n"
       .map { line in
         try line.withUnsafeBytes { line in
@@ -162,12 +165,13 @@ struct SwiftPMTests {
   func eventStreamOutput() async throws {
     // Test that events are successfully streamed to a file and can be read
     // back as snapshots.
-    let temporaryFileURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: false)
+    let tempDirPath = try temporaryDirectory()
+    let temporaryFilePath = appendPathComponent("\(UInt64.random(in: 0 ..< .max))", to: tempDirPath)
     defer {
-      try? FileManager.default.removeItem(at: temporaryFileURL)
+      _ = remove(temporaryFilePath)
     }
     do {
-      let configuration = try configurationForSwiftPMEntryPoint(withArguments: ["PATH", "--experimental-event-stream-output", temporaryFileURL.path])
+      let configuration = try configurationForSwiftPMEntryPoint(withArguments: ["PATH", "--experimental-event-stream-output", temporaryFilePath])
       let eventContext = Event.Context()
       configuration.handleEvent(Event(.runStarted, testID: nil, testCaseID: nil), in: eventContext)
       do {
@@ -178,9 +182,8 @@ struct SwiftPMTests {
       }
       configuration.handleEvent(Event(.runEnded, testID: nil, testCaseID: nil), in: eventContext)
     }
-    #expect(try temporaryFileURL.checkResourceIsReachable())
 
-    let decodedEvents = try decodeEventStream(fromFileAt: temporaryFileURL)
+    let decodedEvents = try decodeEventStream(fromFileAtPath: temporaryFilePath)
     #expect(decodedEvents.count == 4)
   }
 #endif

Tests/TestingTests/Traits/TagListTests.swift

@@ -9,10 +9,7 @@
 //
 
 @testable @_spi(Experimental) @_spi(ForToolsIntegrationOnly) import Testing
-
-#if canImport(Foundation)
-import Foundation
-#endif
+private import TestingInternals
 
 @Suite("Tag/Tag List Tests", .tags(.traitRelated))
 struct TagListTests {
@@ -137,9 +134,9 @@ struct TagListTests {
     .tags("alpha", "beta", "gamma", "delta"), .tags(.namedConstant)
   )
   func tagColorsReadFromDisk() throws {
-    let tempDirURL = FileManager.default.temporaryDirectory
-    let jsonURL = tempDirURL.appendingPathComponent("tag-colors.json", isDirectory: false)
-    let jsonContent = """
+    let tempDirPath = try temporaryDirectory()
+    let jsonPath = appendPathComponent("tag-colors.json", to: tempDirPath)
+    var jsonContent = """
     {
     "alpha": "red",
     "beta": "#00CCFF",
@@ -154,12 +151,15 @@ struct TagListTests {
     "encode purple": "purple"
     }
     """
-    try jsonContent.write(to: jsonURL, atomically: true, encoding: .utf8)
+    try jsonContent.withUTF8 { jsonContent in
+      let fileHandle = try FileHandle(forWritingAtPath: jsonPath)
+      try fileHandle.write(jsonContent)
+    }
     defer {
-      try? FileManager.default.removeItem(at: jsonURL)
+      _ = remove(jsonPath)
     }
 
-    let tagColors = try Testing.loadTagColors(fromFileInDirectoryAtPath: tempDirURL.path)
+    let tagColors = try Testing.loadTagColors(fromFileInDirectoryAtPath: tempDirPath)
     #expect(tagColors[Tag("alpha")] == .red)
     #expect(tagColors[Tag("beta")] == .rgb(0, 0xCC, 0xFF))
     #expect(tagColors[Tag("gamma")] == .rgb(0xAA, 0xBB, 0xCC))