@dvai-bridge/ios 4.0.0 → 4.0.1

package/ios/Tests/DVAIBridgeTests/CoreMLEngineTests.swift

@@ -1,18 +1,18 @@
-import XCTest
-@testable import DVAICoreMLCore
-
-@available(iOS 18.0, macOS 15.0, *)
-final class CoreMLEngineTests: XCTestCase {
-    func testLoadFailsForMissingFile() {
-        let bogusURL = URL(fileURLWithPath: "/tmp/definitely-does-not-exist.mlmodelc")
-        XCTAssertThrowsError(try CoreMLEngine(modelURL: bogusURL, eosTokenId: 0)) { err in
-            guard case let CoreMLBackendError.modelLoadFailed(reason) = err else {
-                return XCTFail("wrong error: \(err)")
-            }
-            XCTAssertTrue(
-                reason.contains("error") || reason.contains("Error") || reason.contains("file"),
-                "reason should mention error details, got: \(reason)"
-            )
-        }
-    }
-}
+import XCTest
+@testable import DVAICoreMLCore
+
+@available(iOS 18.0, macOS 15.0, *)
+final class CoreMLEngineTests: XCTestCase {
+    func testLoadFailsForMissingFile() {
+        let bogusURL = URL(fileURLWithPath: "/tmp/definitely-does-not-exist.mlmodelc")
+        XCTAssertThrowsError(try CoreMLEngine(modelURL: bogusURL, eosTokenId: 0)) { err in
+            guard case let CoreMLBackendError.modelLoadFailed(reason) = err else {
+                return XCTFail("wrong error: \(err)")
+            }
+            XCTAssertTrue(
+                reason.contains("error") || reason.contains("Error") || reason.contains("file"),
+                "reason should mention error details, got: \(reason)"
+            )
+        }
+    }
+}

package/ios/Tests/DVAIBridgeTests/CoreMLGeneratorShapeTests.swift

@@ -1,11 +1,11 @@
-import XCTest
-@testable import DVAICoreMLCore
-
-@available(iOS 18.0, macOS 15.0, *)
-final class CoreMLGeneratorShapeTests: XCTestCase {
-    func testTypesCompile() {
-        // Ensures the public-internal API compiles correctly at the type level.
-        // Real generation is tested end-to-end in RealModelIntegrationTest (Task 18).
-        let _: AsyncThrowingStream<String, Error>.Type = AsyncThrowingStream<String, Error>.self
-    }
-}
+import XCTest
+@testable import DVAICoreMLCore
+
+@available(iOS 18.0, macOS 15.0, *)
+final class CoreMLGeneratorShapeTests: XCTestCase {
+    func testTypesCompile() {
+        // Ensures the public-internal API compiles correctly at the type level.
+        // Real generation is tested end-to-end in RealModelIntegrationTest (Task 18).
+        let _: AsyncThrowingStream<String, Error>.Type = AsyncThrowingStream<String, Error>.self
+    }
+}

package/ios/Tests/DVAIBridgeTests/CoreMLHandlersTests.swift

@@ -1,32 +1,32 @@
-import XCTest
-import DVAISharedCore
-@testable import DVAICoreMLCore
-
-@available(iOS 18.0, macOS 15.0, *)
-final class CoreMLHandlersTests: XCTestCase {
-    func testHandleEmbeddingsReturns501() async throws {
-        // The embeddings endpoint short-circuits without invoking the generator.
-        // We verify the response shape without needing a real MLModel.
-        let response: HandlerResponse = .error(501, "embeddings not yet supported by the CoreML backend")
-        if case let .error(status, msg) = response {
-            XCTAssertEqual(status, 501)
-            XCTAssertTrue(msg.contains("embeddings"), "expected 'embeddings' in '\(msg)'")
-        } else {
-            XCTFail("expected error response")
-        }
-    }
-
-    func testHandleModelsReturnsConfiguredModel() async throws {
-        let response: HandlerResponse = .json(200, [
-            "object": "list",
-            "data": [["id": "test-model", "object": "model", "owned_by": "dvai-bridge"]]
-        ])
-        if case let .json(status, body) = response {
-            XCTAssertEqual(status, 200)
-            let dict = body as? [String: Any]
-            XCTAssertEqual(dict?["object"] as? String, "list")
-        } else {
-            XCTFail("expected json response")
-        }
-    }
-}
+import XCTest
+import DVAISharedCore
+@testable import DVAICoreMLCore
+
+@available(iOS 18.0, macOS 15.0, *)
+final class CoreMLHandlersTests: XCTestCase {
+    func testHandleEmbeddingsReturns501() async throws {
+        // The embeddings endpoint short-circuits without invoking the generator.
+        // We verify the response shape without needing a real MLModel.
+        let response: HandlerResponse = .error(501, "embeddings not yet supported by the CoreML backend")
+        if case let .error(status, msg) = response {
+            XCTAssertEqual(status, 501)
+            XCTAssertTrue(msg.contains("embeddings"), "expected 'embeddings' in '\(msg)'")
+        } else {
+            XCTFail("expected error response")
+        }
+    }
+
+    func testHandleModelsReturnsConfiguredModel() async throws {
+        let response: HandlerResponse = .json(200, [
+            "object": "list",
+            "data": [["id": "test-model", "object": "model", "owned_by": "dvai-bridge"]]
+        ])
+        if case let .json(status, body) = response {
+            XCTAssertEqual(status, 200)
+            let dict = body as? [String: Any]
+            XCTAssertEqual(dict?["object"] as? String, "list")
+        } else {
+            XCTFail("expected json response")
+        }
+    }
+}

