[android] Replace URL tests that use hardcoded /tmp

In Android /tmp doesn't exist, and the temporary directory is normally
/data/local/tmp. It is not a symlink. The tests were mostly working, but
because `resolvingSymlinksInPath` returns a trailing slash if the
directory actually exists, in Android it was returning without the final
trailing slash in some of the cases.

The changes split the large test into smaller pieces that test one of
the behaviours of `resolvingSymlinksInPath`, and tries not to use the
temporarl directory by itself or suppose anything about it.

There are, however, a couple of tests that check behaviours that are
only applicable to Darwin, so those tests are only performed in Darwin
platforms.

Author: drodriguez

TestFoundation/TestURL.swift

@@ -48,19 +48,57 @@ private func getTestData() -> [Any]? {
 
 class TestURL : XCTestCase {
     static var allTests: [(String, (TestURL) -> () throws -> Void)] {
-        return [
+        var tests: [(String, (TestURL) -> () throws -> Void)] = [
             ("test_URLStrings", test_URLStrings),
             ("test_fileURLWithPath_relativeTo", test_fileURLWithPath_relativeTo ),
             // TODO: these tests fail on linux, more investigation is needed
             ("test_fileURLWithPath", test_fileURLWithPath),
             ("test_fileURLWithPath_isDirectory", test_fileURLWithPath_isDirectory),
-            ("test_URLByResolvingSymlinksInPath", test_URLByResolvingSymlinksInPath),
+            ("test_URLByResolvingSymlinksInPathShouldRemoveDuplicatedPathSeparators", test_URLByResolvingSymlinksInPathShouldRemoveDuplicatedPathSeparators),
+            ("test_URLByResolvingSymlinksInPathShouldRemoveSingleDotsBetweenSeparators", test_URLByResolvingSymlinksInPathShouldRemoveSingleDotsBetweenSeparators),
+            ("test_URLByResolvingSymlinksInPathShouldCompressDoubleDotsBetweenSeparators", test_URLByResolvingSymlinksInPathShouldCompressDoubleDotsBetweenSeparators),
+            ("test_URLByResolvingSymlinksInPathShouldUseTheCurrentDirectory", test_URLByResolvingSymlinksInPathShouldUseTheCurrentDirectory),
+            ("test_resolvingSymlinksInPathShouldAppendTrailingSlashWhenExistingDirectory", test_resolvingSymlinksInPathShouldAppendTrailingSlashWhenExistingDirectory),
+            ("test_resolvingSymlinksInPathShouldResolvesSymlinks", test_resolvingSymlinksInPathShouldResolvesSymlinks),
+            ("test_resolvingSymlinksInPathShouldNotChangeNonFileURLs", test_resolvingSymlinksInPathShouldNotChangeNonFileURLs),
+            ("test_resolvingSymlinksInPathShouldNotChangePathlessURLs", test_resolvingSymlinksInPathShouldNotChangePathlessURLs),
             ("test_reachable", test_reachable),
             ("test_copy", test_copy),
             ("test_itemNSCoding", test_itemNSCoding),
             ("test_dataRepresentation", test_dataRepresentation),
             ("test_description", test_description),
         ]
+
+        #if canImport(Darwin)
+        tests += [
+            ("test_resolvingSymlinksInPathShouldRemovePrivatePrefix", test_resolvingSymlinksInPathShouldRemovePrivatePrefix),
+            ("test_resolvingSymlinksInPathShouldNotRemovePrivatePrefixIfOnlyComponent", test_resolvingSymlinksInPathShouldNotRemovePrivatePrefixIfOnlyComponent),
+        ]
+        #endif
+
+        return tests
+    }
+
+    var writableTestDirectoryURL: URL!
+
+    override func setUp() {
+        super.setUp()
+
+        let pid = ProcessInfo.processInfo.processIdentifier
+        writableTestDirectoryURL = URL(fileURLWithPath: NSTemporaryDirectory()).appendingPathComponent("org.swift.TestFoundation.TestURL.\(pid)")
+    }
+
+    override func tearDown() {
+        if let directoryURL = writableTestDirectoryURL,
+            (try? FileManager.default.attributesOfItem(atPath: directoryURL.path)) != nil {
+            do {
+                try FileManager.default.removeItem(at: directoryURL)
+            } catch {
+                NSLog("Could not remove test directory at URL \(directoryURL): \(error)")
+            }
+        }
+
+        super.tearDown()
     }
 
     func test_fileURLWithPath_relativeTo() {
@@ -383,58 +421,96 @@ class TestURL : XCTestCase {
         XCTAssertTrue(strncmp(TestURL.gFileDoesNotExistName, relativePath, lengthOfRelativePath) == 0, "fileSystemRepresentation of file path is wrong")
     }
 
-    func test_URLByResolvingSymlinksInPath() {
-        let files = [
-            NSTemporaryDirectory() + "ABC/test_URLByResolvingSymlinksInPath"
-        ]
-        
-        guard ensureFiles(files) else {
-            XCTAssert(false, "Could create files for testing.")
-            return
-        }
-        
-        // tmp is special because it is symlinked to /private/tmp and this /private prefix should be dropped,
-        // so tmp is tmp. On Linux tmp is not symlinked so it would be the same.
-        do {
-            let url = URL(fileURLWithPath: "/.//tmp/ABC/..")
-            let result = url.resolvingSymlinksInPath().absoluteString
-            XCTAssertEqual(result, "file:///tmp/", "URLByResolvingSymlinksInPath removes extraneous path components and resolve symlinks.")
-        }
-        
-        do {
-            let url = URL(fileURLWithPath: "~")
-            let result = url.resolvingSymlinksInPath().absoluteString
-            let expected = "file://" + FileManager.default.currentDirectoryPath + "/~"
-            XCTAssertEqual(result, expected, "URLByResolvingSymlinksInPath resolves relative paths using current working directory.")
-        }
+    func test_URLByResolvingSymlinksInPathShouldRemoveDuplicatedPathSeparators() {
+        let url = URL(fileURLWithPath: "//foo///bar////baz/")
+        let result = url.resolvingSymlinksInPath()
+        XCTAssertEqual(result, URL(fileURLWithPath: "/foo/bar/baz"))
+    }
 
-        do {
-            let url = URL(fileURLWithPath: "anysite.com/search")
-            let result = url.resolvingSymlinksInPath().absoluteString
-            let expected = "file://" + FileManager.default.currentDirectoryPath + "/anysite.com/search"
-            XCTAssertEqual(result, expected)
-        }
+    func test_URLByResolvingSymlinksInPathShouldRemoveSingleDotsBetweenSeparators() {
+        let url = URL(fileURLWithPath: "/./foo/./.bar/./baz/./")
+        let result = url.resolvingSymlinksInPath()
+        XCTAssertEqual(result, URL(fileURLWithPath: "/foo/.bar/baz"))
+    }
 
-        // tmp is symlinked on macOS only
-        #if os(macOS)
-        do {
-            let url = URL(fileURLWithPath: "/tmp/..")
-            let result = url.resolvingSymlinksInPath().absoluteString
-            XCTAssertEqual(result, "file:///private/")
-        }
-        #else
-        do {
-            let url = URL(fileURLWithPath: "/tmp/ABC/test_URLByResolvingSymlinksInPath")
-            let result = url.resolvingSymlinksInPath().absoluteString
-            XCTAssertEqual(result, "file:///tmp/ABC/test_URLByResolvingSymlinksInPath", "URLByResolvingSymlinksInPath appends trailing slash for existing directories only")
-        }
-        #endif
+    func test_URLByResolvingSymlinksInPathShouldCompressDoubleDotsBetweenSeparators() {
+        let url = URL(fileURLWithPath: "/foo/../..bar/../baz/")
+        let result = url.resolvingSymlinksInPath()
+        XCTAssertEqual(result, URL(fileURLWithPath: "/baz"))
+    }
 
-        do {
-            let url = URL(fileURLWithPath: "/tmp/ABC/..")
-            let result = url.resolvingSymlinksInPath().absoluteString
-            XCTAssertEqual(result, "file:///tmp/")
+    func test_URLByResolvingSymlinksInPathShouldUseTheCurrentDirectory() throws {
+        let fileManager = FileManager.default
+        try fileManager.createDirectory(at: writableTestDirectoryURL, withIntermediateDirectories: true)
+        defer { try? fileManager.removeItem(at: writableTestDirectoryURL) }
+
+        let previousCurrentDirectory = fileManager.currentDirectoryPath
+        fileManager.changeCurrentDirectoryPath(writableTestDirectoryURL.path)
+        defer { fileManager.changeCurrentDirectoryPath(previousCurrentDirectory) }
+
+        let url = URL(fileURLWithPath: "foo/bar/baz")
+        let result = url.resolvingSymlinksInPath()
+        XCTAssertEqual(result, URL(fileURLWithPath: writableTestDirectoryURL.path + "/foo/bar/baz"))
+    }
+
+    func test_resolvingSymlinksInPathShouldAppendTrailingSlashWhenExistingDirectory() throws {
+        let fileManager = FileManager.default
+        try fileManager.createDirectory(at: writableTestDirectoryURL, withIntermediateDirectories: true)
+        defer { try? fileManager.removeItem(at: writableTestDirectoryURL) }
+
+        var path = writableTestDirectoryURL.path
+        if path.hasSuffix("/") {
+            path.remove(at: path.index(path.endIndex, offsetBy: -1))
         }
+        let url = URL(fileURLWithPath: path)
+        let result = url.resolvingSymlinksInPath()
+        XCTAssertEqual(result, URL(fileURLWithPath: path + "/"))
+    }
+
+    func test_resolvingSymlinksInPathShouldResolvesSymlinks() throws {
+        // NOTE: this test only works on file systems that support symlinks.
+        let fileManager = FileManager.default
+        try fileManager.createDirectory(at: writableTestDirectoryURL, withIntermediateDirectories: true)
+        defer { try? fileManager.removeItem(at: writableTestDirectoryURL) }
+
+        let symbolicLink = writableTestDirectoryURL.appendingPathComponent("origin")
+        print(symbolicLink)
+        let destination = writableTestDirectoryURL.appendingPathComponent("destination")
+        print(destination)
+        try "".write(to: destination, atomically: true, encoding: .utf8)
+        try fileManager.createSymbolicLink(at: symbolicLink, withDestinationURL: destination)
+
+        let result = symbolicLink.resolvingSymlinksInPath()
+        print(result)
+        XCTAssertEqual(result, URL(fileURLWithPath: writableTestDirectoryURL.path + "/destination"))
+    }
+
+    func test_resolvingSymlinksInPathShouldRemovePrivatePrefix() {
+        // NOTE: this test only works on Darwin, since the code that removes
+        // /private relies on /private/tmp existing.
+        let url = URL(fileURLWithPath: "/private/tmp")
+        let result = url.resolvingSymlinksInPath()
+        XCTAssertEqual(result, URL(fileURLWithPath: "/tmp"))
+    }
+
+    func test_resolvingSymlinksInPathShouldNotRemovePrivatePrefixIfOnlyComponent() {
+        // NOTE: this test only works on Darwin, since only there /tmp is
+        // symlinked to /private/tmp.
+        let url = URL(fileURLWithPath: "/tmp/..")
+        let result = url.resolvingSymlinksInPath()
+        XCTAssertEqual(result, URL(fileURLWithPath: "/private"))
+    }
+
+    func test_resolvingSymlinksInPathShouldNotChangeNonFileURLs() {
+        let url = URL(string: "myscheme://server/foo/bar/baz")!
+        let result = url.resolvingSymlinksInPath().absoluteString
+        XCTAssertEqual(result, "myscheme://server/foo/bar/baz")
+    }
+
+    func test_resolvingSymlinksInPathShouldNotChangePathlessURLs() {
+        let url = URL(string: "file://")!
+        let result = url.resolvingSymlinksInPath().absoluteString
+        XCTAssertEqual(result, "file://")
     }
 
     func test_reachable() {