Migrate from XCTest to Swift Testing (#229)

* Remove processing of Vocabs resource from package manifest

* Convert ModelsTests from XCTest to Swift Testing

* Convert GenerationTests from XCTest to Swift Testing

* Convert most of TokenizersTests from XCTest to Swift Testing

* Convert FactoryTests from XCTest to Swift Testing

* Fix test names for NormalizerTests

* Reorganize RoBERTa tests

* Inline SQuAD dataset into BertTokenizerTests

* Convert TokenizerTests from XCTest to Swift Testing

* Convert ConfigTests from XCTest to Swift Testing

* Move config-specific tests from HubTests to ConfigTests

* Migrate HubTests from XCTest to Swift Testing

Fix race condition in moveDownloadedFile

Pass hubApiForTests to AutoTokenizer.from calls

Consolidate BERT uncased tests

Conditionalize integration tests on HF_TOKEN

* Revert "Migrate HubTests from XCTest to Swift Testing"

This reverts commit 63eef12b1f3899a89dd7e0e376687fefd2f3f091.

* Run tokenizer tests in serial

* Consolidate references to google-bert/bert-base-uncased to avoid race conditions in tests

* Consolidate references to phi and gemma to avoid race conditions in tests

* Consolidate references to deepseek-ai/DeepSeek-R1-Distill-Qwen-7B to avoid race conditions in tests

* Remove .serialized trait from tokenizer tests

* Swap in google-bert/bert-base-chinese for applyTemplateError test

Author: mattt

Package.swift

@@ -36,6 +36,6 @@ let package = Package(
         .testTarget(name: "GenerationTests", dependencies: ["Generation"]),
         .testTarget(name: "HubTests", dependencies: ["Hub", .product(name: "Jinja", package: "Jinja")], swiftSettings: swiftSettings),
         .testTarget(name: "ModelsTests", dependencies: ["Models", "Hub"], resources: [.process("Resources")]),
-        .testTarget(name: "TokenizersTests", dependencies: ["Tokenizers", "Models", "Hub"], resources: [.process("Resources"), .process("Vocabs")]),
+        .testTarget(name: "TokenizersTests", dependencies: ["Tokenizers", "Models", "Hub"], resources: [.process("Resources")]),
     ]
 )

Tests/GenerationTests/LogitsWarperTests.swift

@@ -6,150 +6,155 @@
 
 #if canImport(CoreML)
 import CoreML
-import XCTest
-
 @testable import Generation
+import Testing
 