package/ios/Tests/DVAIBridgeTests/CoreMLPluginStateTests.swift

@@ -1,41 +1,41 @@
-import XCTest
-@testable import DVAICoreMLCore
-
-@available(iOS 18.0, macOS 15.0, *)
-final class CoreMLPluginStateTests: XCTestCase {
-    func testStartFailsWithoutModelPath() async {
-        let state = CoreMLPluginState()
-        do {
-            _ = try await state.start(opts: [:])
-            XCTFail("Expected throw")
-        } catch let err as CoreMLBackendError {
-            guard case .modelLoadFailed = err else { return XCTFail("wrong error: \(err)") }
-            // Pass — empty opts correctly throws modelLoadFailed
-        } catch {
-            XCTFail("wrong error type: \(error)")
-        }
-    }
-
-    func testStartFailsWithoutTokenizerPath() async {
-        let state = CoreMLPluginState()
-        do {
-            _ = try await state.start(opts: ["modelPath": "/tmp/x.mlmodelc"])
-            XCTFail("Expected throw")
-        } catch let err as CoreMLBackendError {
-            guard case .tokenizerLoadFailed = err else { return XCTFail("wrong error: \(err)") }
-            // Pass — missing tokenizerPath correctly throws tokenizerLoadFailed
-        } catch {
-            XCTFail("wrong error type: \(error)")
-        }
-    }
-
-    func testStopWhenNotStartedIsIdempotent() async throws {
-        try await CoreMLPluginState().stop()
-        // Doesn't throw — idempotent stop is required by the API contract
-    }
-
-    func testStatusInfoReportsNotRunning() async {
-        let info = await CoreMLPluginState().statusInfo()
-        XCTAssertEqual(info["running"] as? Bool, false)
-    }
-}
+import XCTest
+@testable import DVAICoreMLCore
+
+@available(iOS 18.0, macOS 15.0, *)
+final class CoreMLPluginStateTests: XCTestCase {
+    func testStartFailsWithoutModelPath() async {
+        let state = CoreMLPluginState()
+        do {
+            _ = try await state.start(opts: [:])
+            XCTFail("Expected throw")
+        } catch let err as CoreMLBackendError {
+            guard case .modelLoadFailed = err else { return XCTFail("wrong error: \(err)") }
+            // Pass — empty opts correctly throws modelLoadFailed
+        } catch {
+            XCTFail("wrong error type: \(error)")
+        }
+    }
+
+    func testStartFailsWithoutTokenizerPath() async {
+        let state = CoreMLPluginState()
+        do {
+            _ = try await state.start(opts: ["modelPath": "/tmp/x.mlmodelc"])
+            XCTFail("Expected throw")
+        } catch let err as CoreMLBackendError {
+            guard case .tokenizerLoadFailed = err else { return XCTFail("wrong error: \(err)") }
+            // Pass — missing tokenizerPath correctly throws tokenizerLoadFailed
+        } catch {
+            XCTFail("wrong error type: \(error)")
+        }
+    }
+
+    func testStopWhenNotStartedIsIdempotent() async throws {
+        try await CoreMLPluginState().stop()
+        // Doesn't throw — idempotent stop is required by the API contract
+    }
+
+    func testStatusInfoReportsNotRunning() async {
+        let info = await CoreMLPluginState().statusInfo()
+        XCTAssertEqual(info["running"] as? Bool, false)
+    }
+}

