diff --git a/exercises/practice/largest-series-product/.meta/template.swift b/exercises/practice/largest-series-product/.meta/template.swift
index 0e87b4e4b..e660aa6d6 100644
--- a/exercises/practice/largest-series-product/.meta/template.swift
+++ b/exercises/practice/largest-series-product/.meta/template.swift
@@ -1,27 +1,29 @@
-import XCTest
+import Testing
+import Foundation
 @testable import {{exercise|camelCase}}
-class {{exercise|camelCase}}Tests: XCTestCase {
-    let runAll = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
 
+let RUNALL = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
+
+@Suite struct {{exercise|camelCase}}Tests {
     {% for case in cases %}
     {% if forloop.first -%}
-        func test{{case.description |camelCase }}() {
+        @Test("{{case.description}}")
     {% else -%}
-        func test{{case.description |camelCase }}() throws {
-        try XCTSkipIf(true && !runAll) // change true to false to run this test
+        @Test("{{case.description}}", .enabled(if: RUNALL))
     {% endif -%}
+    func test{{case.description |camelCase }}() {
     {% if case.expected.error -%}
-        XCTAssertThrowsError(try NumberSeries("{{case.input.digits}}").largestProduct({{case.input.span}})) { error in
+        #expect(throws: 
         {% if case.expected.error == "span must be smaller than string length" -%}
-            XCTAssertEqual(error as? NumberSeriesError, NumberSeriesError.spanLongerThanInput)
+            NumberSeriesError.spanLongerThanInput
         {% elif case.expected.error == "digits input must only contain digits" -%}
-            XCTAssertEqual(error as? NumberSeriesError, NumberSeriesError.invalidCharacter)
+            NumberSeriesError.invalidCharacter
         {% else -%}
-            XCTAssertEqual(error as? NumberSeriesError, NumberSeriesError.spanIsZeroOrNegative)
+            NumberSeriesError.spanIsZeroOrNegative
         {% endif -%}
-        }
+        ) {try NumberSeries("{{case.input.digits}}").largestProduct({{case.input.span}})}
     {% else -%}
-        XCTAssertEqual(try! NumberSeries("{{case.input.digits}}").largestProduct({{case.input.span}}), {{case.expected}})
+        #expect(try! NumberSeries("{{case.input.digits}}").largestProduct({{case.input.span}}) == {{case.expected}})
     {% endif -%}
     }
     {% endfor -%}
diff --git a/exercises/practice/largest-series-product/Package.swift b/exercises/practice/largest-series-product/Package.swift
index c95bab77d..aa7a408b3 100644
--- a/exercises/practice/largest-series-product/Package.swift
+++ b/exercises/practice/largest-series-product/Package.swift
@@ -1,4 +1,4 @@
-// swift-tools-version:5.3
+// swift-tools-version:6.0
 
 import PackageDescription
 
diff --git a/exercises/practice/largest-series-product/Tests/LargestSeriesProductTests/LargestSeriesProductTests.swift b/exercises/practice/largest-series-product/Tests/LargestSeriesProductTests/LargestSeriesProductTests.swift
index dcb81a330..c44a13d96 100644
--- a/exercises/practice/largest-series-product/Tests/LargestSeriesProductTests/LargestSeriesProductTests.swift
+++ b/exercises/practice/largest-series-product/Tests/LargestSeriesProductTests/LargestSeriesProductTests.swift
@@ -1,81 +1,88 @@
-import XCTest
+import Foundation
+import Testing
 
 @testable import LargestSeriesProduct
 
-class LargestSeriesProductTests: XCTestCase {
-  let runAll = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
+let RUNALL = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
 
+@Suite struct LargestSeriesProductTests {
+
+  @Test("finds the largest product if span equals length")
   func testFindsTheLargestProductIfSpanEqualsLength() {
-    XCTAssertEqual(try! NumberSeries("29").largestProduct(2), 18)
+    #expect(try! NumberSeries("29").largestProduct(2) == 18)
   }
 
-  func testCanFindTheLargestProductOf2WithNumbersInOrder() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertEqual(try! NumberSeries("0123456789").largestProduct(2), 72)
+  @Test("can find the largest product of 2 with numbers in order", .enabled(if: RUNALL))
+  func testCanFindTheLargestProductOf2WithNumbersInOrder() {
+    #expect(try! NumberSeries("0123456789").largestProduct(2) == 72)
   }
 
-  func testCanFindTheLargestProductOf2() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertEqual(try! NumberSeries("576802143").largestProduct(2), 48)
+  @Test("can find the largest product of 2", .enabled(if: RUNALL))
+  func testCanFindTheLargestProductOf2() {
+    #expect(try! NumberSeries("576802143").largestProduct(2) == 48)
   }
 
-  func testCanFindTheLargestProductOf3WithNumbersInOrder() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertEqual(try! NumberSeries("0123456789").largestProduct(3), 504)
+  @Test("can find the largest product of 3 with numbers in order", .enabled(if: RUNALL))
+  func testCanFindTheLargestProductOf3WithNumbersInOrder() {
+    #expect(try! NumberSeries("0123456789").largestProduct(3) == 504)
   }
 
-  func testCanFindTheLargestProductOf3() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertEqual(try! NumberSeries("1027839564").largestProduct(3), 270)
+  @Test("can find the largest product of 3", .enabled(if: RUNALL))
+  func testCanFindTheLargestProductOf3() {
+    #expect(try! NumberSeries("1027839564").largestProduct(3) == 270)
   }
 
-  func testCanFindTheLargestProductOf5WithNumbersInOrder() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertEqual(try! NumberSeries("0123456789").largestProduct(5), 15120)
+  @Test("can find the largest product of 5 with numbers in order", .enabled(if: RUNALL))
+  func testCanFindTheLargestProductOf5WithNumbersInOrder() {
+    #expect(try! NumberSeries("0123456789").largestProduct(5) == 15120)
   }
 
-  func testCanGetTheLargestProductOfABigNumber() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertEqual(
-      try! NumberSeries("73167176531330624919225119674426574742355349194934").largestProduct(6),
-      23520)
+  @Test("can get the largest product of a big number", .enabled(if: RUNALL))
+  func testCanGetTheLargestProductOfABigNumber() {
+    #expect(
+      try! NumberSeries("73167176531330624919225119674426574742355349194934").largestProduct(6)
+        == 23520)
   }
 
-  func testReportsZeroIfTheOnlyDigitsAreZero() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertEqual(try! NumberSeries("0000").largestProduct(2), 0)
+  @Test("reports zero if the only digits are zero", .enabled(if: RUNALL))
+  func testReportsZeroIfTheOnlyDigitsAreZero() {
+    #expect(try! NumberSeries("0000").largestProduct(2) == 0)
   }
 
-  func testReportsZeroIfAllSpansIncludeZero() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertEqual(try! NumberSeries("99099").largestProduct(3), 0)
+  @Test("reports zero if all spans include zero", .enabled(if: RUNALL))
+  func testReportsZeroIfAllSpansIncludeZero() {
+    #expect(try! NumberSeries("99099").largestProduct(3) == 0)
   }
 
-  func testRejectsSpanLongerThanStringLength() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertThrowsError(try NumberSeries("123").largestProduct(4)) { error in
-      XCTAssertEqual(error as? NumberSeriesError, NumberSeriesError.spanLongerThanInput)
-    }
+  @Test("rejects span longer than string length", .enabled(if: RUNALL))
+  func testRejectsSpanLongerThanStringLength() {
+    #expect(
+      throws:
+        NumberSeriesError.spanLongerThanInput
+    ) { try NumberSeries("123").largestProduct(4) }
   }
 
-  func testRejectsEmptyStringAndNonzeroSpan() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertThrowsError(try NumberSeries("").largestProduct(1)) { error in
-      XCTAssertEqual(error as? NumberSeriesError, NumberSeriesError.spanLongerThanInput)
-    }
+  @Test("rejects empty string and nonzero span", .enabled(if: RUNALL))
+  func testRejectsEmptyStringAndNonzeroSpan() {
+    #expect(
+      throws:
+        NumberSeriesError.spanLongerThanInput
+    ) { try NumberSeries("").largestProduct(1) }
   }
 
-  func testRejectsInvalidCharacterInDigits() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertThrowsError(try NumberSeries("1234a5").largestProduct(2)) { error in
-      XCTAssertEqual(error as? NumberSeriesError, NumberSeriesError.invalidCharacter)
-    }
+  @Test("rejects invalid character in digits", .enabled(if: RUNALL))
+  func testRejectsInvalidCharacterInDigits() {
+    #expect(
+      throws:
+        NumberSeriesError.invalidCharacter
+    ) { try NumberSeries("1234a5").largestProduct(2) }
   }
 
-  func testRejectsNegativeSpan() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertThrowsError(try NumberSeries("12345").largestProduct(-1)) { error in
-      XCTAssertEqual(error as? NumberSeriesError, NumberSeriesError.spanIsZeroOrNegative)
-    }
+  @Test("rejects negative span", .enabled(if: RUNALL))
+  func testRejectsNegativeSpan() {
+    #expect(
+      throws:
+        NumberSeriesError.spanIsZeroOrNegative
+    ) { try NumberSeries("12345").largestProduct(-1) }
   }
 }
