[utils] swift-xcodegen: migrate to Swift Testing

Author: AnthonyLatsis

utils/swift-xcodegen/Tests/SwiftXcodeGenTest/CompileCommandsTests.swift

@@ -2,40 +2,45 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2024 Apple Inc. and the Swift project authors
+// Copyright (c) 2024 - 2025 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
 
-import XCTest
+import Testing
+
 @testable import SwiftXcodeGen
 
 fileprivate func assertParse(
-  _ str: String, executable: String? = nil, args: [Command.Argument],
+  _ str: String,
+  executable: String? = nil,
+  args: [Command.Argument],
   knownCommandOnly: Bool = false,
-  file: StaticString = #file, line: UInt = #line
+  sourceLocation: SourceLocation = #_sourceLocation
 ) {
   do {
     let command = try knownCommandOnly ? CommandParser.parseKnownCommandOnly(str)
                                        : CommandParser.parseCommand(str)
     guard let command else {
-      XCTFail("Failed to parse command")
+      Issue.record("Failed to parse command")
       return
     }
     if let executable {
-      XCTAssertEqual(executable, command.executable.rawPath, file: file, line: line)
+      #expect(executable == command.executable.rawPath, sourceLocation: sourceLocation)
     }
-    XCTAssertEqual(args, command.args, file: file, line: line)
+    #expect(args == command.args, sourceLocation: sourceLocation)
   } catch {
-    XCTFail("\(error)", file: file, line: line)
+    Issue.record("\(error)", sourceLocation: sourceLocation)
   }
 }
 