package/ios/Tests/DVAIBridgeTests/CoreMLSamplerTests.swift

@@ -1,40 +1,40 @@
-import XCTest
-import CoreML
-@testable import DVAICoreMLCore
-
-final class CoreMLSamplerTests: XCTestCase {
-    func makeLogits(_ vals: [Float]) -> MLMultiArray {
-        let arr = try! MLMultiArray(shape: [NSNumber(value: vals.count)], dataType: .float32)
-        for (i, v) in vals.enumerated() { arr[i] = NSNumber(value: v) }
-        return arr
-    }
-
-    func testGreedyReturnsArgmax() {
-        let s = CoreMLSampler(temperature: 0, topP: 1.0, topK: 0)
-        let logits = makeLogits([1.0, 5.0, 2.0, 4.0])
-        XCTAssertEqual(s.sample(logits: logits), 1)  // argmax index
-    }
-
-    func testTemperatureSamplingNeverThrows() {
-        let s = CoreMLSampler(temperature: 1.0, topP: 1.0, topK: 0)
-        let logits = makeLogits([1.0, 2.0, 3.0, 4.0])
-        for _ in 0 ..< 100 {
-            let token = s.sample(logits: logits)
-            XCTAssertGreaterThanOrEqual(token, 0)
-            XCTAssertLessThan(token, 4)
-        }
-    }
-
-    func testTopPTruncationFavorsHighProb() {
-        // With top_p = 0.5 and a sharply skewed distribution, only the top
-        // few tokens should ever be selected.
-        let s = CoreMLSampler(temperature: 1.0, topP: 0.5, topK: 0)
-        // Logits chosen so that softmax(logits) ≈ [0.0, 0.0, 0.05, 0.95]
-        let logits = makeLogits([-100.0, -100.0, 1.0, 4.0])
-        var counts = [0, 0, 0, 0]
-        for _ in 0 ..< 1000 { counts[s.sample(logits: logits)] += 1 }
-        XCTAssertEqual(counts[0], 0)
-        XCTAssertEqual(counts[1], 0)
-        XCTAssertGreaterThan(counts[3], counts[2])  // 4.0 picked far more often than 1.0
-    }
-}
+import XCTest
+import CoreML
+@testable import DVAICoreMLCore
+
+final class CoreMLSamplerTests: XCTestCase {
+    func makeLogits(_ vals: [Float]) -> MLMultiArray {
+        let arr = try! MLMultiArray(shape: [NSNumber(value: vals.count)], dataType: .float32)
+        for (i, v) in vals.enumerated() { arr[i] = NSNumber(value: v) }
+        return arr
+    }
+
+    func testGreedyReturnsArgmax() {
+        let s = CoreMLSampler(temperature: 0, topP: 1.0, topK: 0)
+        let logits = makeLogits([1.0, 5.0, 2.0, 4.0])
+        XCTAssertEqual(s.sample(logits: logits), 1)  // argmax index
+    }
+
+    func testTemperatureSamplingNeverThrows() {
+        let s = CoreMLSampler(temperature: 1.0, topP: 1.0, topK: 0)
+        let logits = makeLogits([1.0, 2.0, 3.0, 4.0])
+        for _ in 0 ..< 100 {
+            let token = s.sample(logits: logits)
+            XCTAssertGreaterThanOrEqual(token, 0)
+            XCTAssertLessThan(token, 4)
+        }
+    }
+
+    func testTopPTruncationFavorsHighProb() {
+        // With top_p = 0.5 and a sharply skewed distribution, only the top
+        // few tokens should ever be selected.
+        let s = CoreMLSampler(temperature: 1.0, topP: 0.5, topK: 0)
+        // Logits chosen so that softmax(logits) ≈ [0.0, 0.0, 0.05, 0.95]
+        let logits = makeLogits([-100.0, -100.0, 1.0, 4.0])
+        var counts = [0, 0, 0, 0]
+        for _ in 0 ..< 1000 { counts[s.sample(logits: logits)] += 1 }
+        XCTAssertEqual(counts[0], 0)
+        XCTAssertEqual(counts[1], 0)
+        XCTAssertGreaterThan(counts[3], counts[2])  // 4.0 picked far more often than 1.0
+    }
+}