diff --git a/exercises/practice/leap/.meta/template.swift b/exercises/practice/leap/.meta/template.swift
index 27e8ab25b..ac99fd421 100644
--- a/exercises/practice/leap/.meta/template.swift
+++ b/exercises/practice/leap/.meta/template.swift
@@ -1,20 +1,22 @@
-import XCTest
+import Testing
+import Foundation
 @testable import {{exercise|camelCase}}
-class {{exercise|camelCase}}Tests: XCTestCase {
-    let runAll = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
 
+let RUNALL = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
+
+@Suite struct {{exercise|camelCase}}Tests {
     {% for case in cases %}
     {% if forloop.first -%}
-        func test{{case.description |camelCase }}() {
+        @Test("{{case.description}}")
     {% else -%}
-        func test{{case.description |camelCase }}() throws {
-        try XCTSkipIf(true && !runAll) // change true to false to run this test
+        @Test("{{case.description}}", .enabled(if: RUNALL))
     {% endif -%}
+    func test{{case.description |camelCase }}() {
         let year = Year(calendarYear: {{case.input.year}})
         {% if case.expected -%}
-        XCTAssertTrue(year.isLeapYear)
+        #expect(year.isLeapYear)
         {% else -%}
-        XCTAssertFalse(year.isLeapYear)
+        #expect(!year.isLeapYear)
         {% endif -%}
     }
     {% endfor -%}
diff --git a/exercises/practice/leap/Package.swift b/exercises/practice/leap/Package.swift
index 5b0fa8d46..2b43dcdce 100644
--- a/exercises/practice/leap/Package.swift
+++ b/exercises/practice/leap/Package.swift
@@ -1,4 +1,4 @@
-// swift-tools-version:5.3
+// swift-tools-version:6.0
 
 import PackageDescription
 
diff --git a/exercises/practice/leap/Tests/LeapTests/LeapTests.swift b/exercises/practice/leap/Tests/LeapTests/LeapTests.swift
index 649f0f0c9..505d03db0 100644
--- a/exercises/practice/leap/Tests/LeapTests/LeapTests.swift
+++ b/exercises/practice/leap/Tests/LeapTests/LeapTests.swift
@@ -1,60 +1,63 @@
-import XCTest
+import Foundation
+import Testing
 
 @testable import Leap
 
-class LeapTests: XCTestCase {
-  let runAll = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
+let RUNALL = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
 
+@Suite struct LeapTests {
+
+  @Test("year not divisible by 4 in common year")
   func testYearNotDivisibleBy4InCommonYear() {
     let year = Year(calendarYear: 2015)
-    XCTAssertFalse(year.isLeapYear)
+    #expect(!year.isLeapYear)
   }
 
-  func testYearDivisibleBy2NotDivisibleBy4InCommonYear() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
+  @Test("year divisible by 2, not divisible by 4 in common year", .enabled(if: RUNALL))
+  func testYearDivisibleBy2NotDivisibleBy4InCommonYear() {
     let year = Year(calendarYear: 1970)
-    XCTAssertFalse(year.isLeapYear)
+    #expect(!year.isLeapYear)
   }
 
-  func testYearDivisibleBy4NotDivisibleBy100InLeapYear() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
+  @Test("year divisible by 4, not divisible by 100 in leap year", .enabled(if: RUNALL))
+  func testYearDivisibleBy4NotDivisibleBy100InLeapYear() {
     let year = Year(calendarYear: 1996)
-    XCTAssertTrue(year.isLeapYear)
+    #expect(year.isLeapYear)
   }
 
-  func testYearDivisibleBy4And5IsStillALeapYear() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
+  @Test("year divisible by 4 and 5 is still a leap year", .enabled(if: RUNALL))
+  func testYearDivisibleBy4And5IsStillALeapYear() {
     let year = Year(calendarYear: 1960)
-    XCTAssertTrue(year.isLeapYear)
+    #expect(year.isLeapYear)
   }
 
-  func testYearDivisibleBy100NotDivisibleBy400InCommonYear() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
+  @Test("year divisible by 100, not divisible by 400 in common year", .enabled(if: RUNALL))
+  func testYearDivisibleBy100NotDivisibleBy400InCommonYear() {
     let year = Year(calendarYear: 2100)
-    XCTAssertFalse(year.isLeapYear)
+    #expect(!year.isLeapYear)
   }
 
-  func testYearDivisibleBy100ButNotBy3IsStillNotALeapYear() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
+  @Test("year divisible by 100 but not by 3 is still not a leap year", .enabled(if: RUNALL))
+  func testYearDivisibleBy100ButNotBy3IsStillNotALeapYear() {
     let year = Year(calendarYear: 1900)
-    XCTAssertFalse(year.isLeapYear)
+    #expect(!year.isLeapYear)
   }
 
-  func testYearDivisibleBy400IsLeapYear() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
+  @Test("year divisible by 400 is leap year", .enabled(if: RUNALL))
+  func testYearDivisibleBy400IsLeapYear() {
     let year = Year(calendarYear: 2000)
-    XCTAssertTrue(year.isLeapYear)
+    #expect(year.isLeapYear)
   }
 
-  func testYearDivisibleBy400ButNotBy125IsStillALeapYear() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
+  @Test("year divisible by 400 but not by 125 is still a leap year", .enabled(if: RUNALL))
+  func testYearDivisibleBy400ButNotBy125IsStillALeapYear() {
     let year = Year(calendarYear: 2400)
-    XCTAssertTrue(year.isLeapYear)
+    #expect(year.isLeapYear)
   }
 
-  func testYearDivisibleBy200NotDivisibleBy400InCommonYear() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
+  @Test("year divisible by 200, not divisible by 400 in common year", .enabled(if: RUNALL))
+  func testYearDivisibleBy200NotDivisibleBy400InCommonYear() {
     let year = Year(calendarYear: 1800)
-    XCTAssertFalse(year.isLeapYear)
+    #expect(!year.isLeapYear)
   }
 }
diff --git a/exercises/practice/luhn/.meta/template.swift b/exercises/practice/luhn/.meta/template.swift
index cb698a08a..ffb2c6d1e 100644
--- a/exercises/practice/luhn/.meta/template.swift
+++ b/exercises/practice/luhn/.meta/template.swift
@@ -1,19 +1,21 @@
-import XCTest
+import Testing
+import Foundation
 @testable import {{exercise|camelCase}}
-class {{exercise|camelCase}}Tests: XCTestCase {
-    let runAll = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
 
+let RUNALL = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
+
+@Suite struct {{exercise|camelCase}}Tests {
     {% for case in cases %}
     {% if forloop.first -%}
-        func test{{case.description |camelCase }}() {
+        @Test("{{case.description}}")
     {% else -%}
-        func test{{case.description |camelCase }}() throws {
-        try XCTSkipIf(true && !runAll) // change true to false to run this test
+        @Test("{{case.description}}", .enabled(if: RUNALL))
     {% endif -%}
+    func test{{case.description |camelCase }}() {
         {%- if case.expected -%}
-        XCTAssertTrue(isValidLuhn("{{case.input.value}}"))
+        #expect(isValidLuhn("{{case.input.value}}"))
         {%- else -%}
-        XCTAssertFalse(isValidLuhn("{{case.input.value}}"))
+        #expect(!isValidLuhn("{{case.input.value}}"))
         {%- endif %}
     }
     {% endfor -%}
diff --git a/exercises/practice/luhn/Package.swift b/exercises/practice/luhn/Package.swift
index 42d9cd35a..cbbd76385 100644
--- a/exercises/practice/luhn/Package.swift
+++ b/exercises/practice/luhn/Package.swift
@@ -1,4 +1,4 @@
-// swift-tools-version:5.3
+// swift-tools-version:6.0
 
 import PackageDescription
 
diff --git a/exercises/practice/luhn/Tests/LuhnTests/LuhnTests.swift b/exercises/practice/luhn/Tests/LuhnTests/LuhnTests.swift
index c9dd94810..b6ea062a0 100644
--- a/exercises/practice/luhn/Tests/LuhnTests/LuhnTests.swift
+++ b/exercises/practice/luhn/Tests/LuhnTests/LuhnTests.swift
@@ -1,116 +1,121 @@
-import XCTest
+import Foundation
+import Testing
 
 @testable import Luhn
 
-class LuhnTests: XCTestCase {
-  let runAll = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
+let RUNALL = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
 
+@Suite struct LuhnTests {
+
+  @Test("single digit strings can not be valid")
   func testSingleDigitStringsCanNotBeValid() {
-    XCTAssertFalse(isValidLuhn("1"))
+    #expect(!isValidLuhn("1"))
   }
 
-  func testASingleZeroIsInvalid() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertFalse(isValidLuhn("0"))
+  @Test("a single zero is invalid", .enabled(if: RUNALL))
+  func testASingleZeroIsInvalid() {
+    #expect(!isValidLuhn("0"))
   }
 
-  func testASimpleValidSinThatRemainsValidIfReversed() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertTrue(isValidLuhn("059"))
+  @Test("a simple valid SIN that remains valid if reversed", .enabled(if: RUNALL))
+  func testASimpleValidSinThatRemainsValidIfReversed() {
+    #expect(isValidLuhn("059"))
   }
 
-  func testASimpleValidSinThatBecomesInvalidIfReversed() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertTrue(isValidLuhn("59"))
+  @Test("a simple valid SIN that becomes invalid if reversed", .enabled(if: RUNALL))
+  func testASimpleValidSinThatBecomesInvalidIfReversed() {
+    #expect(isValidLuhn("59"))
   }
 
-  func testAValidCanadianSin() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertTrue(isValidLuhn("055 444 285"))
+  @Test("a valid Canadian SIN", .enabled(if: RUNALL))
+  func testAValidCanadianSin() {
+    #expect(isValidLuhn("055 444 285"))
   }
 
-  func testInvalidCanadianSin() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertFalse(isValidLuhn("055 444 286"))
+  @Test("invalid Canadian SIN", .enabled(if: RUNALL))
+  func testInvalidCanadianSin() {
+    #expect(!isValidLuhn("055 444 286"))
   }
 
-  func testInvalidCreditCard() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertFalse(isValidLuhn("8273 1232 7352 0569"))
+  @Test("invalid credit card", .enabled(if: RUNALL))
+  func testInvalidCreditCard() {
+    #expect(!isValidLuhn("8273 1232 7352 0569"))
   }
 
-  func testInvalidLongNumberWithAnEvenRemainder() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertFalse(isValidLuhn("1 2345 6789 1234 5678 9012"))
+  @Test("invalid long number with an even remainder", .enabled(if: RUNALL))
+  func testInvalidLongNumberWithAnEvenRemainder() {
+    #expect(!isValidLuhn("1 2345 6789 1234 5678 9012"))
   }
 
-  func testInvalidLongNumberWithARemainderDivisibleBy5() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertFalse(isValidLuhn("1 2345 6789 1234 5678 9013"))
+  @Test("invalid long number with a remainder divisible by 5", .enabled(if: RUNALL))
+  func testInvalidLongNumberWithARemainderDivisibleBy5() {
+    #expect(!isValidLuhn("1 2345 6789 1234 5678 9013"))
   }
 
-  func testValidNumberWithAnEvenNumberOfDigits() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertTrue(isValidLuhn("095 245 88"))
+  @Test("valid number with an even number of digits", .enabled(if: RUNALL))
+  func testValidNumberWithAnEvenNumberOfDigits() {
+    #expect(isValidLuhn("095 245 88"))
   }
 
-  func testValidNumberWithAnOddNumberOfSpaces() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertTrue(isValidLuhn("234 567 891 234"))
+  @Test("valid number with an odd number of spaces", .enabled(if: RUNALL))
+  func testValidNumberWithAnOddNumberOfSpaces() {
+    #expect(isValidLuhn("234 567 891 234"))
   }
 
-  func testValidStringsWithANonDigitAddedAtTheEndBecomeInvalid() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertFalse(isValidLuhn("059a"))
+  @Test("valid strings with a non-digit added at the end become invalid", .enabled(if: RUNALL))
+  func testValidStringsWithANonDigitAddedAtTheEndBecomeInvalid() {
+    #expect(!isValidLuhn("059a"))
   }
 
-  func testValidStringsWithPunctuationIncludedBecomeInvalid() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertFalse(isValidLuhn("055-444-285"))
+  @Test("valid strings with punctuation included become invalid", .enabled(if: RUNALL))
+  func testValidStringsWithPunctuationIncludedBecomeInvalid() {
+    #expect(!isValidLuhn("055-444-285"))
   }
 
-  func testValidStringsWithSymbolsIncludedBecomeInvalid() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertFalse(isValidLuhn("055# 444$ 285"))
+  @Test("valid strings with symbols included become invalid", .enabled(if: RUNALL))
+  func testValidStringsWithSymbolsIncludedBecomeInvalid() {
+    #expect(!isValidLuhn("055# 444$ 285"))
   }
 
-  func testSingleZeroWithSpaceIsInvalid() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertFalse(isValidLuhn(" 0"))
+  @Test("single zero with space is invalid", .enabled(if: RUNALL))
+  func testSingleZeroWithSpaceIsInvalid() {
+    #expect(!isValidLuhn(" 0"))
   }
 
-  func testMoreThanASingleZeroIsValid() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertTrue(isValidLuhn("0000 0"))
+  @Test("more than a single zero is valid", .enabled(if: RUNALL))
+  func testMoreThanASingleZeroIsValid() {
+    #expect(isValidLuhn("0000 0"))
   }
 
-  func testInputDigit9IsCorrectlyConvertedToOutputDigit9() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertTrue(isValidLuhn("091"))
+  @Test("input digit 9 is correctly converted to output digit 9", .enabled(if: RUNALL))
+  func testInputDigit9IsCorrectlyConvertedToOutputDigit9() {
+    #expect(isValidLuhn("091"))
   }
 
-  func testVeryLongInputIsValid() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertTrue(isValidLuhn("9999999999 9999999999 9999999999 9999999999"))
+  @Test("very long input is valid", .enabled(if: RUNALL))
+  func testVeryLongInputIsValid() {
+    #expect(isValidLuhn("9999999999 9999999999 9999999999 9999999999"))
   }
 
-  func testValidLuhnWithAnOddNumberOfDigitsAndNonZeroFirstDigit() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertTrue(isValidLuhn("109"))
+  @Test("valid luhn with an odd number of digits and non zero first digit", .enabled(if: RUNALL))
+  func testValidLuhnWithAnOddNumberOfDigitsAndNonZeroFirstDigit() {
+    #expect(isValidLuhn("109"))
   }
 
-  func testUsingAsciiValueForNonDoubledNonDigitIsntAllowed() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertFalse(isValidLuhn("055b 444 285"))
+  @Test("using ascii value for non-doubled non-digit isn't allowed", .enabled(if: RUNALL))
+  func testUsingAsciiValueForNonDoubledNonDigitIsntAllowed() {
+    #expect(!isValidLuhn("055b 444 285"))
   }
 
-  func testUsingAsciiValueForDoubledNonDigitIsntAllowed() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertFalse(isValidLuhn(":9"))
+  @Test("using ascii value for doubled non-digit isn't allowed", .enabled(if: RUNALL))
+  func testUsingAsciiValueForDoubledNonDigitIsntAllowed() {
+    #expect(!isValidLuhn(":9"))
   }
 
-  func testNonNumericNonSpaceCharInTheMiddleWithASumThatsDivisibleBy10IsntAllowed() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertFalse(isValidLuhn("59%59"))
+  @Test(
+    "non-numeric, non-space char in the middle with a sum that's divisible by 10 isn't allowed",
+    .enabled(if: RUNALL))
+  func testNonNumericNonSpaceCharInTheMiddleWithASumThatsDivisibleBy10IsntAllowed() {
+    #expect(!isValidLuhn("59%59"))
   }
 }
diff --git a/exercises/practice/matching-brackets/.meta/template.swift b/exercises/practice/matching-brackets/.meta/template.swift
index 5f486e539..d525c4c75 100644
--- a/exercises/practice/matching-brackets/.meta/template.swift
+++ b/exercises/practice/matching-brackets/.meta/template.swift
@@ -1,19 +1,21 @@
-import XCTest
+import Testing
+import Foundation
 @testable import {{exercise|camelCase}}
-class {{exercise|camelCase}}Tests: XCTestCase {
-    let runAll = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
 
+let RUNALL = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
+
+@Suite struct {{exercise|camelCase}}Tests {
     {% for case in cases %}
     {% if forloop.first -%}
-        func test{{case.description |camelCase }}() {
+        @Test("{{case.description}}")
     {% else -%}
-        func test{{case.description |camelCase }}() throws {
-        try XCTSkipIf(true && !runAll) // change true to false to run this test
+        @Test("{{case.description}}", .enabled(if: RUNALL))
     {% endif -%}
+    func test{{case.description |camelCase }}() {
         {%- if case.expected -%}
-        XCTAssertTrue(MatchingBrackets.paired(text: "{{case.input.value | inspect}}"))
+        #expect(MatchingBrackets.paired(text: "{{case.input.value | inspect}}"))
         {%- else -%}
-        XCTAssertFalse(MatchingBrackets.paired(text: "{{case.input.value | inspect}}"))
+        #expect(!MatchingBrackets.paired(text: "{{case.input.value | inspect}}"))
         {%- endif %}
     }
     {% endfor -%}
diff --git a/exercises/practice/matching-brackets/Package.swift b/exercises/practice/matching-brackets/Package.swift
index 5b43bda40..e5cbcd460 100644
--- a/exercises/practice/matching-brackets/Package.swift
+++ b/exercises/practice/matching-brackets/Package.swift
@@ -1,4 +1,4 @@
-// swift-tools-version:5.3
+// swift-tools-version:6.0
 
 import PackageDescription
 
diff --git a/exercises/practice/matching-brackets/Tests/MatchingBracketsTests/MatchingBracketsTests.swift b/exercises/practice/matching-brackets/Tests/MatchingBracketsTests/MatchingBracketsTests.swift
index a383f68ca..c960b6acb 100644
--- a/exercises/practice/matching-brackets/Tests/MatchingBracketsTests/MatchingBracketsTests.swift
+++ b/exercises/practice/matching-brackets/Tests/MatchingBracketsTests/MatchingBracketsTests.swift
@@ -1,107 +1,110 @@
-import XCTest
+import Foundation
+import Testing
 
 @testable import MatchingBrackets
 
-class MatchingBracketsTests: XCTestCase {
-  let runAll = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
+let RUNALL = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
 
+@Suite struct MatchingBracketsTests {
+
+  @Test("paired square brackets")
   func testPairedSquareBrackets() {
-    XCTAssertTrue(MatchingBrackets.paired(text: "[]"))
+    #expect(MatchingBrackets.paired(text: "[]"))
   }
 
-  func testEmptyString() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertTrue(MatchingBrackets.paired(text: ""))
+  @Test("empty string", .enabled(if: RUNALL))
+  func testEmptyString() {
+    #expect(MatchingBrackets.paired(text: ""))
   }
 
-  func testUnpairedBrackets() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertFalse(MatchingBrackets.paired(text: "[["))
+  @Test("unpaired brackets", .enabled(if: RUNALL))
+  func testUnpairedBrackets() {
+    #expect(!MatchingBrackets.paired(text: "[["))
   }
 
-  func testWrongOrderedBrackets() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertFalse(MatchingBrackets.paired(text: "}{"))
+  @Test("wrong ordered brackets", .enabled(if: RUNALL))
+  func testWrongOrderedBrackets() {
+    #expect(!MatchingBrackets.paired(text: "}{"))
   }
 
-  func testWrongClosingBracket() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertFalse(MatchingBrackets.paired(text: "{]"))
+  @Test("wrong closing bracket", .enabled(if: RUNALL))
+  func testWrongClosingBracket() {
+    #expect(!MatchingBrackets.paired(text: "{]"))
   }
 
-  func testPairedWithWhitespace() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertTrue(MatchingBrackets.paired(text: "{ }"))
+  @Test("paired with whitespace", .enabled(if: RUNALL))
+  func testPairedWithWhitespace() {
+    #expect(MatchingBrackets.paired(text: "{ }"))
   }
 
-  func testPartiallyPairedBrackets() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertFalse(MatchingBrackets.paired(text: "{[])"))
+  @Test("partially paired brackets", .enabled(if: RUNALL))
+  func testPartiallyPairedBrackets() {
+    #expect(!MatchingBrackets.paired(text: "{[])"))
   }
 
-  func testSimpleNestedBrackets() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertTrue(MatchingBrackets.paired(text: "{[]}"))
+  @Test("simple nested brackets", .enabled(if: RUNALL))
+  func testSimpleNestedBrackets() {
+    #expect(MatchingBrackets.paired(text: "{[]}"))
   }
 
-  func testSeveralPairedBrackets() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertTrue(MatchingBrackets.paired(text: "{}[]"))
+  @Test("several paired brackets", .enabled(if: RUNALL))
+  func testSeveralPairedBrackets() {
+    #expect(MatchingBrackets.paired(text: "{}[]"))
   }
 
-  func testPairedAndNestedBrackets() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertTrue(MatchingBrackets.paired(text: "([{}({}[])])"))
+  @Test("paired and nested brackets", .enabled(if: RUNALL))
+  func testPairedAndNestedBrackets() {
+    #expect(MatchingBrackets.paired(text: "([{}({}[])])"))
   }
 
-  func testUnopenedClosingBrackets() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertFalse(MatchingBrackets.paired(text: "{[)][]}"))
+  @Test("unopened closing brackets", .enabled(if: RUNALL))
+  func testUnopenedClosingBrackets() {
+    #expect(!MatchingBrackets.paired(text: "{[)][]}"))
   }
 
-  func testUnpairedAndNestedBrackets() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertFalse(MatchingBrackets.paired(text: "([{])"))
+  @Test("unpaired and nested brackets", .enabled(if: RUNALL))
+  func testUnpairedAndNestedBrackets() {
+    #expect(!MatchingBrackets.paired(text: "([{])"))
   }
 
-  func testPairedAndWrongNestedBrackets() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertFalse(MatchingBrackets.paired(text: "[({]})"))
+  @Test("paired and wrong nested brackets", .enabled(if: RUNALL))
+  func testPairedAndWrongNestedBrackets() {
+    #expect(!MatchingBrackets.paired(text: "[({]})"))
   }
 
-  func testPairedAndWrongNestedBracketsButInnermostAreCorrect() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertFalse(MatchingBrackets.paired(text: "[({}])"))
+  @Test("paired and wrong nested brackets but innermost are correct", .enabled(if: RUNALL))
+  func testPairedAndWrongNestedBracketsButInnermostAreCorrect() {
+    #expect(!MatchingBrackets.paired(text: "[({}])"))
   }
 
-  func testPairedAndIncompleteBrackets() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertFalse(MatchingBrackets.paired(text: "{}["))
+  @Test("paired and incomplete brackets", .enabled(if: RUNALL))
+  func testPairedAndIncompleteBrackets() {
+    #expect(!MatchingBrackets.paired(text: "{}["))
   }
 
-  func testTooManyClosingBrackets() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertFalse(MatchingBrackets.paired(text: "[]]"))
+  @Test("too many closing brackets", .enabled(if: RUNALL))
+  func testTooManyClosingBrackets() {
+    #expect(!MatchingBrackets.paired(text: "[]]"))
   }
 
-  func testEarlyUnexpectedBrackets() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertFalse(MatchingBrackets.paired(text: ")()"))
+  @Test("early unexpected brackets", .enabled(if: RUNALL))
+  func testEarlyUnexpectedBrackets() {
+    #expect(!MatchingBrackets.paired(text: ")()"))
   }
 
-  func testEarlyMismatchedBrackets() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertFalse(MatchingBrackets.paired(text: "{)()"))
+  @Test("early mismatched brackets", .enabled(if: RUNALL))
+  func testEarlyMismatchedBrackets() {
+    #expect(!MatchingBrackets.paired(text: "{)()"))
   }
 
-  func testMathExpression() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertTrue(MatchingBrackets.paired(text: "(((185 + 223.85) * 15) - 543)/2"))
+  @Test("math expression", .enabled(if: RUNALL))
+  func testMathExpression() {
+    #expect(MatchingBrackets.paired(text: "(((185 + 223.85) * 15) - 543)/2"))
   }
 
-  func testComplexLatexExpression() throws {
-    try XCTSkipIf(true && !runAll)  // change true to false to run this test
-    XCTAssertTrue(
+  @Test("complex latex expression", .enabled(if: RUNALL))
+  func testComplexLatexExpression() {
+    #expect(
       MatchingBrackets.paired(
         text:
           "\\left(\\begin{array}{cc} \\frac{1}{3} & x\\\\ \\mathrm{e}^{x} &... x^2 \\end{array}\\right)"