Skip to content

Commit 3ff773d

Browse files
SencudraSencudra
committed
Rewrite template to Swift Testing
1 parent d9571e1 commit 3ff773d

File tree

2 files changed

+101
-71
lines changed

2 files changed

+101
-71
lines changed

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

Lines changed: 27 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -1,38 +1,45 @@
1-
import XCTest
2-
@testable import {{exercise|camelCase}}
3-
class {{exercise|camelCase}}Tests: XCTestCase {
4-
let runAll = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
1+
import Testing
2+
import Foundation
3+
@testable import {{exercise | camelCase}}
54

5+
let RUNALL = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
6+
7+
@Suite struct {{exercise | camelCase}}Tests {
68
{% outer: for case in cases %}
79
{%- for subCases in case.cases %}
810
{%- if forloop.outer.first and forloop.first %}
9-
func test{{subCases.description |camelCase }}() {
11+
@Test("{{subCases.description}}")
1012
{%- else %}
11-
func test{{subCases.description |camelCase }}() throws {
12-
try XCTSkipIf(true && !runAll) // change true to false to run this test
13+
@Test("{{subCases.description}}", .enabled(if: RUNALL))
1314
{%- endif %}
15+
func test{{subCases.description | camelCase}}() throws {
1416
{%- if subCases.property == "create" %}
1517
{%- if subCases.expected.error %}
16-
XCTAssertThrowsError(try Queen(row: {{subCases.input.queen.position.row}}, column: {{subCases.input.queen.position.column}})) { error in
17-
{%- if subCases.expected.error | contains:"row" %}
18-
XCTAssertEqual(error as? QueenError, .inValidRow)
19-
{%- else %}
20-
XCTAssertEqual(error as? QueenError, .inValidColumn)
21-
{%- endif %}
18+
{%- if subCases.expected.error | contains: "row" %}
19+
#expect(throws: QueenError.inValidRow)
20+
{%- else %}
21+
#expect(throws: QueenError.inValidColumn)
22+
{%- endif %}
23+
{
24+
try Queen(row: {{subCases.input.queen.position.row}}, column: {{subCases.input.queen.position.column}})
2225
}
2326
{%- else %}
24-
let queen = try! Queen(row: {{subCases.input.queen.position.row}}, column: {{subCases.input.queen.position.column}})
25-
XCTAssertEqual(queen.row, {{subCases.input.queen.position.row}})
26-
XCTAssertEqual(queen.column, {{subCases.input.queen.position.column}})
27+
#expect(throws: Never.self) {
28+
let queen = try Queen(row: {{subCases.input.queen.position.row}}, column: {{subCases.input.queen.position.column}})
29+
#expect(queen.row == {{subCases.input.queen.position.row}})
30+
#expect(queen.column == {{subCases.input.queen.position.column}})
31+
}
2732
{%- endif %}
2833
{%- else %}
29-
let queen = try! Queen(row: {{subCases.input.white_queen.position.row}}, column: {{subCases.input.white_queen.position.column}})
30-
let otherQueen = try! Queen(row: {{subCases.input.black_queen.position.row}}, column: {{subCases.input.black_queen.position.column}})
34+
#expect(throws: Never.self) {
35+
let queen = try Queen(row: {{subCases.input.white_queen.position.row}}, column: {{subCases.input.white_queen.position.column}})
36+
let otherQueen = try Queen(row: {{subCases.input.black_queen.position.row}}, column: {{subCases.input.black_queen.position.column}})
3137
{%- if subCases.expected %}
32-
XCTAssertTrue(queen.canAttack(other: otherQueen))
38+
#expect(queen.canAttack(other: otherQueen))
3339
{%- else %}
34-
XCTAssertFalse(queen.canAttack(other: otherQueen))
40+
#expect(!queen.canAttack(other: otherQueen))
3541
{%- endif %}
42+
}
3643
{%- endif %}
3744
}
3845
{% endfor -%}

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

Lines changed: 74 additions & 51 deletions
Original file line numberDiff line numberDiff line change
@@ -1,100 +1,123 @@
1-
import XCTest
1+
import Foundation
2+
import Testing
23

34
@testable import QueenAttack
45

5-
class QueenAttackTests: XCTestCase {
6-
let runAll = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
6+
let RUNALL = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
77

8-
func testQueenWithAValidPosition() {
9-
let queen = try! Queen(row: 2, column: 2)
10-
XCTAssertEqual(queen.row, 2)
11-
XCTAssertEqual(queen.column, 2)
8+
@Suite struct QueenAttackTests {
9+
10+
@Test("queen with a valid position")
11+
func testQueenWithAValidPosition() throws {
12+
#expect(throws: Never.self) {
13+
let queen = try Queen(row: 2, column: 2)
14+
#expect(queen.row == 2)
15+
#expect(queen.column == 2)
16+
}
1217
}
1318

19+
@Test("queen must have positive row", .enabled(if: RUNALL))
1420
func testQueenMustHavePositiveRow() throws {
15-
try XCTSkipIf(true && !runAll) // change true to false to run this test
16-
XCTAssertThrowsError(try Queen(row: -2, column: 2)) { error in
17-
XCTAssertEqual(error as? QueenError, .inValidRow)
21+
#expect(throws: QueenError.inValidRow) {
22+
try Queen(row: -2, column: 2)
1823
}
1924
}
2025

26+
@Test("queen must have row on board", .enabled(if: RUNALL))
2127
func testQueenMustHaveRowOnBoard() throws {
22-
try XCTSkipIf(true && !runAll) // change true to false to run this test
23-
XCTAssertThrowsError(try Queen(row: 8, column: 4)) { error in
24-
XCTAssertEqual(error as? QueenError, .inValidRow)
28+
#expect(throws: QueenError.inValidRow) {
29+
try Queen(row: 8, column: 4)
2530
}
2631
}
2732

33+
@Test("queen must have positive column", .enabled(if: RUNALL))
2834
func testQueenMustHavePositiveColumn() throws {
29-
try XCTSkipIf(true && !runAll) // change true to false to run this test
30-
XCTAssertThrowsError(try Queen(row: 2, column: -2)) { error in
31-
XCTAssertEqual(error as? QueenError, .inValidColumn)
35+
#expect(throws: QueenError.inValidColumn) {
36+
try Queen(row: 2, column: -2)
3237
}
3338
}
3439

40+
@Test("queen must have column on board", .enabled(if: RUNALL))
3541
func testQueenMustHaveColumnOnBoard() throws {
36-
try XCTSkipIf(true && !runAll) // change true to false to run this test
37-
XCTAssertThrowsError(try Queen(row: 4, column: 8)) { error in
38-
XCTAssertEqual(error as? QueenError, .inValidColumn)
42+
#expect(throws: QueenError.inValidColumn) {
43+
try Queen(row: 4, column: 8)
3944
}
4045
}
4146

47+
@Test("cannot attack", .enabled(if: RUNALL))
4248
func testCannotAttack() throws {
43-
try XCTSkipIf(true && !runAll) // change true to false to run this test
44-
let queen = try! Queen(row: 2, column: 4)
45-
let otherQueen = try! Queen(row: 6, column: 6)
46-
XCTAssertFalse(queen.canAttack(other: otherQueen))
49+
#expect(throws: Never.self) {
50+
let queen = try Queen(row: 2, column: 4)
51+
let otherQueen = try Queen(row: 6, column: 6)
52+
#expect(!queen.canAttack(other: otherQueen))
53+
}
4754
}
4855

56+
@Test("can attack on same row", .enabled(if: RUNALL))
4957
func testCanAttackOnSameRow() throws {
50-
try XCTSkipIf(true && !runAll) // change true to false to run this test
51-
let queen = try! Queen(row: 2, column: 4)
52-
let otherQueen = try! Queen(row: 2, column: 6)
53-
XCTAssertTrue(queen.canAttack(other: otherQueen))
58+
#expect(throws: Never.self) {
59+
let queen = try Queen(row: 2, column: 4)
60+
let otherQueen = try Queen(row: 2, column: 6)
61+
#expect(queen.canAttack(other: otherQueen))
62+
}
5463
}
5564

65+
@Test("can attack on same column", .enabled(if: RUNALL))
5666
func testCanAttackOnSameColumn() throws {
57-
try XCTSkipIf(true && !runAll) // change true to false to run this test
58-
let queen = try! Queen(row: 4, column: 5)
59-
let otherQueen = try! Queen(row: 2, column: 5)
60-
XCTAssertTrue(queen.canAttack(other: otherQueen))
67+
#expect(throws: Never.self) {
68+
let queen = try Queen(row: 4, column: 5)
69+
let otherQueen = try Queen(row: 2, column: 5)
70+
#expect(queen.canAttack(other: otherQueen))
71+
}
6172
}
6273

74+
@Test("can attack on first diagonal", .enabled(if: RUNALL))
6375
func testCanAttackOnFirstDiagonal() throws {
64-
try XCTSkipIf(true && !runAll) // change true to false to run this test
65-
let queen = try! Queen(row: 2, column: 2)
66-
let otherQueen = try! Queen(row: 0, column: 4)
67-
XCTAssertTrue(queen.canAttack(other: otherQueen))
76+
#expect(throws: Never.self) {
77+
let queen = try Queen(row: 2, column: 2)
78+
let otherQueen = try Queen(row: 0, column: 4)
79+
#expect(queen.canAttack(other: otherQueen))
80+
}
6881
}
6982

83+
@Test("can attack on second diagonal", .enabled(if: RUNALL))
7084
func testCanAttackOnSecondDiagonal() throws {
71-
try XCTSkipIf(true && !runAll) // change true to false to run this test
72-
let queen = try! Queen(row: 2, column: 2)
73-
let otherQueen = try! Queen(row: 3, column: 1)
74-
XCTAssertTrue(queen.canAttack(other: otherQueen))
85+
#expect(throws: Never.self) {
86+
let queen = try Queen(row: 2, column: 2)
87+
let otherQueen = try Queen(row: 3, column: 1)
88+
#expect(queen.canAttack(other: otherQueen))
89+
}
7590
}
7691

