[Swift 6]: Update Exercises batch 9

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 -%}

exercises/practice/largest-series-product/Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.3
+// swift-tools-version:6.0
 
 import PackageDescription
 

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) }
   }
 }

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 -%}

exercises/practice/leap/Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.3
+// swift-tools-version:6.0
 
 import PackageDescription
 

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)
   }
 }

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 -%}

exercises/practice/luhn/Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.3
+// swift-tools-version:6.0
 
 import PackageDescription