package/ios/Tests/DVAIBridgeTests/CoreMLTokenizerTests.swift

@@ -1,19 +1,19 @@
-import XCTest
-@testable import DVAICoreMLCore
-
-final class CoreMLTokenizerTests: XCTestCase {
-    func testInitFailsForMissingDir() async {
-        let bogus = URL(fileURLWithPath: "/tmp/no-such-tokenizer-dir-xyz")
-        do {
-            _ = try await CoreMLTokenizer(tokenizerDir: bogus)
-            XCTFail("Expected throw for missing tokenizer dir")
-        } catch let err as CoreMLBackendError {
-            guard case .tokenizerLoadFailed = err else {
-                return XCTFail("wrong error type: \(err)")
-            }
-            // Pass — missing dir correctly converts to tokenizerLoadFailed
-        } catch {
-            XCTFail("wrong error type: \(error)")
-        }
-    }
-}
+import XCTest
+@testable import DVAICoreMLCore
+
+final class CoreMLTokenizerTests: XCTestCase {
+    func testInitFailsForMissingDir() async {
+        let bogus = URL(fileURLWithPath: "/tmp/no-such-tokenizer-dir-xyz")
+        do {
+            _ = try await CoreMLTokenizer(tokenizerDir: bogus)
+            XCTFail("Expected throw for missing tokenizer dir")
+        } catch let err as CoreMLBackendError {
+            guard case .tokenizerLoadFailed = err else {
+                return XCTFail("wrong error type: \(err)")
+            }
+            // Pass — missing dir correctly converts to tokenizerLoadFailed
+        } catch {
+            XCTFail("wrong error type: \(error)")
+        }
+    }
+}

package/ios/Tests/DVAIBridgeTests/DVAIBridgeAPIShapeTests.swift

@@ -1,37 +1,37 @@
-import XCTest
-@testable import DVAIBridge
-
-final class DVAIBridgeAPIShapeTests: XCTestCase {
-    func testSingletonExists() {
-        let bridge: DVAIBridge = DVAIBridge.shared
-        XCTAssertNotNil(bridge)
-    }
-
-    func testStatusBeforeStartReportsNotRunning() async {
-        let bridge = DVAIBridge()  // fresh instance for test isolation
-        let info = await bridge.status()
-        XCTAssertFalse(info.running)
-        XCTAssertNil(info.backend)
-        XCTAssertNil(info.baseUrl)
-    }
-
-    func testStopWhenNotStartedIsIdempotent() async throws {
-        let bridge = DVAIBridge()
-        try await bridge.stop()
-        try await bridge.stop()  // no throw
-    }
-
-    func testStartCoreMLThrowsBackendUnavailable() async {
-        let bridge = DVAIBridge()
-        do {
-            _ = try await bridge.start(.init(backend: .coreml))
-            XCTFail("Expected throw")
-        } catch let err as DVAIBridgeError {
-            if case .backendUnavailable(.coreml, _) = err { /* expected */ } else {
-                XCTFail("wrong error: \(err)")
-            }
-        } catch {
-            XCTFail("wrong error type: \(error)")
-        }
-    }
-}
+import XCTest
+@testable import DVAIBridge
+
+final class DVAIBridgeAPIShapeTests: XCTestCase {
+    func testSingletonExists() {
+        let bridge: DVAIBridge = DVAIBridge.shared
+        XCTAssertNotNil(bridge)
+    }
+
+    func testStatusBeforeStartReportsNotRunning() async {
+        let bridge = DVAIBridge()  // fresh instance for test isolation
+        let info = await bridge.status()
+        XCTAssertFalse(info.running)
+        XCTAssertNil(info.backend)
+        XCTAssertNil(info.baseUrl)
+    }
+
+    func testStopWhenNotStartedIsIdempotent() async throws {
+        let bridge = DVAIBridge()
+        try await bridge.stop()
+        try await bridge.stop()  // no throw
+    }
+
+    func testStartCoreMLThrowsBackendUnavailable() async {
+        let bridge = DVAIBridge()
+        do {
+            _ = try await bridge.start(.init(backend: .coreml))
+            XCTFail("Expected throw")
+        } catch let err as DVAIBridgeError {
+            if case .backendUnavailable(.coreml, _) = err { /* expected */ } else {
+                XCTFail("wrong error: \(err)")
+            }
+        } catch {
+            XCTFail("wrong error type: \(error)")
+        }
+    }
+}