-class CompileCommandsTests: XCTestCase {
-  func testClangCommandParse() {
+@Suite
+struct CompileCommandsTests {
+  @Test
+  func clangCommandParse() {
     assertParse("x -a -b", executable: "x", args: [.value("-a"), .value("-b")])
 
     assertParse("x -D -I", executable: "x", args: [.value("-D"), .value("-I")])
@@ -194,7 +199,8 @@ class CompileCommandsTests: XCTestCase {
     )
   }
 
-  func testSwiftCommandParse() {
+  @Test
+  func swiftCommandParse() {
     assertParse(
       #"swiftc -FX"#,
       args: [.option(.F, spacing: .unspaced, value: "X")]
@@ -213,52 +219,56 @@ class CompileCommandsTests: XCTestCase {
     )
   }
 
-  func testCommandEscape() {
-    XCTAssertEqual(Command.Argument.flag(.I).printedArgs, ["-I"])
-    XCTAssertEqual(Command.Argument.value("hello").printedArgs, ["hello"])
-    XCTAssertEqual(Command.Argument.value("he llo").printedArgs, [#""he llo""#])
-    XCTAssertEqual(Command.Argument.value(#""hello""#).printedArgs, [#"\"hello\""#])
-    XCTAssertEqual(Command.Argument.value(#""he llo""#).printedArgs, [#""\"he llo\"""#])
+  @Test
+  func commandEscape() throws {
+    #expect(Command.Argument.flag(.I).printedArgs == ["-I"])
+    #expect(Command.Argument.value("hello").printedArgs == ["hello"])
+    #expect(Command.Argument.value("he llo").printedArgs == [#""he llo""#])
+    #expect(Command.Argument.value(#""hello""#).printedArgs == [#"\"hello\""#])
+    #expect(Command.Argument.value(#""he llo""#).printedArgs == [#""\"he llo\"""#])
 
-    XCTAssertEqual(
+    #expect(
       Command.Argument.option(
-        .I, spacing: .unspaced, value: "he llo"
-      ).printedArgs,
-      [#"-I"he llo""#]
+        .I,
+        spacing: .unspaced,
+        value: "he llo"
+      ).printedArgs == [#"-I"he llo""#]
     )
 
-    XCTAssertEqual(
+    #expect(
       Command.Argument.option(
-        .I, spacing: .spaced, value: "he llo"
-      ).printedArgs,
-      ["-I", #""he llo""#]
+        .I,
+        spacing: .spaced,
+        value: "he llo"
+      ).printedArgs == ["-I", #""he llo""#]
     )
 
-    XCTAssertEqual(
+    #expect(
       Command.Argument.option(
-        .I, spacing: .unspaced, value: #""he llo""#
-      ).printedArgs,
-      [#"-I"\"he llo\"""#]
+        .I,
+        spacing: .unspaced,
+        value: #""he llo""#
+      ).printedArgs == [#"-I"\"he llo\"""#]
     )
 
-    XCTAssertEqual(
+    #expect(
       Command.Argument.option(
-        .I, spacing: .spaced, value: #""he llo""#
-      ).printedArgs,
-      ["-I", #""\"he llo\"""#]
+        .I,
+        spacing: .spaced,
+        value: #""he llo""#
+      ).printedArgs == ["-I", #""\"he llo\"""#]
     )
 
-    XCTAssertEqual(
-      try CommandParser.parseCommand(#"swift \\ \ "#).printed,
-      #"swift \\ " ""#
+    #expect(
+      try CommandParser.parseCommand(#"swift \\ \ "#).printed == #"swift \\ " ""#
     )
-    XCTAssertEqual(
-      try CommandParser.parseCommand(#"swift "\\ ""#).printed,
-      #"swift "\\ ""#
+    #expect(
+      try CommandParser.parseCommand(#"swift "\\ ""#).printed == #"swift "\\ ""#
     )
   }
 
-  func testEmptyArg() {
+  @Test
+  func emptyArg() {
     // The empty string immediately after '-I' is effectively ignored.
     assertParse(#"swiftc -I"" """#, args: [
       .option(.I, spacing: .spaced, value: ""),
@@ -279,7 +289,8 @@ class CompileCommandsTests: XCTestCase {
     ])
   }
 
-  func testSpaceBeforeCommand() {
+  @Test
+  func spaceBeforeCommand() {
     assertParse("  swiftc  ", executable: "swiftc", args: [])
     assertParse("\t\tswiftc\t\ta b\t", executable: "swiftc", args: [
       .value("a"),

utils/swift-xcodegen/Tests/SwiftXcodeGenTest/NinjaParserTests.swift

@@ -2,52 +2,28 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2024 Apple Inc. and the Swift project authors
+// Copyright (c) 2024 - 2025 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
 
-import XCTest
-@testable import SwiftXcodeGen
+import Foundation
+import Testing
 
-fileprivate func expectEqual<T: Equatable>(
-  expected: [T], actual: [T], description: String,
-  file: StaticString = #file, line: UInt = #line
-) {
-  guard expected.count == actual.count else {
-    XCTFail(
-      """
-      Expected \(expected.count) '\(description)', \
-      got \(actual.count) (\(actual))
-      """,
-      file: file, line: line
-    )
-    return
-  }
-  for (expected, actual) in zip(expected, actual) {
-    XCTAssertEqual(expected, actual, file: file, line: line)
-  }
-}
-
-fileprivate func expectEqual<T, U: Equatable>(
-  _ expected: T, _ actual: T, _ kp: KeyPath<T, U>,
-  file: StaticString = #file, line: UInt = #line
-) {
-  XCTAssertEqual(
-    expected[keyPath: kp], actual[keyPath: kp], file: file, line: line
-  )
-}
+@testable import SwiftXcodeGen
 
 fileprivate func expectEqual<T, U: Equatable>(
-  _ expected: T, _ actual: T, _ kp: KeyPath<T, [U]>,
-  file: StaticString = #file, line: UInt = #line
+  _ expected: T,
+  _ actual: T,
+  _ kp: KeyPath<T, U>,
+  sourceLocation: SourceLocation = #_sourceLocation
 ) {
-  expectEqual(
-    expected: expected[keyPath: kp], actual: actual[keyPath: kp],
-    description: "\(kp)", file: file, line: line
+  #expect(
+    expected[keyPath: kp] == actual[keyPath: kp],
+    sourceLocation: sourceLocation
   )
 }
 
@@ -56,13 +32,20 @@ fileprivate func assertParse(
   bindings: [String: String] = [:],
   rules: [String: NinjaBuildFile.Rule] = [:],
   edges: [NinjaBuildFile.BuildEdge],
-  file: StaticString = #file, line: UInt = #line
+  sourceLocation: SourceLocation = #_sourceLocation
 ) {
   let filePath: AbsolutePath = "/tmp/build.ninja"
   let files: [AbsolutePath: String] = [
     filePath: str
   ]
-  assertParse(filePath, in: files, bindings: bindings, rules: rules, edges: edges, file: file, line: line)
+  assertParse(
+    filePath,
+    in: files,
+    bindings: bindings,
+    rules: rules,
+    edges: edges,
+    sourceLocation: sourceLocation
+  )
 }
 
 fileprivate func assertParse(
@@ -71,42 +54,43 @@ fileprivate func assertParse(
   bindings: [String: String] = [:],
   rules: [String: NinjaBuildFile.Rule] = [:],
   edges: [NinjaBuildFile.BuildEdge],
-  file: StaticString = #file, line: UInt = #line
+  sourceLocation: SourceLocation = #_sourceLocation
 ) {
   do {
     let buildFile = try NinjaParser.parse(filePath: filePath, fileReader: { Data(fileSystem[$0]!.utf8) })
     guard edges.count == buildFile.buildEdges.count else {
-      XCTFail(
+      Issue.record(
         "Expected \(edges.count) edges, got \(buildFile.buildEdges.count)",
-        file: file, line: line
+        sourceLocation: sourceLocation
       )
       return
     }
-    XCTAssertEqual(
-      bindings,
-      buildFile.bindings.values,
-      file: file, line: line
+    #expect(
+      bindings == buildFile.bindings.values,
+      sourceLocation: sourceLocation
     )
-    XCTAssertEqual(
-      rules, buildFile.rules,
-      file: file, line: line
+    #expect(
+      rules == buildFile.rules,
+      sourceLocation: sourceLocation
     )
     for (expected, actual) in zip(edges, buildFile.buildEdges) {
-      expectEqual(expected, actual, \.ruleName, file: file, line: line)
-      expectEqual(expected, actual, \.inputs, file: file, line: line)
-      expectEqual(expected, actual, \.outputs, file: file, line: line)
-      expectEqual(expected, actual,  \.dependencies, file: file, line: line)
-      expectEqual(expected, actual,  \.bindings, file: file, line: line)
+      expectEqual(expected, actual, \.ruleName, sourceLocation: sourceLocation)
+      expectEqual(expected, actual, \.inputs, sourceLocation: sourceLocation)
+      expectEqual(expected, actual, \.outputs, sourceLocation: sourceLocation)
+      expectEqual(expected, actual, \.dependencies, sourceLocation: sourceLocation)
+      expectEqual(expected, actual, \.bindings, sourceLocation: sourceLocation)
 
-      XCTAssertEqual(expected, actual, file: file, line: line)
+      #expect(expected == actual, sourceLocation: sourceLocation)
     }
   } catch {
-    XCTFail("\(error)", file: file, line: line)
+    Issue.record("\(error)", sourceLocation: sourceLocation)
   }
 }
 
-class NinjaParserTests: XCTestCase {
-  func testBuildEdge() throws {
+@Suite
+struct NinjaParserTests {
+  @Test
+  func buildEdge() throws {
     assertParse(
       """
       # ignore comment, build foo.o: a.swift | dep || orderdep
@@ -126,7 +110,8 @@ class NinjaParserTests: XCTestCase {
     )
   }
 
-  func testRule() throws {
+  @Test
+  func rule() throws {
     assertParse(
       """
       rule SWIFTC
@@ -146,7 +131,8 @@ class NinjaParserTests: XCTestCase {
     )
   }
 
-  func testInclude() throws {
+  @Test
+  func include() throws {
     let files: [AbsolutePath: String] = [
       "/tmp/build.ninja": """
         include path/to/sub.ninja
@@ -180,7 +166,8 @@ class NinjaParserTests: XCTestCase {
     )
   }
 
-  func testPhonyRule() throws {
+  @Test
+  func phonyRule() throws {
     assertParse(
       """
       build foo.swiftmodule : phony bar.swiftmodule
@@ -194,7 +181,8 @@ class NinjaParserTests: XCTestCase {
     )
   }
 
-  func testBindings() throws {
+  @Test
+  func bindings() throws {
     assertParse(
       """
       x = y
@@ -252,7 +240,8 @@ class NinjaParserTests: XCTestCase {
     )
   }
 
-  func testEscape() throws {
+  @Test
+  func escape() throws {
     for newline in ["\n", "\r", "\r\n"] {
       assertParse(
         """