.some

Tests/PathTests/PathTests.swift

@@ -0,0 +1,96 @@
+import XCTest
+import Path
+
+class PathTests: XCTestCase {
+    func testConcatenation() {
+        XCTAssertEqual((Path.root/"bar").string, "/bar")
+        XCTAssertEqual(Path.cwd.string, FileManager.default.currentDirectoryPath)
+        XCTAssertEqual((Path.root/"/bar").string, "/bar")
+        XCTAssertEqual((Path.root/"///bar").string, "/bar")
+        XCTAssertEqual((Path.root/"foo///bar////").string, "/foo/bar")
+        XCTAssertEqual((Path.root/"foo"/"/bar").string, "/foo/bar")
+    }
+
+    func testEnumeration() throws {
+        let tmpdir_ = try TemporaryDirectory()
+        let tmpdir = tmpdir_.path
+        try tmpdir.join("a").mkdir().join("c").touch()
+        try tmpdir.join("b").touch()
+        try tmpdir.join("c").touch()
+
+        var paths = Set<String>()
+        var dirs = 0
+        for entry in try tmpdir.ls() {
+            if entry.kind == .directory {
+                dirs += 1
+            }
+            paths.insert(entry.path.basename())
+        }
+        XCTAssertEqual(dirs, 1)
+        XCTAssertEqual(paths, ["a", "b", "c"])
+    }
+
+    func testRelativeTo() {
+        XCTAssertEqual((Path.root/"tmp/foo").relative(to: .root/"tmp"), "foo")
+        XCTAssertEqual((Path.root/"tmp/foo/bar").relative(to: .root/"tmp/baz"), "../foo/bar")
+    }
+
+    func testExists() {
+        XCTAssert(Path.root.exists)
+        XCTAssert((Path.root/"Users").exists)
+    }
+
+    func testIsDirectory() {
+        XCTAssert(Path.root.isDirectory)
+        XCTAssert((Path.root/"Users").isDirectory)
+    }
+
+    func testMktemp() throws {
+        var path: Path!
+        try Path.mktemp {
+            path = $0
+            XCTAssert(path.isDirectory)
+        }
+        XCTAssert(!path.exists)
+        XCTAssert(!path.isDirectory)
+    }
+
+    func testMkpathIfExists() throws {
+        try Path.mktemp {
+            for _ in 0...1 {
+                try $0.join("a").mkdir()
+                try $0.join("b/c").mkpath()
+            }
+        }
+    }
+
+    func testBasename() {
+        XCTAssertEqual(Path.root.join("foo.bar").basename(dropExtension: true), "foo")
+        XCTAssertEqual(Path.root.join("foo").basename(dropExtension: true), "foo")
+        XCTAssertEqual(Path.root.join("foo.").basename(dropExtension: true), "foo.")
+        XCTAssertEqual(Path.root.join("foo.bar.baz").basename(dropExtension: true), "foo.bar")
+    }
+
+    func testCodable() throws {
+        let input = [Path.root/"bar"]
+        XCTAssertEqual(try JSONDecoder().decode([Path].self, from: try JSONEncoder().encode(input)), input)
+    }
+
+    func testRelativePathCodable() throws {
+        let root = Path.root/"bar"
+        let input = [
+            root/"foo"
+        ]
+
+        let encoder = JSONEncoder()
+        encoder.userInfo[.relativePath] = root
+        let data = try encoder.encode(input)
+
+        XCTAssertEqual(try JSONSerialization.jsonObject(with: data) as? [String], ["foo"])
+
+        let decoder = JSONDecoder()
+        XCTAssertThrowsError(try decoder.decode([Path].self, from: data))
+        decoder.userInfo[.relativePath] = root
+        XCTAssertEqual(try decoder.decode([Path].self, from: data), input)
+    }
+}

Tests/PathTests/XCTestManifests.swift

@@ -0,0 +1,24 @@
+import XCTest
+
+extension PathTests {
+    static let __allTests = [
+        ("testBasename", testBasename),
+        ("testCodable", testCodable),
+        ("testConcatenation", testConcatenation),
+        ("testEnumeration", testEnumeration),
+        ("testExists", testExists),
+        ("testIsDirectory", testIsDirectory),
+        ("testMkpathIfExists", testMkpathIfExists),
+        ("testMktemp", testMktemp),
+        ("testRelativePathCodable", testRelativePathCodable),
+        ("testRelativeTo", testRelativeTo),
+    ]
+}
+
+#if !os(macOS)
+public func __allTests() -> [XCTestCaseEntry] {
+    return [
+        testCase(PathTests.__allTests),
+    ]
+}
+#endif