package/ios/Tests/DVAIBridgeTests/DVAIBridgeConfigTests.swift

@@ -1,52 +1,52 @@
-import XCTest
-@testable import DVAIBridge
-
-final class DVAIBridgeConfigTests: XCTestCase {
-    func testDefaultsMatchSpec() {
-        let c = DVAIBridgeConfig()
-        XCTAssertEqual(c.backend, .auto)
-        XCTAssertNil(c.modelPath)
-        XCTAssertEqual(c.gpuLayers, 99)
-        XCTAssertEqual(c.contextSize, 2048)
-        XCTAssertEqual(c.threads, 4)
-        XCTAssertFalse(c.embeddingMode)
-        XCTAssertEqual(c.httpBasePort, 38883)
-        XCTAssertEqual(c.httpMaxPortAttempts, 16)
-        XCTAssertFalse(c.autoUnloadOnLowMemory)
-        XCTAssertEqual(c.logLevel, "info")
-    }
-
-    func testToCoreOptsWildcardCors() {
-        let c = DVAIBridgeConfig(modelPath: "/x.gguf")
-        let opts = c.toCoreOpts()
-        XCTAssertEqual(opts["modelPath"] as? String, "/x.gguf")
-        XCTAssertEqual(opts["corsOrigin"] as? String, "*")
-    }
-
-    func testToCoreOptsExactCors() {
-        let c = DVAIBridgeConfig(corsOrigin: .exact("https://example.com"))
-        XCTAssertEqual(c.toCoreOpts()["corsOrigin"] as? String, "https://example.com")
-    }
-
-    func testToCoreOptsAllowlistCors() {
-        let c = DVAIBridgeConfig(corsOrigin: .allowlist(["https://a.com", "https://b.com"]))
-        XCTAssertEqual(c.toCoreOpts()["corsOrigin"] as? [String], ["https://a.com", "https://b.com"])
-    }
-
-    func testBoundServerInitFromCoreResult() throws {
-        let result: [String: Any] = [
-            "baseUrl": "http://127.0.0.1:38883/v1",
-            "port": 38883,
-            "modelId": "test-model"
-        ]
-        let server = try BoundServer(coreResult: result, backend: .llama)
-        XCTAssertEqual(server.baseUrl, "http://127.0.0.1:38883/v1")
-        XCTAssertEqual(server.port, 38883)
-        XCTAssertEqual(server.backend, .llama)
-        XCTAssertEqual(server.modelId, "test-model")
-    }
-
-    func testBoundServerInitMalformedResult() {
-        XCTAssertThrowsError(try BoundServer(coreResult: ["baseUrl": "x"], backend: .llama))
-    }
-}
+import XCTest
+@testable import DVAIBridge
+
+final class DVAIBridgeConfigTests: XCTestCase {
+    func testDefaultsMatchSpec() {
+        let c = DVAIBridgeConfig()
+        XCTAssertEqual(c.backend, .auto)
+        XCTAssertNil(c.modelPath)
+        XCTAssertEqual(c.gpuLayers, 99)
+        XCTAssertEqual(c.contextSize, 2048)
+        XCTAssertEqual(c.threads, 4)
+        XCTAssertFalse(c.embeddingMode)
+        XCTAssertEqual(c.httpBasePort, 38883)
+        XCTAssertEqual(c.httpMaxPortAttempts, 16)
+        XCTAssertFalse(c.autoUnloadOnLowMemory)
+        XCTAssertEqual(c.logLevel, "info")
+    }
+
+    func testToCoreOptsWildcardCors() {
+        let c = DVAIBridgeConfig(modelPath: "/x.gguf")
+        let opts = c.toCoreOpts()
+        XCTAssertEqual(opts["modelPath"] as? String, "/x.gguf")
+        XCTAssertEqual(opts["corsOrigin"] as? String, "*")
+    }
+
+    func testToCoreOptsExactCors() {
+        let c = DVAIBridgeConfig(corsOrigin: .exact("https://example.com"))
+        XCTAssertEqual(c.toCoreOpts()["corsOrigin"] as? String, "https://example.com")
+    }
+
+    func testToCoreOptsAllowlistCors() {
+        let c = DVAIBridgeConfig(corsOrigin: .allowlist(["https://a.com", "https://b.com"]))
+        XCTAssertEqual(c.toCoreOpts()["corsOrigin"] as? [String], ["https://a.com", "https://b.com"])
+    }
+
+    func testBoundServerInitFromCoreResult() throws {
+        let result: [String: Any] = [
+            "baseUrl": "http://127.0.0.1:38883/v1",
+            "port": 38883,
+            "modelId": "test-model"
+        ]
+        let server = try BoundServer(coreResult: result, backend: .llama)
+        XCTAssertEqual(server.baseUrl, "http://127.0.0.1:38883/v1")
+        XCTAssertEqual(server.port, 38883)
+        XCTAssertEqual(server.backend, .llama)
+        XCTAssertEqual(server.modelId, "test-model")
+    }
+
+    func testBoundServerInitMalformedResult() {
+        XCTAssertThrowsError(try BoundServer(coreResult: ["baseUrl": "x"], backend: .llama))
+    }
+}

