Rewrite test template for Queen-Attack practise exercise to wotk with Swift Testing

exercises/practice/queen-attack/.meta/template.swift

@@ -1,38 +1,45 @@
-import XCTest
-@testable import {{exercise|camelCase}}
-class {{exercise|camelCase}}Tests: XCTestCase {
-    let runAll = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
+import Testing
+import Foundation
+@testable import {{exercise | camelCase}}
 
+let RUNALL = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
+
+@Suite struct {{exercise | camelCase}}Tests {
     {% outer: for case in cases %}
         {%- for subCases in case.cases %}
         {%- if forloop.outer.first and forloop.first %}
-            func test{{subCases.description |camelCase }}() {
+            @Test("{{subCases.description}}")
         {%- else %}
-            func test{{subCases.description |camelCase }}() throws {
-            try XCTSkipIf(true && !runAll) // change true to false to run this test
+            @Test("{{subCases.description}}", .enabled(if: RUNALL))
         {%- endif %}
+            func test{{subCases.description | camelCase}}() throws {
         {%- if subCases.property == "create" %}
             {%- if subCases.expected.error %}
-                XCTAssertThrowsError(try Queen(row: {{subCases.input.queen.position.row}}, column: {{subCases.input.queen.position.column}})) { error in
-                    {%- if subCases.expected.error | contains:"row"  %}
-                    XCTAssertEqual(error as? QueenError, .inValidRow)
-                    {%- else %}
-                    XCTAssertEqual(error as? QueenError, .inValidColumn)
-                    {%- endif %}
+                {%- if subCases.expected.error | contains: "row" %}
+                #expect(throws: QueenError.inValidRow)
+                {%- else %}
+                #expect(throws: QueenError.inValidColumn)
+                {%- endif %}
+                {
+                    try Queen(row: {{subCases.input.queen.position.row}}, column: {{subCases.input.queen.position.column}})
                 }
             {%- else %}
-                let queen = try! Queen(row: {{subCases.input.queen.position.row}}, column: {{subCases.input.queen.position.column}})
-                XCTAssertEqual(queen.row, {{subCases.input.queen.position.row}})
-                XCTAssertEqual(queen.column, {{subCases.input.queen.position.column}})
+                #expect(throws: Never.self) {
+                    let queen = try Queen(row: {{subCases.input.queen.position.row}}, column: {{subCases.input.queen.position.column}})
+                    #expect(queen.row == {{subCases.input.queen.position.row}})
+                    #expect(queen.column == {{subCases.input.queen.position.column}})
+                }
             {%- endif %}
         {%- else %}
-            let queen = try! Queen(row: {{subCases.input.white_queen.position.row}}, column: {{subCases.input.white_queen.position.column}})
-            let otherQueen = try! Queen(row: {{subCases.input.black_queen.position.row}}, column: {{subCases.input.black_queen.position.column}})
+            #expect(throws: Never.self) {
+                let queen = try Queen(row: {{subCases.input.white_queen.position.row}}, column: {{subCases.input.white_queen.position.column}})
+                let otherQueen = try Queen(row: {{subCases.input.black_queen.position.row}}, column: {{subCases.input.black_queen.position.column}})
             {%- if subCases.expected %}
-                XCTAssertTrue(queen.canAttack(other: otherQueen))
+                #expect(queen.canAttack(other: otherQueen))
             {%- else %}
-                XCTAssertFalse(queen.canAttack(other: otherQueen))
+                #expect(!queen.canAttack(other: otherQueen))
             {%- endif %}
+            }
         {%- endif %}
         }
         {% endfor -%}

exercises/practice/queen-attack/Tests/QueenAttackTests/QueenAttackTests.swift

@@ -1,100 +1,123 @@
-import XCTest
+import Foundation
+import Testing
 
 @testable import QueenAttack
 
-class QueenAttackTests: XCTestCase {
-  let runAll = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
+let RUNALL = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
 
-  func testQueenWithAValidPosition() {
-    let queen = try! Queen(row: 2, column: 2)
-    XCTAssertEqual(queen.row, 2)
-    XCTAssertEqual(queen.column, 2)
+@Suite struct QueenAttackTests {
+
+  @Test("queen with a valid position")
+  func testQueenWithAValidPosition() throws {
+    #expect(throws: Never.self) {
+      let queen = try Queen(row: 2, column: 2)
+      #expect(queen.row == 2)
+      #expect(queen.column == 2)
+    }
   }
 
+  @Test("queen must have positive row", .enabled(if: RUNALL))
   func testQueenMustHavePositiveRow() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertThrowsError(try Queen(row: -2, column: 2)) { error in
-      XCTAssertEqual(error as? QueenError, .inValidRow)
+    #expect(throws: QueenError.inValidRow) {
+      try Queen(row: -2, column: 2)
     }
   }
 
+  @Test("queen must have row on board", .enabled(if: RUNALL))
   func testQueenMustHaveRowOnBoard() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertThrowsError(try Queen(row: 8, column: 4)) { error in
-      XCTAssertEqual(error as? QueenError, .inValidRow)
+    #expect(throws: QueenError.inValidRow) {
+      try Queen(row: 8, column: 4)
     }
   }
 
+  @Test("queen must have positive column", .enabled(if: RUNALL))
   func testQueenMustHavePositiveColumn() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertThrowsError(try Queen(row: 2, column: -2)) { error in
-      XCTAssertEqual(error as? QueenError, .inValidColumn)
+    #expect(throws: QueenError.inValidColumn) {
+      try Queen(row: 2, column: -2)
     }
   }
 
+  @Test("queen must have column on board", .enabled(if: RUNALL))
   func testQueenMustHaveColumnOnBoard() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertThrowsError(try Queen(row: 4, column: 8)) { error in
-      XCTAssertEqual(error as? QueenError, .inValidColumn)
+    #expect(throws: QueenError.inValidColumn) {
+      try Queen(row: 4, column: 8)
     }
   }
 
+  @Test("cannot attack", .enabled(if: RUNALL))
   func testCannotAttack() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    let queen = try! Queen(row: 2, column: 4)
-    let otherQueen = try! Queen(row: 6, column: 6)
-    XCTAssertFalse(queen.canAttack(other: otherQueen))
+    #expect(throws: Never.self) {
+      let queen = try Queen(row: 2, column: 4)
+      let otherQueen = try Queen(row: 6, column: 6)
+      #expect(!queen.canAttack(other: otherQueen))
+    }
   }
 
