WIP: Add in path syntax tests

Author: milseman

Sources/SystemInternals/Mocking.swift

@@ -81,6 +81,10 @@ public class MockingDriver {
 
   // A buffer to put `write` bytes into
   public var writeBuffer = WriteBuffer()
+
+  // Whether we should pretend to be Windows for syntactic operations
+  // inside FilePath
+  public var forceWindowsSyntaxForPaths = false
 }
 
 #if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)

Tests/SystemTests/FilePathTests/FilePathSyntaxTest.swift

@@ -0,0 +1,243 @@
+/*
+ This source file is part of the Swift System open source project
+
+ Copyright (c) 2020 Apple Inc. and the Swift System project authors
+ Licensed under Apache License v2.0 with Runtime Library Exception
+
+ See https://swift.org/LICENSE.txt for license information
+*/
+
+import XCTest
+import SystemPackage
+
+
+struct TestPathSyntax: TestCase {
+  var file: StaticString
+  var line: UInt
+
+  func runAllTests() {
+    // ...
+  }
+}
+
+struct SyntaxTestCase: TestCase {
+  // We defer forming the path until `runAllTests()` executes,
+  // so that we can switch between unix and windows behavior.
+  let pathStr: String
+
+  // Whether we want the path to be constructed and syntactically
+  // manipulated as though it were a Windows path
+  let isWindows: Bool
+
+  let absolute: Bool
+
+  let root: String?
+  let relative: String?
+
+  let rootName: String?
+  let rootDirectory: String?
+
+  let dirname: String
+  let basename: String?
+
+  let stem: String?
+  let `extension`: String?
+
+  var file: StaticString
+  var line: UInt
+}
+
+extension SyntaxTestCase {
+  static func unix(
+    _ path: String,
+    root: String?, relative: String,
+    dirname: String, basename: String?,
+    stem: String?, extension: String? = nil,
+    file: StaticString = #file, line: UInt = #line
+  ) -> SyntaxTestCase {
+    SyntaxTestCase(
+      pathStr: path,
+      isWindows: false,
+      absolute: root != nil,
+      root: root, relative: relative,
+      rootName: nil, rootDirectory: root,
+      dirname: dirname, basename: basename,
+      stem: stem, extension: `extension`,
+      file: file, line: line)
+  }
+
+  static func windows(
+    _ path: String,
+    absolute: Bool,
+    root: String?, relative: String,
+    rootName: String?, rootDirectory: String?,
+    dirname: String, basename: String?,
+    stem: String?, extension: String? = nil,
+    file: StaticString = #file, line: UInt = #line
+  ) -> SyntaxTestCase {
+    SyntaxTestCase(
+      pathStr: path,
+      isWindows: true,
+      absolute: absolute,
+      root: root, relative: relative,
+      rootName: rootName, rootDirectory: rootDirectory,
+      dirname: dirname, basename: basename,
+      stem: stem, extension: `extension`,
+      file: file, line: line)
+  }
+}
+
+import SystemInternals
+private func withWindowsSupport(enabled: Bool, _ f: () -> ()) {
+  guard enabled else { return f() }
+  MockingDriver.withMockingEnabled { driver in
+    driver.forceWindowsSyntaxForPaths = true
+    f()
+  }
+}
+
+extension SyntaxTestCase {
+  func runAllTests() {
+    withWindowsSupport(enabled: isWindows) {
+      let path = FilePath(pathStr)
+      expectEqual(pathStr, path.description)
+
+//      expectEqual(absolute, path.isAbsolute)
+//      expectEqual(!absolute, path.isRelative)
+//
+//      expectEqual(root, path.root?.description)
+//      expectEqual(relative, path.relativePath.description)
+//
+//      expectEqual(rootName, path.rootName)
+//      expectEqual(rootDirectory, path.rootDirectory?.description)
+//
+//      expectEqual(dirname, path.dirname.description)
+//      expectEqual(basename, path.basename?.description)
+//
+//      expectEqual(stem, path.stem)
+//      expectEqual(`extension`, path.`extension`)
+    }
+  }
+}
+
+// TODO: lexically normalize tests, lexically relative tests, separator normalization, etc.
+
+let unixPaths: Array<SyntaxTestCase> = [
+  .unix(
+    "/usr/bin/ls",
+    root: "/", relative: "usr/bin/ls",
+    dirname: "/usr/bin", basename: "ls",
+    stem: "ls"),
+
+  .unix(
+    "bin/ls",
+    root: nil, relative: "bin/ls",
+    dirname: "bin", basename: "ls",
+    stem: "ls"),
+
+  .unix(
+    "~/bar.app",
+    root: nil, relative: "~/bar.app",
+    dirname: "~", basename: "bar.app",
+    stem: "bar", extension: "app"),
+
+  .unix(
+    "/",
+    root: "/", relative: "",
+    dirname: "/", basename: nil,
+    stem: nil, extension: nil),
+
+  .unix(
+    "/tmp/.",
+    root: "/", relative: "tmp/.",
+    dirname: "/tmp/.", basename: ".",
+    stem: ".", extension: nil),
+
+  .unix(
+    "/tmp/..",
+    root: "/", relative: "tmp/..",
+    dirname: "/tmp/..", basename: "..",
+    stem: "..", extension: nil),
+
+  .unix(
+    "/tmp/.hidden",
+    root: "/", relative: "tmp/.hidden",
+    dirname: "/tmp/.hidden", basename: ".hidden",
+    stem: ".hidden", extension: nil),
+
+  // Backslash is not a separator, nor a root
+  .unix(
+    #"\bin\.\ls"#,
+    root: nil, relative: #"\bin\.\ls"#,
+    dirname: "", basename: #"\bin\.\ls"#,
+    stem: #"\bin\"#, extension: #".\ls"#),
+]
+
+let windowsPaths: Array<SyntaxTestCase> = [
+  .windows(
+    #"C:\foo\bar.exe"#,
+    absolute: true,
+    root: #"C:\"#, relative: #"foo\bar.exe"#,
+    rootName: "C:", rootDirectory: #"\"#,
+    dirname: #"C:\foo"#, basename: "bar.exe",
+    stem: "bar", extension: "exe"),
+
+  .windows(
+    #"C:foo\bar"#,
+    absolute: false,
+    root: #"C:`"#, relative: #"foo\bar"#,
+    rootName: "C:", rootDirectory: nil,
+    dirname: #"C:foo"#, basename: "bar",
+    stem: "bar"),
+
+  .windows(
+    #"\foo\bar.exe"#,
+    absolute: false,
+    root: #"\"#, relative: #"foo\bar"#,
+    rootName: nil, rootDirectory: #"\"#,
+    dirname: #"\foo"#, basename: "bar",
+    stem: "bar", extension: "exe"),
+
+  .windows(
+    #"foo\bar.exe"#,
+    absolute: false,
+    root: nil, relative: #"foo\bar"#,
+    rootName: nil, rootDirectory: nil,
+    dirname: #"foo"#, basename: "bar",
+    stem: "bar", extension: "exe"),
+
+  .windows(
+    #"\\?\device\folder\file.exe"#,
+    absolute: true,
+    root: #"\\?\device\"#, relative: #"folder\file.exe"#,
+    rootName: #"\\?\device"#, rootDirectory: #"\"#,
+    dirname: #"\\?\device\folder"#, basename: "file.exe",
+    stem: "file", extension: "exe"),
+
+  .windows(
+    #"\\?\UNC\server\share\folder\file.txt"#,
+    absolute: true,
+    root: #"\\?\UNC\server\share\`"#, relative: #"folder\file.txt"#,
+    rootName: #"\\?\UNC\server\share"#, rootDirectory: #"\"#,
+    dirname: #"\\?\UNC\server\share\folder"#, basename: "file.txt",
+    stem: "file", extension: ".txt"),
+
+  .windows(
+    #"\\server\share\folder\file.txt"#,
+    absolute: true,
+    root: #"\\server\share\`"#, relative: #"folder\file.txt"#,
+    rootName: #"\\server\share"#, rootDirectory: #"\"#,
+    dirname: #"\\server\share\folder"#, basename: "file.txt",
+    stem: "file", extension: ".txt"),
+]
+
+final class FilePathSyntaxTest: XCTestCase {
+  func testRootRelative() {
+    for test in unixPaths {
+      test.runAllTests()
+    }
+    for test in windowsPaths {
+      test.runAllTests()
+    }
+  }
+}