package/ios/Tests/DVAIBridgeTests/DVAIBridgeErrorTests.swift

@@ -1,33 +1,33 @@
-import XCTest
-@testable import DVAIBridge
-
-final class DVAIBridgeErrorTests: XCTestCase {
-    func testErrorDescriptionsAreUserFacing() {
-        let cases: [(DVAIBridgeError, String)] = [
-            (.notStarted, "has not been started"),
-            (.alreadyStarted(currentBackend: .llama, baseUrl: "http://127.0.0.1:38883/v1"), "already running"),
-            (.configurationInvalid(reason: "x"), "invalid"),
-            (.backendUnavailable(.foundation, reason: "iOS 26+ required"), "unavailable"),
-            (.modelLoadFailed(reason: "x"), "Model load failed"),
-            (.downloadFailed(reason: "x"), "Download failed"),
-            (.checksumMismatch, "SHA-256"),
-            (.backendError(underlying: "x"), "Backend error"),
-        ]
-        for (err, expectedFragment) in cases {
-            XCTAssertNotNil(err.errorDescription, "error has no description: \(err)")
-            XCTAssertTrue(
-                err.errorDescription!.contains(expectedFragment),
-                "expected '\(expectedFragment)' in '\(err.errorDescription!)'"
-            )
-        }
-    }
-
-    func testBackendKindAllCases() {
-        XCTAssertEqual(BackendKind.allCases.count, 5)
-        XCTAssertTrue(BackendKind.allCases.contains(.auto))
-        XCTAssertTrue(BackendKind.allCases.contains(.llama))
-        XCTAssertTrue(BackendKind.allCases.contains(.foundation))
-        XCTAssertTrue(BackendKind.allCases.contains(.coreml))
-        XCTAssertTrue(BackendKind.allCases.contains(.mlx))
-    }
-}
+import XCTest
+@testable import DVAIBridge
+
+final class DVAIBridgeErrorTests: XCTestCase {
+    func testErrorDescriptionsAreUserFacing() {
+        let cases: [(DVAIBridgeError, String)] = [
+            (.notStarted, "has not been started"),
+            (.alreadyStarted(currentBackend: .llama, baseUrl: "http://127.0.0.1:38883/v1"), "already running"),
+            (.configurationInvalid(reason: "x"), "invalid"),
+            (.backendUnavailable(.foundation, reason: "iOS 26+ required"), "unavailable"),
+            (.modelLoadFailed(reason: "x"), "Model load failed"),
+            (.downloadFailed(reason: "x"), "Download failed"),
+            (.checksumMismatch, "SHA-256"),
+            (.backendError(underlying: "x"), "Backend error"),
+        ]
+        for (err, expectedFragment) in cases {
+            XCTAssertNotNil(err.errorDescription, "error has no description: \(err)")
+            XCTAssertTrue(
+                err.errorDescription!.contains(expectedFragment),
+                "expected '\(expectedFragment)' in '\(err.errorDescription!)'"
+            )
+        }
+    }
+
+    func testBackendKindAllCases() {
+        XCTAssertEqual(BackendKind.allCases.count, 5)
+        XCTAssertTrue(BackendKind.allCases.contains(.auto))
+        XCTAssertTrue(BackendKind.allCases.contains(.llama))
+        XCTAssertTrue(BackendKind.allCases.contains(.foundation))
+        XCTAssertTrue(BackendKind.allCases.contains(.coreml))
+        XCTAssertTrue(BackendKind.allCases.contains(.mlx))
+    }
+}