-final class LogitsWarperTests: XCTestCase {
+@Suite("Logits Warper Tests")
+struct LogitsWarperTests {
     private let accuracy: Float = 0.00001
 
-    func testTemperatureLogitsWarper() {
+    @Test("Temperature logits warper functionality")
+    func temperatureLogitsWarper() {
         let result1 = TemperatureLogitsWarper(temperature: 0.0)([], [])
-        XCTAssertTrue(result1.indices.isEmpty)
-        XCTAssertTrue(result1.logits.isEmpty)
+        #expect(result1.indices.isEmpty)
+        #expect(result1.logits.isEmpty)
 
         let result2 = TemperatureLogitsWarper(temperature: 1.0)([], [])
-        XCTAssertTrue(result2.indices.isEmpty)
-        XCTAssertTrue(result2.logits.isEmpty)
+        #expect(result2.indices.isEmpty)
+        #expect(result2.logits.isEmpty)
 
         let result3 = TemperatureLogitsWarper(temperature: 1.0)([0, 1], [2.0, 1.0])
-        XCTAssertEqual(result3.indices, [0, 1])
-        XCTAssertEqual(result3.logits, [2.0, 1.0], accuracy: accuracy)
+        #expect(result3.indices == [0, 1])
+        #expect(isClose(result3.logits, [2.0, 1.0], accuracy: accuracy))
 
         let result4 = TemperatureLogitsWarper(temperature: 2.0)([0, 1], [2.0, 1.0])
-        XCTAssertEqual(result4.indices, [0, 1])
-        XCTAssertEqual(result4.logits, [1.0, 0.5], accuracy: accuracy)
+        #expect(result4.indices == [0, 1])
+        #expect(isClose(result4.logits, [1.0, 0.5], accuracy: accuracy))
 
         let result5 = TemperatureLogitsWarper(temperature: 0.5)([0, 1], [2.0, 1.0])
-        XCTAssertEqual(result5.indices, [0, 1])
-        XCTAssertEqual(result5.logits, [4.0, 2.0], accuracy: accuracy)
+        #expect(result5.indices == [0, 1])
+        #expect(isClose(result5.logits, [4.0, 2.0], accuracy: accuracy))
 
         let result6 = TemperatureLogitsWarper(temperature: 0.5)([200, 100], [2.0, 1.0])
-        XCTAssertEqual(result6.indices, [200, 100])
-        XCTAssertEqual(result6.logits, [4.0, 2.0], accuracy: accuracy)
+        #expect(result6.indices == [200, 100])
+        #expect(isClose(result6.logits, [4.0, 2.0], accuracy: accuracy))
     }
 
-    func testTopKLogitsWarper() {
+    @Test("Top-K logits warper functionality")
+    func topKLogitsWarper() {
         let result1 = TopKLogitsWarper(k: 0)([], [])
-        XCTAssertTrue(result1.indices.isEmpty)
-        XCTAssertTrue(result1.logits.isEmpty)
+        #expect(result1.indices.isEmpty)
+        #expect(result1.logits.isEmpty)
 
         let result2 = TopKLogitsWarper(k: 3)([], [])
-        XCTAssertTrue(result2.indices.isEmpty)
-        XCTAssertTrue(result2.logits.isEmpty)
+        #expect(result2.indices.isEmpty)
+        #expect(result2.logits.isEmpty)
 
         let result3 = TopKLogitsWarper(k: 3)([0, 1], [2.0, 1.0])
-        XCTAssertEqual(result3.indices, [0, 1])
-        XCTAssertEqual(result3.logits, [2.0, 1.0], accuracy: accuracy)
+        #expect(result3.indices == [0, 1])
+        #expect(isClose(result3.logits, [2.0, 1.0], accuracy: accuracy))
 
         let result4 = TopKLogitsWarper(k: 3)([0, 1, 2], [2.0, 1.0, 3.0])
-        XCTAssertEqual(result4.indices, [2, 0, 1])
-        XCTAssertEqual(result4.logits, [3.0, 2.0, 1.0], accuracy: accuracy)
+        #expect(result4.indices == [2, 0, 1])
+        #expect(isClose(result4.logits, [3.0, 2.0, 1.0], accuracy: accuracy))
 
         let result5 = TopKLogitsWarper(k: 4)([0, 1, 2, 3, 4, 5], [2.0, 1.0, 3.0, -1.0, 123.0, 0.0])
-        XCTAssertEqual(result5.indices, [4, 2, 0, 1])
-        XCTAssertEqual(result5.logits, [123.0, 3.0, 2.0, 1.0], accuracy: accuracy)
+        #expect(result5.indices == [4, 2, 0, 1])
+        #expect(isClose(result5.logits, [123.0, 3.0, 2.0, 1.0], accuracy: accuracy))
 
         let result6 = TopKLogitsWarper(k: 3)([10, 1, 52], [2.0, 1.0, 3.0])
-        XCTAssertEqual(result6.indices, [52, 10, 1])
-        XCTAssertEqual(result6.logits, [3.0, 2.0, 1.0], accuracy: accuracy)
+        #expect(result6.indices == [52, 10, 1])
+        #expect(isClose(result6.logits, [3.0, 2.0, 1.0], accuracy: accuracy))
     }
 
-    func testTopPLogitsWarper() {
+    @Test("Top-P logits warper functionality")
+    func topPLogitsWarper() {
         let result1 = TopPLogitsWarper(p: 0.99)([], [])
-        XCTAssertTrue(result1.indices.isEmpty)
-        XCTAssertTrue(result1.logits.isEmpty)
+        #expect(result1.indices.isEmpty)
+        #expect(result1.logits.isEmpty)
 
         let logits = (0..<10).map { Float($0) }
         let indices = Array(logits.indices)
         let result2 = TopPLogitsWarper(p: 0.99)(indices, logits)
-        XCTAssertEqual(result2.indices, [9, 8, 7, 6, 5])
-        XCTAssertEqual(result2.logits, [9.0, 8.0, 7.0, 6.0, 5.0], accuracy: accuracy)
+        #expect(result2.indices == [9, 8, 7, 6, 5])
+        #expect(isClose(result2.logits, [9.0, 8.0, 7.0, 6.0, 5.0], accuracy: accuracy))
 
         let result3 = TopPLogitsWarper(p: 0.95)(indices, logits)
-        XCTAssertEqual(result3.indices, [9, 8, 7])
-        XCTAssertEqual(result3.logits, [9.0, 8.0, 7.0], accuracy: accuracy)
+        #expect(result3.indices == [9, 8, 7])
+        #expect(isClose(result3.logits, [9.0, 8.0, 7.0], accuracy: accuracy))
 
         let result4 = TopPLogitsWarper(p: 0.6321493)(indices, logits)
-        XCTAssertEqual(result4.indices, [9, 8])
-        XCTAssertEqual(result4.logits, [9.0, 8.0], accuracy: accuracy)
+        #expect(result4.indices == [9, 8])
+        #expect(isClose(result4.logits, [9.0, 8.0], accuracy: accuracy))
 
         let result5 = TopPLogitsWarper(p: 0.95)([3, 1, 8], [0, 1, 2])
-        XCTAssertEqual(result5.indices, [8, 1, 3])
-        XCTAssertEqual(result5.logits, [2, 1, 0], accuracy: accuracy)
+        #expect(result5.indices == [8, 1, 3])
+        #expect(isClose(result5.logits, [2, 1, 0], accuracy: accuracy))
     }
 
-    func testRepetitionPenaltyWarper() {
+    @Test("Repetition penalty warper functionality")
+    func repetitionPenaltyWarper() {
         let indices = Array(0..<10)
         let logits = indices.map { Float($0) }
 
         let result1 = RepetitionPenaltyWarper(penalty: 1.0)(indices, logits)
-        XCTAssertEqual(result1.indices, indices)
-        XCTAssertEqual(result1.logits, logits, accuracy: accuracy)
+        #expect(result1.indices == indices)
+        #expect(isClose(result1.logits, logits, accuracy: accuracy))
 
         let result2 = RepetitionPenaltyWarper(penalty: 3.75)(indices, logits)
-        XCTAssertEqual(result2.indices, indices)
+        #expect(result2.indices == indices)
         let logits2 = indices.map { Float($0) / 3.75 }
-        XCTAssertEqual(result2.logits, logits2, accuracy: accuracy)
+        #expect(isClose(result2.logits, logits2, accuracy: accuracy))
 
         let result3 = RepetitionPenaltyWarper(penalty: 0.75)([0, 1, 2], [0.8108, 0.9954, 0.0119])
-        XCTAssertEqual(result3.indices, [0, 1, 2])
-        XCTAssertEqual(result3.logits, [1.0811, 1.3272, 0.0158], accuracy: 1e-4)
+        #expect(result3.indices == [0, 1, 2])
+        #expect(isClose(result3.logits, [1.0811, 1.3272, 0.0158], accuracy: 1e-4))
 
         let result4 = RepetitionPenaltyWarper(penalty: 1.11)([2, 3, 4], [0.5029, 0.8694, 0.4765, 0.9967, 0.4190, 0.9158])
-        XCTAssertEqual(result4.indices, [2, 3, 4])
-        XCTAssertEqual(result4.logits, [0.5029, 0.8694, 0.4293, 0.8980, 0.3775, 0.9158], accuracy: 1e-4)
+        #expect(result4.indices == [2, 3, 4])
+        #expect(isClose(result4.logits, [0.5029, 0.8694, 0.4293, 0.8980, 0.3775, 0.9158], accuracy: 1e-4))
 
         let result5 = RepetitionPenaltyWarper(penalty: 0.9)([0, 1, 2], [-0.7433, -0.4738, -0.2966])
-        XCTAssertEqual(result5.indices, [0, 1, 2])
-        XCTAssertEqual(result5.logits, [-0.6690, -0.4264, -0.2669], accuracy: 1e-4)
+        #expect(result5.indices == [0, 1, 2])
+        #expect(isClose(result5.logits, [-0.6690, -0.4264, -0.2669], accuracy: 1e-4))
 
         let result6 = RepetitionPenaltyWarper(penalty: 1.125)([3, 1, 2], [0.1674, 0.6431, 0.6780, 0.2755])
-        XCTAssertEqual(result6.indices, [3, 1, 2])
-        XCTAssertEqual(result6.logits, [0.1674, 0.5716, 0.6026, 0.2449], accuracy: 1e-4)
+        #expect(result6.indices == [3, 1, 2])
+        #expect(isClose(result6.logits, [0.1674, 0.5716, 0.6026, 0.2449], accuracy: 1e-4))
     }
 
-    func testLogitsProcessor() {
+    @Test("Logits processor functionality")
+    func logitsProcessor() {
         let processor1 = LogitsProcessor(logitsWarpers: [])
         let result1 = processor1([])
-        XCTAssertTrue(result1.indices.isEmpty)
-        XCTAssertTrue(result1.logits.isEmpty)
+        #expect(result1.indices.isEmpty)
+        #expect(result1.logits.isEmpty)
 
         let processor2 = LogitsProcessor(logitsWarpers: [])
         let result2 = processor2([2.0, 1.0])
-        XCTAssertEqual(result2.indices, [0, 1])
-        XCTAssertEqual(result2.logits, [2.0, 1.0], accuracy: accuracy)
+        #expect(result2.indices == [0, 1])
+        #expect(isClose(result2.logits, [2.0, 1.0], accuracy: accuracy))
 
         let processor3 = LogitsProcessor(
             logitsWarpers: [TopKLogitsWarper(k: 3)]
         )
         let result3 = processor3([2.0, 1.0, 3.0, -5.0])
-        XCTAssertEqual(result3.indices, [2, 0, 1])
-        XCTAssertEqual(result3.logits, [3.0, 2.0, 1.0], accuracy: accuracy)
+        #expect(result3.indices == [2, 0, 1])
+        #expect(isClose(result3.logits, [3.0, 2.0, 1.0], accuracy: accuracy))
 
         let processor4 = LogitsProcessor(
             logitsWarpers: [TopKLogitsWarper(k: 3), TopPLogitsWarper(p: 0.99)]
         )
         let result4 = processor4([2.0, 1.0, 3.0, -5.0, -23.0, 12.5])
-        XCTAssertEqual(result4.indices, [5])
-        XCTAssertEqual(result4.logits, [12.5], accuracy: accuracy)
+        #expect(result4.indices == [5])
+        #expect(isClose(result4.logits, [12.5], accuracy: accuracy))
 
         let processor5 = LogitsProcessor(
             logitsWarpers: [TopKLogitsWarper(k: 4), TopPLogitsWarper(p: 0.99)]
         )
         let result5 = processor5([2.0, 1.0, 3.0, -5.0, -3.0, 4.5])
-        XCTAssertEqual(result5.indices, [5, 2, 0, 1])
-        XCTAssertEqual(result5.logits, [4.5, 3.0, 2.0, 1.0], accuracy: accuracy)
+        #expect(result5.indices == [5, 2, 0, 1])
+        #expect(isClose(result5.logits, [4.5, 3.0, 2.0, 1.0], accuracy: accuracy))
     }
 }
 #endif // canImport(CoreML)

Tests/GenerationTests/MathTests.swift

@@ -6,51 +6,54 @@
 
 #if canImport(CoreML)
 import CoreML
-import XCTest
-
 @testable import Generation
+import Testing
 
-final class MathTests: XCTestCase {
+@Suite("Math Tests")
+struct MathTests {
     private let accuracy: Float = 0.00001
 
-    func testCumsum() {
-        XCTAssertTrue(Math.cumsum([]).isEmpty)
-        XCTAssertEqual(Math.cumsum([1]), [1])
-        XCTAssertEqual(Math.cumsum([1, 2, 3, 4]), [1, 3, 6, 10])
+    @Test("Cumulative sum functionality")
+    func cumsum() {
+        #expect(Math.cumsum([]).isEmpty)
+        #expect(Math.cumsum([1]) == [1])
+        #expect(Math.cumsum([1, 2, 3, 4]) == [1, 3, 6, 10])
     }
 
-    func testArgMax() throws {
+    @Test("Argmax functionality")
+    func argmax() throws {
         let result1 = Math.argmax([3.0, 4.0, 1.0, 2.0] as [Float], count: 4)
-        XCTAssertEqual(result1.0, 1)
-        XCTAssertEqual(result1.1, 4.0)
+        #expect(result1.0 == 1)
+        #expect(result1.1 == 4.0)
 
         let result2 = Math.argmax32([3.0, 4.0, 1.0, 2.0], count: 4)
-        XCTAssertEqual(result2.0, 1)
-        XCTAssertEqual(result2.1, 4.0)
+        #expect(result2.0 == 1)
+        #expect(result2.1 == 4.0)
 
         let result3 = Math.argmax([3.0, 4.0, 1.0, 2.0] as [Double], count: 4)
-        XCTAssertEqual(result3.0, 1)
-        XCTAssertEqual(result3.1, 4.0)
+        #expect(result3.0 == 1)
+        #expect(result3.1 == 4.0)
 
         let result4 = try Math.argmax32(MLMultiArray([3.0, 4.0, 1.0, 2.0] as [Float]))
-        XCTAssertEqual(result4.0, 1)
-        XCTAssertEqual(result4.1, 4.0)
+        #expect(result4.0 == 1)
+        #expect(result4.1 == 4.0)
 
         let result5 = try Math.argmax(MLMultiArray([3.0, 4.0, 1.0, 2.0] as [Double]))
-        XCTAssertEqual(result5.0, 1)
-        XCTAssertEqual(result5.1, 4.0)
+        #expect(result5.0 == 1)
+        #expect(result5.1 == 4.0)
 
         let result6 = Math.argmax(MLShapedArray(scalars: [3.0, 4.0, 1.0, 2.0] as [Float], shape: [4]))
-        XCTAssertEqual(result6.0, 1)
-        XCTAssertEqual(result6.1, 4.0)
+        #expect(result6.0 == 1)
+        #expect(result6.1 == 4.0)
     }
 
-    func testSoftmax() {
-        XCTAssertEqual(Math.softmax([]), [])
+    @Test("Softmax functionality")
+    func softmax() {
+        #expect(Math.softmax([]) == [])
 
         let result1 = Math.softmax([3.0, 4.0, 1.0, 2.0])
-        XCTAssertEqual(result1, [0.23688284, 0.6439143, 0.032058604, 0.08714432], accuracy: accuracy)
-        XCTAssertEqual(result1.reduce(0, +), 1.0, accuracy: accuracy)
+        #expect(isClose(result1, [0.23688284, 0.6439143, 0.032058604, 0.08714432], accuracy: accuracy))
+        #expect(abs(result1.reduce(0, +) - 1.0) < accuracy)
     }
 }
 #endif // canImport(CoreML)

Tests/GenerationTests/TestUtils.swift

@@ -1,22 +1,7 @@
 import Foundation
-import XCTest
 
-func XCTAssertEqual<T: FloatingPoint>(
-    _ expression1: @autoclosure () throws -> [T],
-    _ expression2: @autoclosure () throws -> [T],
-    accuracy: T,
-    _ message: @autoclosure () -> String = "",
-    file: StaticString = #filePath,
-    line: UInt = #line
-) {
-    do {
-        let lhsEvaluated = try expression1()
-        let rhsEvaluated = try expression2()
-        XCTAssertEqual(lhsEvaluated.count, rhsEvaluated.count, file: file, line: line)
-        for (lhs, rhs) in zip(lhsEvaluated, rhsEvaluated) {
-            XCTAssertEqual(lhs, rhs, accuracy: accuracy, file: file, line: line)
-        }
-    } catch {
-        XCTFail("Unexpected error: \(error)", file: file, line: line)
-    }
+/// Check if two floating-point arrays are equal within a given accuracy
+func isClose<T: FloatingPoint>(_ lhs: [T], _ rhs: [T], accuracy: T) -> Bool {
+    guard lhs.count == rhs.count else { return false }
+    return zip(lhs, rhs).allSatisfy { abs($0.0 - $0.1) <= accuracy }
 }