@dvai-bridge/ios-llama-core 4.0.0 → 4.0.1

package/ios/Tests/DVAILlamaCoreTests/ImageDecoderTest.swift

@@ -1,139 +1,139 @@
-import XCTest
-@testable import DVAILlamaCore
-
-final class ImageDecoderTest: XCTestCase {
-    /// `data:image/png;base64,...` round-trips to bytes whose first 8 bytes
-    /// are the canonical PNG magic header.
-    func testDataURLBase64() async throws {
-        let url = try String(contentsOf: imageFixtureURL("tiny-test-base64.txt"), encoding: .utf8)
-            .trimmingCharacters(in: .whitespacesAndNewlines)
-        let bytes = try await ImageDecoder.resolve(url: url)
-        XCTAssertEqual(
-            Array(bytes.prefix(8)),
-            [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A],
-            "expected PNG magic header"
-        )
-    }
-
-    /// `file://` URLs return the raw bytes off disk.
-    func testFileURL() async throws {
-        let pngURL = imageFixtureURL("tiny-test.png")
-        let result = try await ImageDecoder.resolve(url: pngURL.absoluteString)
-        let raw = try Data(contentsOf: pngURL)
-        XCTAssertEqual(result, raw)
-    }
-
-    /// Unsupported schemes throw `invalidScheme`.
-    func testInvalidScheme() async {
-        do {
-            _ = try await ImageDecoder.resolve(url: "ftp://example.com/x.png")
-            XCTFail("Expected throw")
-        } catch ImageSourceError.invalidScheme {
-            // expected
-        } catch {
-            XCTFail("Unexpected error type: \(error)")
-        }
-    }
-
-    /// `data:` URL with no comma → `malformedDataURL`.
-    func testMalformedDataURL() async {
-        do {
-            _ = try await ImageDecoder.resolve(url: "data:image/png;base64")
-            XCTFail("Expected throw")
-        } catch ImageSourceError.malformedDataURL {
-            // expected
-        } catch {
-            XCTFail("Unexpected error type: \(error)")
-        }
-    }
-
-    /// `https://` URL fetches response body bytes verbatim. Mocked at the
-    /// URLSession layer via `URLProtocol.registerClass` so no real network
-    /// is touched.
-    func testHTTPSFetchesBytes() async throws {
-        let payload = try Data(contentsOf: imageFixtureURL("tiny-test.png"))
-        URLProtocol.registerClass(MockURLProtocol.self)
-        defer {
-            URLProtocol.unregisterClass(MockURLProtocol.self)
-            MockURLProtocol.handler = nil
-        }
-        MockURLProtocol.handler = { request in
-            let response = HTTPURLResponse(
-                url: request.url!,
-                statusCode: 200,
-                httpVersion: "HTTP/1.1",
-                headerFields: nil
-            )!
-            return (response, payload)
-        }
-
-        let bytes = try await ImageDecoder.resolve(url: "https://example.invalid/img.png")
-        XCTAssertEqual(bytes, payload)
-    }
-
-    /// HTTP non-2xx → `ImageSourceError.httpError(status:)` carrying the code.
-    func testHTTPErrorThrowsHttpError() async {
-        URLProtocol.registerClass(MockURLProtocol.self)
-        defer {
-            URLProtocol.unregisterClass(MockURLProtocol.self)
-            MockURLProtocol.handler = nil
-        }
-        MockURLProtocol.handler = { request in
-            let response = HTTPURLResponse(
-                url: request.url!,
-                statusCode: 404,
-                httpVersion: "HTTP/1.1",
-                headerFields: nil
-            )!
-            return (response, Data())
-        }
-
-        do {
-            _ = try await ImageDecoder.resolve(url: "https://example.invalid/missing.png")
-            XCTFail("Expected throw")
-        } catch ImageSourceError.httpError(let status) {
-            XCTAssertEqual(status, 404)
-        } catch {
-            XCTFail("Unexpected error type: \(error)")
-        }
-    }
-
-    /// Walks up from this test source file until it finds the repo-root
-    /// `fixtures/` directory — same pattern as `AudioDecoderTest`.
-    private func imageFixtureURL(_ name: String) -> URL {
-        var dir = URL(fileURLWithPath: #file).deletingLastPathComponent()
-        while !FileManager.default.fileExists(atPath: dir.appendingPathComponent("fixtures").path) {
-            let parent = dir.deletingLastPathComponent()
-            if parent.path == dir.path {
-                fatalError("fixtures dir not found walking up from \(#file)")
-            }
-            dir = parent
-        }
-        return dir.appendingPathComponent("fixtures").appendingPathComponent("images").appendingPathComponent(name)
-    }
-}
-
-/// In-process `URLProtocol` stub that intercepts every URLSession request
-/// and dispatches it to a per-test handler. Registered globally via
-/// `URLProtocol.registerClass`, which `URLSession.shared` consults — so the
-/// production code under test (which uses `URLSession.shared`) is exercised
-/// without any actual network I/O.
-private final class MockURLProtocol: URLProtocol {
-    static var handler: ((URLRequest) -> (HTTPURLResponse, Data))?
-
-    override class func canInit(with request: URLRequest) -> Bool { true }
-    override class func canonicalRequest(for request: URLRequest) -> URLRequest { request }
-
-    override func startLoading() {
-        guard let handler = MockURLProtocol.handler else {
-            client?.urlProtocol(self, didFailWithError: NSError(domain: "MockURLProtocol", code: -1))
-            return
-        }
-        let (response, data) = handler(request)
-        client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
-        client?.urlProtocol(self, didLoad: data)
-        client?.urlProtocolDidFinishLoading(self)
-    }
-
-    override func stopLoading() {}
-}
+import XCTest
+@testable import DVAILlamaCore
+
+final class ImageDecoderTest: XCTestCase {
+    /// `data:image/png;base64,...` round-trips to bytes whose first 8 bytes
+    /// are the canonical PNG magic header.
+    func testDataURLBase64() async throws {
+        let url = try String(contentsOf: imageFixtureURL("tiny-test-base64.txt"), encoding: .utf8)
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        let bytes = try await ImageDecoder.resolve(url: url)
+        XCTAssertEqual(
+            Array(bytes.prefix(8)),
+            [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A],
+            "expected PNG magic header"
+        )
+    }
+
+    /// `file://` URLs return the raw bytes off disk.
+    func testFileURL() async throws {
+        let pngURL = imageFixtureURL("tiny-test.png")
+        let result = try await ImageDecoder.resolve(url: pngURL.absoluteString)
+        let raw = try Data(contentsOf: pngURL)
+        XCTAssertEqual(result, raw)
+    }
+
+    /// Unsupported schemes throw `invalidScheme`.
+    func testInvalidScheme() async {
+        do {
+            _ = try await ImageDecoder.resolve(url: "ftp://example.com/x.png")
+            XCTFail("Expected throw")
+        } catch ImageSourceError.invalidScheme {
+            // expected
+        } catch {
+            XCTFail("Unexpected error type: \(error)")
+        }
+    }
+
+    /// `data:` URL with no comma → `malformedDataURL`.
+    func testMalformedDataURL() async {
+        do {
+            _ = try await ImageDecoder.resolve(url: "data:image/png;base64")
+            XCTFail("Expected throw")
+        } catch ImageSourceError.malformedDataURL {
+            // expected
+        } catch {
+            XCTFail("Unexpected error type: \(error)")
+        }
+    }
+
+    /// `https://` URL fetches response body bytes verbatim. Mocked at the
+    /// URLSession layer via `URLProtocol.registerClass` so no real network
+    /// is touched.
+    func testHTTPSFetchesBytes() async throws {
+        let payload = try Data(contentsOf: imageFixtureURL("tiny-test.png"))
+        URLProtocol.registerClass(MockURLProtocol.self)
+        defer {
+            URLProtocol.unregisterClass(MockURLProtocol.self)
+            MockURLProtocol.handler = nil
+        }
+        MockURLProtocol.handler = { request in
+            let response = HTTPURLResponse(
+                url: request.url!,
+                statusCode: 200,
+                httpVersion: "HTTP/1.1",
+                headerFields: nil
+            )!
+            return (response, payload)
+        }
+
+        let bytes = try await ImageDecoder.resolve(url: "https://example.invalid/img.png")
+        XCTAssertEqual(bytes, payload)
+    }
+
+    /// HTTP non-2xx → `ImageSourceError.httpError(status:)` carrying the code.
+    func testHTTPErrorThrowsHttpError() async {
+        URLProtocol.registerClass(MockURLProtocol.self)
+        defer {
+            URLProtocol.unregisterClass(MockURLProtocol.self)
+            MockURLProtocol.handler = nil
+        }
+        MockURLProtocol.handler = { request in
+            let response = HTTPURLResponse(
+                url: request.url!,
+                statusCode: 404,
+                httpVersion: "HTTP/1.1",
+                headerFields: nil
+            )!
+            return (response, Data())
+        }
+
+        do {
+            _ = try await ImageDecoder.resolve(url: "https://example.invalid/missing.png")
+            XCTFail("Expected throw")
+        } catch ImageSourceError.httpError(let status) {
+            XCTAssertEqual(status, 404)
+        } catch {
+            XCTFail("Unexpected error type: \(error)")
+        }
+    }
+
+    /// Walks up from this test source file until it finds the repo-root
+    /// `fixtures/` directory — same pattern as `AudioDecoderTest`.
+    private func imageFixtureURL(_ name: String) -> URL {
+        var dir = URL(fileURLWithPath: #file).deletingLastPathComponent()
+        while !FileManager.default.fileExists(atPath: dir.appendingPathComponent("fixtures").path) {
+            let parent = dir.deletingLastPathComponent()
+            if parent.path == dir.path {
+                fatalError("fixtures dir not found walking up from \(#file)")
+            }
+            dir = parent
+        }
+        return dir.appendingPathComponent("fixtures").appendingPathComponent("images").appendingPathComponent(name)
+    }
+}
+
+/// In-process `URLProtocol` stub that intercepts every URLSession request
+/// and dispatches it to a per-test handler. Registered globally via
+/// `URLProtocol.registerClass`, which `URLSession.shared` consults — so the
+/// production code under test (which uses `URLSession.shared`) is exercised
+/// without any actual network I/O.
+private final class MockURLProtocol: URLProtocol {
+    static var handler: ((URLRequest) -> (HTTPURLResponse, Data))?
+
+    override class func canInit(with request: URLRequest) -> Bool { true }
+    override class func canonicalRequest(for request: URLRequest) -> URLRequest { request }
+
+    override func startLoading() {
+        guard let handler = MockURLProtocol.handler else {
+            client?.urlProtocol(self, didFailWithError: NSError(domain: "MockURLProtocol", code: -1))
+            return
+        }
+        let (response, data) = handler(request)
+        client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+        client?.urlProtocol(self, didLoad: data)
+        client?.urlProtocolDidFinishLoading(self)
+    }
+
+    override func stopLoading() {}
+}

package/ios/Tests/DVAILlamaCoreTests/LlamaCppBridgeTest.swift

@@ -1,131 +1,131 @@
-import XCTest
-@testable import DVAILlamaCore
-import DVAILlamaCoreObjC
-
-final class LlamaCppBridgeTest: XCTestCase {
-    func testInitiallyNotLoaded() {
-        let bridge = LlamaCppBridge()
-        XCTAssertFalse(bridge.isLoaded)
-        XCTAssertNil(bridge.currentModelPath)
-    }
-
-    func testLoadEmptyPathFails() {
-        let bridge = LlamaCppBridge()
-        XCTAssertThrowsError(
-            try bridge.loadModel(
-                atPath: "",
-                mmprojPath: nil,
-                gpuLayers: 99,
-                contextSize: 2048,
-                threads: 4,
-                embeddingMode: false
-            )
-        )
-        XCTAssertFalse(bridge.isLoaded)
-    }
-
-    func testLoadFakePathFails() {
-        let bridge = LlamaCppBridge()
-        XCTAssertThrowsError(
-            try bridge.loadModel(
-                atPath: "/tmp/definitely-does-not-exist.gguf",
-                mmprojPath: nil,
-                gpuLayers: 99,
-                contextSize: 2048,
-                threads: 4,
-                embeddingMode: false
-            )
-        )
-        XCTAssertFalse(bridge.isLoaded)
-        XCTAssertNil(bridge.currentModelPath)
-    }
-
-    func testVersionStringContainsLlama() {
-        let bridge = LlamaCppBridge()
-        let version = bridge.versionString()
-        let prefix = "llama.cpp "
-        XCTAssertTrue(
-            version.hasPrefix(prefix),
-            "expected versionString to start with '\(prefix)', got: \(version)"
-        )
-        XCTAssertGreaterThan(
-            version.count,
-            prefix.count,
-            "expected versionString to include system info after prefix, got: \(version)"
-        )
-    }
-
-    // MARK: - Multimodal stubs (Phase 2A Pass 1)
-
-    func testInitiallyMmprojNotLoaded() {
-        let bridge = LlamaCppBridge()
-        XCTAssertFalse(bridge.isMmprojLoaded)
-    }
-
-    func testLoadMmprojRequiresMainModel() {
-        let bridge = LlamaCppBridge()
-        // Main model never loaded -> should fail with code 31.
-        XCTAssertThrowsError(try bridge.loadMmproj(atPath: "/tmp/fake-mmproj.gguf"))
-        XCTAssertFalse(bridge.isMmprojLoaded)
-    }
-
-    func testEmptyMmprojPathFails() {
-        let bridge = LlamaCppBridge()
-        XCTAssertThrowsError(try bridge.loadMmproj(atPath: ""))
-        XCTAssertFalse(bridge.isMmprojLoaded)
-    }
-
-    func testUnloadMmprojIsIdempotent() {
-        let bridge = LlamaCppBridge()
-        // Repeated unload calls on a never-loaded bridge must not crash.
-        bridge.unloadMmproj()
-        bridge.unloadMmproj()
-        XCTAssertFalse(bridge.isMmprojLoaded)
-    }
-
-    // MARK: - Multimodal — Phase 2A Pass 2
-
-    /// Without a loaded model, completeMultimodalPrompt must return an error
-    /// (code 50, "Model not loaded"). We can verify this without a real model.
-    func testCompleteMultimodalRequiresModelLoaded() {
-        let bridge = LlamaCppBridge()
-        XCTAssertFalse(bridge.isLoaded)
-        XCTAssertThrowsError(
-            try bridge.completeMultimodalPrompt(
-                "ignored <__media__>",
-                media: [Data([0x00, 0x01, 0x02])],
-                maxTokens: 8,
-                temperature: 0.0,
-                topP: 1.0
-            )
-        ) { error in
-            let nsErr = error as NSError
-            XCTAssertEqual(nsErr.domain, "DVAIBridgeLlama")
-            XCTAssertEqual(nsErr.code, 50, "expected code 50 (Model not loaded)")
-        }
-    }
-
-    /// applyChatTemplate without a loaded model returns the "Model not loaded"
-    /// error (code 40). Same can-run-without-model property as above.
-    func testApplyChatTemplateRequiresModelLoaded() {
-        let bridge = LlamaCppBridge()
-        XCTAssertFalse(bridge.isLoaded)
-        XCTAssertThrowsError(
-            try bridge.applyChatTemplate(
-                nil,
-                messages: [["role": "user", "content": "hi"]],
-                addAssistant: true
-            )
-        ) { error in
-            let nsErr = error as NSError
-            XCTAssertEqual(nsErr.domain, "DVAIBridgeLlama")
-            XCTAssertEqual(nsErr.code, 40, "expected code 40 (Model not loaded)")
-        }
-    }
-
-    /// hasAudioEncoder is always false when no mmproj is loaded.
-    func testHasAudioEncoderFalseWithoutMmproj() {
-        let bridge = LlamaCppBridge()
-        XCTAssertFalse(bridge.hasAudioEncoder())
-    }
-}
+import XCTest
+@testable import DVAILlamaCore
+import DVAILlamaCoreObjC
+
+final class LlamaCppBridgeTest: XCTestCase {
+    func testInitiallyNotLoaded() {
+        let bridge = LlamaCppBridge()
+        XCTAssertFalse(bridge.isLoaded)
+        XCTAssertNil(bridge.currentModelPath)
+    }
+
+    func testLoadEmptyPathFails() {
+        let bridge = LlamaCppBridge()
+        XCTAssertThrowsError(
+            try bridge.loadModel(
+                atPath: "",
+                mmprojPath: nil,
+                gpuLayers: 99,
+                contextSize: 2048,
+                threads: 4,
+                embeddingMode: false
+            )
+        )
+        XCTAssertFalse(bridge.isLoaded)
+    }
+
+    func testLoadFakePathFails() {
+        let bridge = LlamaCppBridge()
+        XCTAssertThrowsError(
+            try bridge.loadModel(
+                atPath: "/tmp/definitely-does-not-exist.gguf",
+                mmprojPath: nil,
+                gpuLayers: 99,
+                contextSize: 2048,
+                threads: 4,
+                embeddingMode: false
+            )
+        )
+        XCTAssertFalse(bridge.isLoaded)
+        XCTAssertNil(bridge.currentModelPath)
+    }
+
+    func testVersionStringContainsLlama() {
+        let bridge = LlamaCppBridge()
+        let version = bridge.versionString()
+        let prefix = "llama.cpp "
+        XCTAssertTrue(
+            version.hasPrefix(prefix),
+            "expected versionString to start with '\(prefix)', got: \(version)"
+        )
+        XCTAssertGreaterThan(
+            version.count,
+            prefix.count,
+            "expected versionString to include system info after prefix, got: \(version)"
+        )
+    }
+
+    // MARK: - Multimodal stubs (Phase 2A Pass 1)
+
+    func testInitiallyMmprojNotLoaded() {
+        let bridge = LlamaCppBridge()
+        XCTAssertFalse(bridge.isMmprojLoaded)
+    }
+
+    func testLoadMmprojRequiresMainModel() {
+        let bridge = LlamaCppBridge()
+        // Main model never loaded -> should fail with code 31.
+        XCTAssertThrowsError(try bridge.loadMmproj(atPath: "/tmp/fake-mmproj.gguf"))
+        XCTAssertFalse(bridge.isMmprojLoaded)
+    }
+
+    func testEmptyMmprojPathFails() {
+        let bridge = LlamaCppBridge()
+        XCTAssertThrowsError(try bridge.loadMmproj(atPath: ""))
+        XCTAssertFalse(bridge.isMmprojLoaded)
+    }
+
+    func testUnloadMmprojIsIdempotent() {
+        let bridge = LlamaCppBridge()
+        // Repeated unload calls on a never-loaded bridge must not crash.
+        bridge.unloadMmproj()
+        bridge.unloadMmproj()
+        XCTAssertFalse(bridge.isMmprojLoaded)
+    }
+
+    // MARK: - Multimodal — Phase 2A Pass 2
+
+    /// Without a loaded model, completeMultimodalPrompt must return an error
+    /// (code 50, "Model not loaded"). We can verify this without a real model.
+    func testCompleteMultimodalRequiresModelLoaded() {
+        let bridge = LlamaCppBridge()
+        XCTAssertFalse(bridge.isLoaded)
+        XCTAssertThrowsError(
+            try bridge.completeMultimodalPrompt(
+                "ignored <__media__>",
+                media: [Data([0x00, 0x01, 0x02])],
+                maxTokens: 8,
+                temperature: 0.0,
+                topP: 1.0
+            )
+        ) { error in
+            let nsErr = error as NSError
+            XCTAssertEqual(nsErr.domain, "DVAIBridgeLlama")
+            XCTAssertEqual(nsErr.code, 50, "expected code 50 (Model not loaded)")
+        }
+    }
+
+    /// applyChatTemplate without a loaded model returns the "Model not loaded"
+    /// error (code 40). Same can-run-without-model property as above.
+    func testApplyChatTemplateRequiresModelLoaded() {
+        let bridge = LlamaCppBridge()
+        XCTAssertFalse(bridge.isLoaded)
+        XCTAssertThrowsError(
+            try bridge.applyChatTemplate(
+                nil,
+                messages: [["role": "user", "content": "hi"]],
+                addAssistant: true
+            )
+        ) { error in
+            let nsErr = error as NSError
+            XCTAssertEqual(nsErr.domain, "DVAIBridgeLlama")
+            XCTAssertEqual(nsErr.code, 40, "expected code 40 (Model not loaded)")
+        }
+    }
+
+    /// hasAudioEncoder is always false when no mmproj is loaded.
+    func testHasAudioEncoderFalseWithoutMmproj() {
+        let bridge = LlamaCppBridge()
+        XCTAssertFalse(bridge.hasAudioEncoder())
+    }
+}