92+
@Test("can attack on third diagonal", .enabled(if: RUNALL))
7793
func testCanAttackOnThirdDiagonal() throws {
78-
try XCTSkipIf(true && !runAll) // change true to false to run this test
79-
let queen = try! Queen(row: 2, column: 2)
80-
let otherQueen = try! Queen(row: 1, column: 1)
81-
XCTAssertTrue(queen.canAttack(other: otherQueen))
94+
#expect(throws: Never.self) {
95+
let queen = try Queen(row: 2, column: 2)
96+
let otherQueen = try Queen(row: 1, column: 1)
97+
#expect(queen.canAttack(other: otherQueen))
98+
}
8299
}
83100

101+
@Test("can attack on fourth diagonal", .enabled(if: RUNALL))
84102
func testCanAttackOnFourthDiagonal() throws {
85-
try XCTSkipIf(true && !runAll) // change true to false to run this test
86-
let queen = try! Queen(row: 1, column: 7)
87-
let otherQueen = try! Queen(row: 0, column: 6)
88-
XCTAssertTrue(queen.canAttack(other: otherQueen))
103+
#expect(throws: Never.self) {
104+
let queen = try Queen(row: 1, column: 7)
105+
let otherQueen = try Queen(row: 0, column: 6)
106+
#expect(queen.canAttack(other: otherQueen))
107+
}
89108
}
90109

110+
@Test(
111+
"cannot attack if falling diagonals are only the same when reflected across the longest falling diagonal",
112+
.enabled(if: RUNALL))
91113
func
92114
testCannotAttackIfFallingDiagonalsAreOnlyTheSameWhenReflectedAcrossTheLongestFallingDiagonal()
93115
throws
94116
{
95-
try XCTSkipIf(true && !runAll) // change true to false to run this test
96-
let queen = try! Queen(row: 4, column: 1)
97-
let otherQueen = try! Queen(row: 2, column: 5)
98-
XCTAssertFalse(queen.canAttack(other: otherQueen))
117+
#expect(throws: Never.self) {
118+
let queen = try Queen(row: 4, column: 1)
119+
let otherQueen = try Queen(row: 2, column: 5)
120+
#expect(!queen.canAttack(other: otherQueen))
121+
}
99122
}
100123
}

0 commit comments

Comments
 (0)