+  @Test("can attack on same row", .enabled(if: RUNALL))
   func testCanAttackOnSameRow() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    let queen = try! Queen(row: 2, column: 4)
-    let otherQueen = try! Queen(row: 2, column: 6)
-    XCTAssertTrue(queen.canAttack(other: otherQueen))
+    #expect(throws: Never.self) {
+      let queen = try Queen(row: 2, column: 4)
+      let otherQueen = try Queen(row: 2, column: 6)
+      #expect(queen.canAttack(other: otherQueen))
+    }
   }
 
+  @Test("can attack on same column", .enabled(if: RUNALL))
   func testCanAttackOnSameColumn() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    let queen = try! Queen(row: 4, column: 5)
-    let otherQueen = try! Queen(row: 2, column: 5)
-    XCTAssertTrue(queen.canAttack(other: otherQueen))
+    #expect(throws: Never.self) {
+      let queen = try Queen(row: 4, column: 5)
+      let otherQueen = try Queen(row: 2, column: 5)
+      #expect(queen.canAttack(other: otherQueen))
+    }
   }
 
+  @Test("can attack on first diagonal", .enabled(if: RUNALL))
   func testCanAttackOnFirstDiagonal() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    let queen = try! Queen(row: 2, column: 2)
-    let otherQueen = try! Queen(row: 0, column: 4)
-    XCTAssertTrue(queen.canAttack(other: otherQueen))
+    #expect(throws: Never.self) {
+      let queen = try Queen(row: 2, column: 2)
+      let otherQueen = try Queen(row: 0, column: 4)
+      #expect(queen.canAttack(other: otherQueen))
+    }
   }
 
+  @Test("can attack on second diagonal", .enabled(if: RUNALL))
   func testCanAttackOnSecondDiagonal() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    let queen = try! Queen(row: 2, column: 2)
-    let otherQueen = try! Queen(row: 3, column: 1)
-    XCTAssertTrue(queen.canAttack(other: otherQueen))
+    #expect(throws: Never.self) {
+      let queen = try Queen(row: 2, column: 2)
+      let otherQueen = try Queen(row: 3, column: 1)
+      #expect(queen.canAttack(other: otherQueen))
+    }
   }
 
+  @Test("can attack on third diagonal", .enabled(if: RUNALL))
   func testCanAttackOnThirdDiagonal() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    let queen = try! Queen(row: 2, column: 2)
-    let otherQueen = try! Queen(row: 1, column: 1)
-    XCTAssertTrue(queen.canAttack(other: otherQueen))
+    #expect(throws: Never.self) {
+      let queen = try Queen(row: 2, column: 2)
+      let otherQueen = try Queen(row: 1, column: 1)
+      #expect(queen.canAttack(other: otherQueen))
+    }
   }
 
+  @Test("can attack on fourth diagonal", .enabled(if: RUNALL))
   func testCanAttackOnFourthDiagonal() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    let queen = try! Queen(row: 1, column: 7)
-    let otherQueen = try! Queen(row: 0, column: 6)
-    XCTAssertTrue(queen.canAttack(other: otherQueen))
+    #expect(throws: Never.self) {
+      let queen = try Queen(row: 1, column: 7)
+      let otherQueen = try Queen(row: 0, column: 6)
+      #expect(queen.canAttack(other: otherQueen))
+    }
   }
 
+  @Test(
+    "cannot attack if falling diagonals are only the same when reflected across the longest falling diagonal",
+    .enabled(if: RUNALL))
   func
     testCannotAttackIfFallingDiagonalsAreOnlyTheSameWhenReflectedAcrossTheLongestFallingDiagonal()
     throws
   {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    let queen = try! Queen(row: 4, column: 1)
-    let otherQueen = try! Queen(row: 2, column: 5)
-    XCTAssertFalse(queen.canAttack(other: otherQueen))
+    #expect(throws: Never.self) {
+      let queen = try Queen(row: 4, column: 1)
+      let otherQueen = try Queen(row: 2, column: 5)
+      #expect(!queen.canAttack(other: otherQueen))
+    }
   }
 }