Tests: Convert Basics/FileSystem/* to Swift Testing

Convert test from XCTest to Swift Testing.
  - Tests/BasicsTests/FileSystem/FileSystemTests.swift
  - Tests/BasicsTests/FileSystem/PathShimTests.swift
  - Tests/BasicsTests/FileSystem/PathTests.swift
  - Tests/BasicsTests/FileSystem/TemporaryFileTests.swift
  - Tests/BasicsTests/FileSystem/VFSTests.swift

relates to: swiftlang#8433

Author: bkhouri

Tests/BasicsTests/FileSystem/FileSystemTests.swift

@@ -9,13 +9,13 @@
 // See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
-
 @testable import Basics
 import TSCTestSupport
-import XCTest
+import Testing
 
-final class FileSystemTests: XCTestCase {
-    func testStripFirstLevelComponent() throws {
+struct FileSystemTests {
+    @Test
+    func stripFirstLevelComponent() throws {
         let fileSystem = InMemoryFileSystem()
 
         let rootPath = AbsolutePath("/root")
@@ -35,29 +35,31 @@ final class FileSystemTests: XCTestCase {
 
         do {
             let contents = try fileSystem.getDirectoryContents(.root)
-            XCTAssertEqual(contents.count, 1)
+            #expect(contents.count == 1)
         }
 
         try fileSystem.stripFirstLevel(of: .root)
 
         do {
             let contents = Set(try fileSystem.getDirectoryContents(.root))
-            XCTAssertEqual(contents.count, totalDirectories + totalFiles)
+            #expect(contents.count == totalDirectories + totalFiles)
 
             for index in 0 ..< totalDirectories {
-                XCTAssertTrue(contents.contains("dir\(index)"))
+                #expect(contents.contains("dir\(index)"))
             }
             for index in 0 ..< totalFiles {
-                XCTAssertTrue(contents.contains("file\(index)"))
+                #expect(contents.contains("file\(index)"))
             }
         }
     }
 
-    func testStripFirstLevelComponentErrors() throws {
+    @Test
+    func stripFirstLevelComponentErrors() throws {
+        let functionUnderTest = "stripFirstLevel"
         do {
             let fileSystem = InMemoryFileSystem()
-            XCTAssertThrowsError(try fileSystem.stripFirstLevel(of: .root), "expected error") { error in
-                XCTAssertMatch((error as? StringError)?.description, .contains("requires single top level directory"))
+            #expect(throws: StringError("\(functionUnderTest) requires single top level directory")) {
+                try fileSystem.stripFirstLevel(of: .root)
             }
         }
 
@@ -67,8 +69,8 @@ final class FileSystemTests: XCTestCase {
                 let path = AbsolutePath.root.appending("dir\(index)")
                 try fileSystem.createDirectory(path, recursive: false)
             }
-            XCTAssertThrowsError(try fileSystem.stripFirstLevel(of: .root), "expected error") { error in
-                XCTAssertMatch((error as? StringError)?.description, .contains("requires single top level directory"))
+            #expect(throws: StringError("\(functionUnderTest) requires single top level directory")) {
+                try fileSystem.stripFirstLevel(of: .root)
             }
         }
 
@@ -78,17 +80,17 @@ final class FileSystemTests: XCTestCase {
                 let path = AbsolutePath.root.appending("file\(index)")
                 try fileSystem.writeFileContents(path, string: "\(index)")
             }
-            XCTAssertThrowsError(try fileSystem.stripFirstLevel(of: .root), "expected error") { error in
-                XCTAssertMatch((error as? StringError)?.description, .contains("requires single top level directory"))
+            #expect(throws: StringError("\(functionUnderTest) requires single top level directory")) {
+                try fileSystem.stripFirstLevel(of: .root)
             }
         }
 
         do {
             let fileSystem = InMemoryFileSystem()
             let path = AbsolutePath.root.appending("file")
             try fileSystem.writeFileContents(path, string: "")
-            XCTAssertThrowsError(try fileSystem.stripFirstLevel(of: .root), "expected error") { error in
-                XCTAssertMatch((error as? StringError)?.description, .contains("requires single top level directory"))
+            #expect(throws: StringError("\(functionUnderTest) requires single top level directory")) {
+                try fileSystem.stripFirstLevel(of: .root)
             }
         }
     }

Tests/BasicsTests/FileSystem/PathShimTests.swift

@@ -12,64 +12,65 @@
 
 import Basics
 import Foundation
-import XCTest
+import Testing
 
-class PathShimTests: XCTestCase {
-    func testRescursiveDirectoryCreation() {
-        // For the tests we'll need a temporary directory.
+struct PathShimTests {
+    @Test
+    func rescursiveDirectoryCreation() {
         try! withTemporaryDirectory(removeTreeOnDeinit: true) { path in
             // Create a directory under several ancestor directories.
             let dirPath = path.appending(components: "abc", "def", "ghi", "mno", "pqr")
             try! makeDirectories(dirPath)
 
             // Check that we were able to actually create the directory.
-            XCTAssertTrue(localFileSystem.isDirectory(dirPath))
+            #expect(localFileSystem.isDirectory(dirPath))
 
             // Check that there's no error if we try to create the directory again.
-            try! makeDirectories(dirPath)
+            #expect(throws: Never.self) {
+                try! makeDirectories(dirPath)
+            }
         }
     }
 }
 
-class WalkTests: XCTestCase {
-    func testNonRecursive() throws {
-        #if os(Android)
+struct WalkTests {
+    @Test
+    func nonRecursive() throws {
+#if os(Android)
         let root = "/system"
         var expected: [AbsolutePath] = [
             "\(root)/usr",
             "\(root)/bin",
             "\(root)/etc",
         ]
-        #elseif os(Windows)
+        let expectedCount = 3
+#elseif os(Windows)
         let root = ProcessInfo.processInfo.environment["SystemRoot"]!
         var expected: [AbsolutePath] = [
             "\(root)/System32",
             "\(root)/SysWOW64",
         ]
-        #else
+        let expectedCount = (root as NSString).pathComponents.count + 2
+#else
         let root = ""
         var expected: [AbsolutePath] = [
             "/usr",
             "/bin",
             "/sbin",
         ]
-        #endif
+        let expectedCount = 2
+#endif
         for x in try walk(AbsolutePath(validating: "\(root)/"), recursively: false) {
             if let i = expected.firstIndex(of: x) {
                 expected.remove(at: i)
             }
-            #if os(Android)
-            XCTAssertEqual(3, x.components.count)
-            #elseif os(Windows)
-            XCTAssertEqual((root as NSString).pathComponents.count + 2, x.components.count)
-            #else
-            XCTAssertEqual(2, x.components.count)
-            #endif
+            #expect(x.components.count == expectedCount, "Actual is not as expected")
         }
-        XCTAssertEqual(expected.count, 0)
+        #expect(expected.count == 0)
     }
 
-    func testRecursive() {
+    @Test
+    func recursive() {
         let root = AbsolutePath(#file).parentDirectory.parentDirectory.parentDirectory.parentDirectory
             .appending(component: "Sources")
         var expected = [
@@ -82,6 +83,6 @@ class WalkTests: XCTestCase {
                 expected.remove(at: i)
             }
         }
-        XCTAssertEqual(expected, [])
+        #expect(expected == [])
     }
 }