Use swift-testing instead

Tests/SGFKitTests/Game/Go/GoCollectionTests.swift

@@ -1,75 +1,86 @@
 @testable import SGFKit
-import XCTest
+import Testing
 
-final class GoCollectionTests: XCTestCase {
+@Suite
+struct GoCollectionTests {
 
-    func testAddProperty() throws {
+    @Test
+    func addProperty() throws {
         let go = try Go(input: "(;FF[4];B[ab];B[ba])")
         let rootNode = go.tree.nodes[0]
         let node = rootNode.children[0] // ;B[ab]
 
         let point = GoPoint(column: 2, row: 28)
         node.addProperty(point, to: .black) // bB
-        XCTAssertEqual(node.propertyValue(of: .black), point)
+        #expect(node.propertyValue(of: .black) == point)
 
-        XCTAssertEqual(go.tree.convertToSGF(), "(;FF[4];B[bB];B[ba])")
+        #expect(go.tree.convertToSGF() == "(;FF[4];B[bB];B[ba])")
     }
 
-    func testRemoveProperty() throws {
+    @Test
+    func removeProperty() throws {
         let go = try Go(input: "(;FF[4];B[ab]C[a];B[ba])")
         let rootNode = go.tree.nodes[0]
         let node = rootNode.children[0] // ;B[ab]C[a]
-        XCTAssertEqual(node.propertyValue(of: .comment), "a")
+        #expect(node.propertyValue(of: .comment) == "a")
 
         node.removeProperty(of: .comment)
-        XCTAssertNil(node.propertyValue(of: .comment))
-        XCTAssertFalse(node.has(.comment))
-        XCTAssertEqual(go.tree.convertToSGF(), "(;FF[4];B[ab];B[ba])")
+        #expect(node.propertyValue(of: .comment) == nil)
+        #expect(!node.has(.comment))
+        #expect(go.tree.convertToSGF() == "(;FF[4];B[ab];B[ba])")
     }
 
-    func testAddNewNode() throws {
+    @Test
+    func addNewNode() throws {
         let go = try Go(input: "(;FF[4];B[ab];B[ba])")
         let rootNode = go.tree.nodes[0]
         let node = rootNode.children[0] // ;B[ab]
         node.children.append(Node(properties: [Property(identifier: "B", values: [.single("cc")])]))
 
-        XCTAssertEqual(go.tree.nodes[0].number, 0)
-        XCTAssertEqual(go.tree.nodes[0].children[0].number, 1)
-        XCTAssertEqual(go.tree.nodes[0].children[0].children[0].number, 2)
-        XCTAssertEqual(go.tree.nodes[0].children[0].children[1].number, 3)
-        XCTAssertEqual(go.tree.convertToSGF(), "(;FF[4];B[ab](;B[ba])(;B[cc]))")
+        #expect(go.tree.nodes[0].number == 0)
+        #expect(go.tree.nodes[0].children[0].number == 1)
+        #expect(go.tree.nodes[0].children[0].children[0].number == 2)
+        #expect(go.tree.nodes[0].children[0].children[1].number == 3)
+        #expect(go.tree.convertToSGF() == "(;FF[4];B[ab](;B[ba])(;B[cc]))")
     }
 
-    func testRemoveNode() throws {
+    @Test
+    func removeNode() throws {
         let go = try Go(input: "(;FF[4];B[ab];B[ba])")
         let rootNode = go.tree.nodes[0]
         let node = rootNode.children[0] // ;B[ab]
+#if compiler(>=6.2)
+        weak let childNode = node.children.first // ;B[ba]
+#else
         weak var childNode = node.children.first // ;B[ba]
+#endif
         node.children.removeAll()
 
-        XCTAssertEqual(go.tree.nodes[0].number, 0)
-        XCTAssertEqual(go.tree.nodes[0].children[0].number, 1)
-        XCTAssertEqual(go.tree.convertToSGF(), "(;FF[4];B[ab])")
-        XCTAssertNil(childNode)
+        #expect(go.tree.nodes[0].number == 0)
+        #expect(go.tree.nodes[0].children[0].number == 1)
+        #expect(go.tree.convertToSGF() == "(;FF[4];B[ab])")
+        #expect(childNode == nil)
     }
 
-    func testCopyNode() throws {
+    @Test
+    func copyNode() throws {
         let go = try Go(input: "(;FF[4];B[ab];B[ba])")
         let rootNode = go.tree.nodes[0]
         let node = rootNode.children[0] // ;B[ab]
 
         let copiedNode = node.copy()
-        XCTAssertTrue(copiedNode !== node)
-        XCTAssertEqual(copiedNode.propertyValue(of: .black), GoPoint(column: 1, row: 2))
-        XCTAssertEqual(copiedNode.children[0].propertyValue(of: .black), GoPoint(column: 2, row: 1))
+        #expect(copiedNode !== node)
+        #expect(copiedNode.propertyValue(of: .black) == GoPoint(column: 1, row: 2))
+        #expect(copiedNode.children[0].propertyValue(of: .black) == GoPoint(column: 2, row: 1))
     }
 
-    func testCopyCollection() throws {
+    @Test
+    func copyCollection() throws {
         let go = try Go(input: "(;FF[4];B[ab];B[ba])")
         let collection = go.tree
         let copiedCollection = collection.copy()
 
-        XCTAssertTrue(copiedCollection !== collection)
-        XCTAssertEqual(copiedCollection.convertToSGF(), "(;FF[4];B[ab];B[ba])")
+        #expect(copiedCollection !== collection)
+        #expect(copiedCollection.convertToSGF() == "(;FF[4];B[ab];B[ba])")
     }
 }

Tests/SGFKitTests/Game/Go/GoTests.swift

@@ -1,101 +1,109 @@
 @testable import SGFKit
-import XCTest
+import Testing
 
-final class GoTests: XCTestCase {
+@Suite
+struct GoTests {
 
-    func testProperty() throws {
+    @Test
+    func property() throws {
         let go = try Go(input: "(;FF[4](;B[ab];B[ba]))")
 
         let node1 = go.tree.nodes[0].children[0]
         let result1 = node1.propertyValue(of: .black)
-        XCTAssertEqual(result1, GoPoint(column: 1, row: 2))
+        #expect(result1 == GoPoint(column: 1, row: 2))
 
         let node2 = node1.children[0]
         let result2 = node2.propertyValue(of: .black)
-        XCTAssertEqual(result2, GoPoint(column: 2, row: 1))
+        #expect(result2 == GoPoint(column: 2, row: 1))
     }
 
-    func testGoSpecificProperty() throws {
+    @Test
+    func goSpecificProperty() throws {
         let go = try Go(input: "(;FF[4]KM[6.5](;B[ab];B[ba]))")
-        XCTAssertEqual(go.tree.nodes[0].propertyValue(of: .komi), 6.5)
+        #expect(go.tree.nodes[0].propertyValue(of: .komi) == 6.5)
     }
 
-    func testNoneProperty()  throws {
+    @Test
+    func noneProperty()  throws {
         let go = try Go(input: "(;FF[4](;B[ab]DO[];B[ba]))")
 
         let node1 = go.tree.nodes[0].children[0] // ;B[ab]DO[]
-        XCTAssertEqual(node1.propertyValue(of: .doubtful), SGFNone.none)
-        XCTAssertTrue(node1.has(.doubtful))
+        #expect(node1.propertyValue(of: .doubtful) == SGFNone.none)
+        #expect(node1.has(.doubtful))
 
         let node2 = node1.children[0] // ;B[ba]
-        XCTAssertNil(node2.propertyValue(of: .doubtful))
-        XCTAssertFalse(node2.has(.doubtful))
+        #expect(node2.propertyValue(of: .doubtful) == nil)
+        #expect(!node2.has(.doubtful))
     }
 
-    func testComplexBranch()  throws {
+    @Test
+    func complexBranch()  throws {
         let input = "(;FF[4]C[root](;C[a];C[b](;C[c])(;C[d];C[e]))(;C[f](;C[g];C[h];C[i])(;C[j])))"
         let go = try Go(input: input)
         let tree = go.tree
 
         let rootNode = tree.nodes[0] // ";FF[4]C[root]"
-        XCTAssertEqual(rootNode.propertyValue(of: .fileFormat), 4)
-        XCTAssertEqual(rootNode.propertyValue(of: .comment), "root")
-        XCTAssertEqual(rootNode.number, 0)
-        XCTAssertEqual(rootNode.children.count, 2)
-        XCTAssertEqual(rootNode.parent?.number, tree.number)
+        #expect(rootNode.propertyValue(of: .fileFormat) == 4)
+        #expect(rootNode.propertyValue(of: .comment) == "root")
+        #expect(rootNode.number == 0)
+        #expect(rootNode.children.count == 2)
+        #expect(rootNode.parent?.number == tree.number)
 
         let nodeA = rootNode.children[0] // ;C[a]
-        XCTAssertEqual(nodeA.propertyValue(of: .comment), "a")
-        XCTAssertEqual(nodeA.children.count, 1)
-        XCTAssertEqual(nodeA.number, 1)
-        XCTAssertEqual(nodeA.parent?.number, rootNode.number)
+        #expect(nodeA.propertyValue(of: .comment) == "a")
+        #expect(nodeA.children.count == 1)
+        #expect(nodeA.number == 1)
+        #expect(nodeA.parent?.number == rootNode.number)
 
         let nodeB = nodeA.children[0] // ;C[b]
-        XCTAssertEqual(nodeB.propertyValue(of: .comment), "b")
-        XCTAssertEqual(nodeB.children.count, 2)
-        XCTAssertEqual(nodeB.number, 2)
-        XCTAssertEqual(nodeB.parent?.number, nodeA.number)
+        #expect(nodeB.propertyValue(of: .comment) == "b")
+        #expect(nodeB.children.count == 2)
+        #expect(nodeB.number == 2)
+        #expect(nodeB.parent?.number == nodeA.number)
 
         let nodeC = nodeB.children[0] // ;C[c]
-        XCTAssertEqual(nodeC.propertyValue(of: .comment), "c")
-        XCTAssertEqual(nodeC.children.count, 0)
-        XCTAssertEqual(nodeC.number, 3)
-        XCTAssertEqual(nodeC.parent?.number, nodeB.number)
+        #expect(nodeC.propertyValue(of: .comment) == "c")
+        #expect(nodeC.children.count == 0)
+        #expect(nodeC.number == 3)
+        #expect(nodeC.parent?.number == nodeB.number)
 
         let nodeD = nodeB.children[1] // ;C[d]
-        XCTAssertEqual(nodeD.propertyValue(of: .comment), "d")
-        XCTAssertEqual(nodeD.children.count, 1)
-        XCTAssertEqual(nodeD.number, 4)
-        XCTAssertEqual(nodeD.parent?.number, nodeB.number)
+        #expect(nodeD.propertyValue(of: .comment) == "d")
+        #expect(nodeD.children.count == 1)
+        #expect(nodeD.number == 4)
+        #expect(nodeD.parent?.number == nodeB.number)
 
         let nodeE = nodeD.children[0] // ;C[e]
-        XCTAssertEqual(nodeE.propertyValue(of: .comment), "e")
-        XCTAssertEqual(nodeE.children.count, 0)
-        XCTAssertEqual(nodeE.number, 5)
-        XCTAssertEqual(nodeE.parent?.number, nodeD.number)
+        #expect(nodeE.propertyValue(of: .comment) == "e")
+        #expect(nodeE.children.count == 0)
+        #expect(nodeE.number == 5)
+        #expect(nodeE.parent?.number == nodeD.number)
     }
 
-    func testInherit() throws {
+    @Test
+    func inherit() throws {
         let go = try Go(input: "(;FF[4](;B[ab];B[ba]PM[3];B[c1]))")
         let node1 = go.tree.nodes[0].children[0] // ;B[ab]
-        XCTAssertNil(node1.propertyValue(of: .printMoveMode))
+        #expect(node1.propertyValue(of: .printMoveMode) == nil)
 
         let node2 = node1.children[0] // ;B[ba]PM[3]
-        XCTAssertEqual(node2.propertyValue(of: .printMoveMode), 3)
+        #expect(node2.propertyValue(of: .printMoveMode) == 3)
 
         let node3 = node2.children[0] // B[c1])
-        XCTAssertEqual(node3.propertyValue(of: .printMoveMode), 3)
+        #expect(node3.propertyValue(of: .printMoveMode) == 3)
     }
 
-    func testConvertToSGF() throws {
+    @Test
+    func convertToSGF() throws {
         let input = "(;FF[4]C[root](;C[a];C[b](;C[c])(;C[d];C[e]))(;C[f](;C[g];C[h];C[i])(;C[j])))"
         let go = try Go(input: input)
-        XCTAssertEqual(go.tree.convertToSGF(), input)
+        #expect(go.tree.convertToSGF() == input)
     }
 
-    func testConvertToSGFWithEscaping() throws {
+    @Test
+    func convertToSGFWithEscaping() throws {
         let input = "(;FF[4]C[¥]¥:¥\\foo])"
         let go = try Go(input: input)
-        XCTAssertEqual(go.tree.convertToSGF(), input)
+        #expect(go.tree.convertToSGF() == input)
     }
 }

Tests/SGFKitTests/LexerTests.swift

@@ -1,9 +1,11 @@
 @testable import SGFKit
-import XCTest
+import Testing
 
-final class LexerTests: XCTestCase {
+@Suite
+struct LexerTests {
 
-    func testSimpleCase() throws {
+    @Test
+    func simpleCase() throws {
         let input = """
         (;FF[4]C[root](;C[a];C[b](;C[c])
         (;C[d];C[e]))
@@ -12,7 +14,7 @@ final class LexerTests: XCTestCase {
         """
         let tokens = try Lexer(input: input).tokenize()
         let kinds = tokens.map { $0.kind }
-        XCTAssertEqual(kinds, [
+        #expect(kinds == [
             .leftParenthesis,   // (
             .semicolon,         // ;
             .identifier("FF"),  // FF

Tests/SGFKitTests/ParserTests.swift

@@ -1,9 +1,11 @@
 @testable import SGFKit
-import XCTest
+import Testing
 
-final class GoParserTests: XCTestCase {
+@Suite
+struct GoParserTests {
 
-    func testParseForSimpleCase() throws {
+    @Test
+    func parseForSimpleCase() throws {
         let input = """
         (;FF[4]C[root](;C[a];C[b](;C[c])
         (;C[d];C[e]))
@@ -79,10 +81,11 @@ final class GoParserTests: XCTestCase {
                 )
             ]
         )
-        XCTAssertEqual(collection, expected)
+        #expect(collection == expected)
     }
 
-    func testConvertToSGF() throws {
+    @Test
+    func convertToSGF() throws {
         let input = """
         (;FF[4]C[root](;C[a];C[b](;C[c])
         (;C[d];C[e]))
@@ -91,9 +94,8 @@ final class GoParserTests: XCTestCase {
         """
         let collection = try Parser.parse(input: input)
 
-        XCTAssertEqual(
-            collection.convertToSGF(),
-            "(;FF[4]C[root](;C[a];C[b](;C[c])(;C[d];C[e]))(;C[f](;C[g];C[h];C[i])(;C[j])))"
+        #expect(
+            collection.convertToSGF() == "(;FF[4]C[root](;C[a];C[b](;C[c])(;C[d];C[e]))(;C[f](;C[g];C[h];C[i])(;C[j])))"
         )
     }
 }