Fix Up FileManager Tests on Windows

- Windows directory enumerator now doesn't look in a directory it
  returns until nextObject is called again
- Fixed some path handling platform issues
- Properly calculate level

Author: gmittert

Foundation/FileManager+Win32.swift

@@ -652,14 +652,15 @@ extension FileManager {
         var _options : FileManager.DirectoryEnumerationOptions
         var _errorHandler : ((URL, Error) -> Bool)?
         var _stack: [URL]
-        var _current: URL?
+        var _current: URL
         var _rootDepth : Int
 
         init(url: URL, options: FileManager.DirectoryEnumerationOptions, errorHandler: (/* @escaping */ (URL, Error) -> Bool)?) {
             _options = options
             _errorHandler = errorHandler
-            _stack = [url]
+            _stack = []
             _rootDepth = url.pathComponents.count
+            _current = url
         }
 
         override func nextObject() -> Any? {
@@ -689,27 +690,52 @@ extension FileManager {
                 } while FindNextFileW(h, &ffd)
                 return files
             }
-            while let url = _stack.popLast() {
-                if url.hasDirectoryPath && !_options.contains(.skipsSubdirectoryDescendants) {
-                    guard let dirContents = contentsOfDir(directory: url)?.reversed() else {
-                        if let handler = _errorHandler {
-                           let dirFSR = url.withUnsafeFileSystemRepresentation { $0.flatMap { fsr in String(utf8String: fsr) } }
-                           let keepGoing = handler(URL(fileURLWithPath: dirFSR ?? ""),
-                               _NSErrorWithWindowsError(GetLastError(), reading: true))
-                           if !keepGoing { return nil }
-                        }
-                        continue
-                    }
-                    _stack.append(contentsOf: dirContents)
+
+            func findFirstValidFile() -> URL? {
+              while let url = _stack.popLast() {
+                let dirFSR = url.withUnsafeFileSystemRepresentation { $0.flatMap { fsr in String(utf8String: fsr) } } ?? ""
+                if !FileManager.default.fileExists(atPath: dirFSR, isDirectory: nil) {
+                  if let handler = _errorHandler {
+                    let keepGoing = handler(URL(fileURLWithPath: dirFSR),
+                                    _NSErrorWithWindowsError(GetLastError(), reading: true))
+                    if !keepGoing { return nil }
+                  }
+                  continue
                 }
+
                 _current = url
-                return url
+                return _current
+              }
+              return nil
             }
-            return nil
+
+            var isDir: ObjCBool = false
+            let dirFSR = _current.withUnsafeFileSystemRepresentation { $0.flatMap { fsr in String(utf8String: fsr) } } ?? ""
+            guard FileManager.default.fileExists(atPath: dirFSR, isDirectory: &isDir) else {
+              if let handler = _errorHandler {
+                let keepGoing = handler(URL(fileURLWithPath: dirFSR),
+                                        _NSErrorWithWindowsError(GetLastError(), reading: true))
+                return keepGoing ? findFirstValidFile() : nil
+              }
+              return nil
+            }
+
+            if isDir.boolValue && !_options.contains(.skipsSubdirectoryDescendants) {
+              if let dirContents = contentsOfDir(directory: _current)?.reversed() {
+                _stack.append(contentsOf: dirContents)
+              } else {
+                if let handler = _errorHandler {
+                  let keepGoing = handler(URL(fileURLWithPath: dirFSR),
+                                          _NSErrorWithWindowsError(GetLastError(), reading: true))
+                  if !keepGoing { return nil }
+                }
+              }
+            }
+            return findFirstValidFile()
         }
 
         override var level: Int {
-            return _rootDepth - (_current?.pathComponents.count ?? _rootDepth)
+            return _current.pathComponents.count - _rootDepth
         }
 
         override func skipDescendants() {
@@ -733,8 +759,7 @@ extension FileManager.NSPathDirectoryEnumerator {
             return nil
         }
 
-        var relativePath = UnsafeMutableBufferPointer<WCHAR>.allocate(capacity: Int(MAX_PATH))
-        defer { relativePath.deallocate() }
+        var relativePath: [WCHAR] = Array<WCHAR>(repeating: 0, count: Int(MAX_PATH))
         func withURLCString<Result>(url: URL, _ f: (UnsafePointer<WCHAR>) -> Result?) -> Result? {
             return url.withUnsafeFileSystemRepresentation { fsr in
                 (fsr.flatMap { String(utf8String: $0) })?.withCString(encodedAs: UTF16.self) { f($0) }
@@ -747,12 +772,14 @@ extension FileManager.NSPathDirectoryEnumerator {
                 guard fromAttrs != INVALID_FILE_ATTRIBUTES, toAttrs != INVALID_FILE_ATTRIBUTES else {
                     return false
                 }
-                return PathRelativePathToW(relativePath.baseAddress, pszFrom, fromAttrs, pszTo, toAttrs)
+                return PathRelativePathToW(&relativePath, pszFrom, fromAttrs, pszTo, toAttrs)
             }
-        }) == true, let (path, _) = String.decodeCString(relativePath.baseAddress, as: UTF16.self) else {
+        }) == true, let (path, _) = String.decodeCString(&relativePath, as: UTF16.self) else {
             return nil
         }
-        _currentItemPath = path
+        // PathRelativePathToW always prepends a ".\" to the path. Drop it to
+        // match the POSIX implementation
+        _currentItemPath = path.dropFirst(2)
         return _currentItemPath
     }
 

Foundation/NSPathUtilities.swift

@@ -118,7 +118,11 @@ extension String {
     }
 
     internal var absolutePath: Bool {
+#if os(Windows)
+        return !withCString(encodedAs: UTF16.self, PathIsRelativeW)
+#else
         return hasPrefix("~") || hasPrefix("/")
+#endif
     }
 
     internal func _stringByAppendingPathComponent(_ str: String, doneAppending : Bool = true) -> String {
@@ -345,7 +349,11 @@ extension NSString {
 
         let automount = "/var/automount"
         resolved = resolved._tryToRemovePathPrefix(automount) ?? resolved
+#if os(Windows)
+        return String(resolved.map { $0 == "\\" ? "/" : $0 })
+#else
         return resolved
+#endif
     }
 
     public var resolvingSymlinksInPath: String {

Foundation/NSURL.swift

@@ -32,7 +32,11 @@ private func _standardizedPath(_ path: String) -> String {
     if !path.absolutePath {
         return path._nsObject.standardizingPath
     }
+    #if os(Windows)
+    return String(path.map({$0 == "/" ? "\\" : $0}))
+    #else
     return path
+    #endif
 }
 
 internal func _pathComponents(_ path: String?) -> [String]? {
@@ -986,7 +990,7 @@ extension NSURL {
         }
 
         let absolutePath: String
-        if selfPath.hasPrefix("/") {
+        if selfPath.absolutePath {
             absolutePath = selfPath
         } else {
             let workingDir = FileManager.default.currentDirectoryPath

TestFoundation/TestFileManager.swift

@@ -447,13 +447,25 @@ class TestFileManager : XCTestCase {
             var foundItems = Set<String>()
             while let item = e.nextObject() as? String {
                 foundItems.insert(item)
+#if os(Windows)
+                if item == "item" {
+                    item1FileAttributes = e.fileAttributes
+                } else if item == "path2\\item" {
+                    item2FileAttributes = e.fileAttributes
+                }
+#else
                 if item == "item" {
                     item1FileAttributes = e.fileAttributes
                 } else if item == "path2/item" {
                     item2FileAttributes = e.fileAttributes
                 }
+#endif
             }
+#if os(Windows)
+            XCTAssertEqual(foundItems, Set(["item", "path2", "path2\\item"]))
+#else
             XCTAssertEqual(foundItems, Set(["item", "path2", "path2/item"]))
+#endif
         } else {
             XCTFail()
         }