@kaeawc/auto-mobile 0.0.44 → 0.0.45

package/dist/ios/screen-capture/Tests/ScreenCaptureCoreTests/CommandLineOptionsTests.swift

@@ -0,0 +1,181 @@
+import XCTest
+@testable import ScreenCaptureCore
+
+final class CommandLineOptionsTests: XCTestCase {
+    func testParsesAudioForSimulatorCapture() throws {
+        let options = try CommandLineOptions.parse([
+            "screen-capture-helper", "--simulator-window", "42", "--audio"
+        ])
+
+        XCTAssertEqual(options.mode, .captureSimulator(windowID: 42, fps: 5, audio: true))
+    }
+
+    func testDefaultsToCaptureWithoutDeviceID() throws {
+        let opts = try CommandLineOptions.parse(["screen-capture-helper"])
+        XCTAssertEqual(opts.mode, .capture(deviceID: nil))
+    }
+
+    func testParsesDeviceID() throws {
+        let opts = try CommandLineOptions.parse([
+            "screen-capture-helper", "--device-id", "ABC123"
+        ])
+        XCTAssertEqual(opts.mode, .capture(deviceID: "ABC123"))
+    }
+
+    func testParsesListDevices() throws {
+        let opts = try CommandLineOptions.parse([
+            "screen-capture-helper", "--list-devices"
+        ])
+        XCTAssertEqual(opts.mode, .listDevices)
+    }
+
+    func testParsesHelpFlag() throws {
+        let opts = try CommandLineOptions.parse([
+            "screen-capture-helper", "--help"
+        ])
+        XCTAssertEqual(opts.mode, .help)
+    }
+
+    func testMissingDeviceIDValueThrows() {
+        XCTAssertThrowsError(try CommandLineOptions.parse([
+            "screen-capture-helper", "--device-id"
+        ])) { error in
+            XCTAssertEqual(
+                error as? CommandLineOptions.ParseError,
+                .missingValue(flag: "--device-id")
+            )
+        }
+    }
+
+    func testUnknownArgumentThrows() {
+        XCTAssertThrowsError(try CommandLineOptions.parse([
+            "screen-capture-helper", "--bogus"
+        ])) { error in
+            XCTAssertEqual(
+                error as? CommandLineOptions.ParseError,
+                .unknownArgument("--bogus")
+            )
+        }
+    }
+
+    func testParsesListSimulators() throws {
+        let opts = try CommandLineOptions.parse([
+            "screen-capture-helper", "--list-simulators"
+        ])
+        XCTAssertEqual(opts.mode, .listSimulators)
+    }
+
+    func testParsesSimulatorWindowWithDefaultFPS() throws {
+        let opts = try CommandLineOptions.parse([
+            "screen-capture-helper", "--simulator-window", "98765"
+        ])
+        XCTAssertEqual(
+            opts.mode,
+            .captureSimulator(
+                windowID: 98765,
+                fps: CommandLineOptions.defaultSimulatorFPS,
+                audio: false
+            )
+        )
+    }
+
+    func testParsesSimulatorFPSWithinRange() throws {
+        let opts = try CommandLineOptions.parse([
+            "screen-capture-helper",
+            "--simulator-window", "1",
+            "--simulator-fps", "30",
+        ])
+        XCTAssertEqual(opts.mode, .captureSimulator(windowID: 1, fps: 30, audio: false))
+    }
+
+    func testRejectsSimulatorFPSBelowRange() {
+        XCTAssertThrowsError(try CommandLineOptions.parse([
+            "screen-capture-helper",
+            "--simulator-window", "1",
+            "--simulator-fps", "4",
+        ])) { error in
+            XCTAssertEqual(
+                error as? CommandLineOptions.ParseError,
+                .invalidValue(flag: "--simulator-fps", value: "4")
+            )
+        }
+    }
+
+    func testRejectsSimulatorFPSAboveRange() {
+        XCTAssertThrowsError(try CommandLineOptions.parse([
+            "screen-capture-helper",
+            "--simulator-window", "1",
+            "--simulator-fps", "61",
+        ])) { error in
+            XCTAssertEqual(
+                error as? CommandLineOptions.ParseError,
+                .invalidValue(flag: "--simulator-fps", value: "61")
+            )
+        }
+    }
+
+    func testRejectsSimulatorFPSWithoutWindow() {
+        XCTAssertThrowsError(try CommandLineOptions.parse([
+            "screen-capture-helper", "--simulator-fps", "15",
+        ])) { error in
+            guard case CommandLineOptions.ParseError.conflictingFlags = error else {
+                XCTFail("expected conflictingFlags, got \(error)")
+                return
+            }
+        }
+    }
+
+    func testDefaultSimulatorFPSConstantIs5() {
+        XCTAssertEqual(CommandLineOptions.defaultSimulatorFPS, 5)
+        XCTAssertEqual(CommandLineOptions.minSimulatorFPS, 5)
+        XCTAssertEqual(CommandLineOptions.maxSimulatorFPS, 60)
+    }
+
+    func testInvalidSimulatorWindowValueThrows() {
+        XCTAssertThrowsError(try CommandLineOptions.parse([
+            "screen-capture-helper", "--simulator-window", "not-a-number"
+        ])) { error in
+            XCTAssertEqual(
+                error as? CommandLineOptions.ParseError,
+                .invalidValue(flag: "--simulator-window", value: "not-a-number")
+            )
+        }
+    }
+
+    func testMissingSimulatorWindowValueThrows() {
+        XCTAssertThrowsError(try CommandLineOptions.parse([
+            "screen-capture-helper", "--simulator-window"
+        ])) { error in
+            XCTAssertEqual(
+                error as? CommandLineOptions.ParseError,
+                .missingValue(flag: "--simulator-window")
+            )
+        }
+    }
+
+    func testConflictingDeviceAndSimulatorFlagsThrow() {
+        XCTAssertThrowsError(try CommandLineOptions.parse([
+            "screen-capture-helper",
+            "--device-id", "abc",
+            "--simulator-window", "1",
+        ])) { error in
+            guard case CommandLineOptions.ParseError.conflictingFlags = error else {
+                XCTFail("expected conflictingFlags, got \(error)")
+                return
+            }
+        }
+    }
+
+    func testConflictingListFlagsThrow() {
+        XCTAssertThrowsError(try CommandLineOptions.parse([
+            "screen-capture-helper",
+            "--list-devices",
+            "--list-simulators",
+        ])) { error in
+            guard case CommandLineOptions.ParseError.conflictingFlags = error else {
+                XCTFail("expected conflictingFlags, got \(error)")
+                return
+            }
+        }
+    }
+}

package/dist/ios/screen-capture/Tests/ScreenCaptureCoreTests/DeviceInfoTests.swift

@@ -0,0 +1,35 @@
+import XCTest
+@testable import ScreenCaptureCore
+
+final class DeviceInfoTests: XCTestCase {
+    func testRoundTripsThroughJSON() throws {
+        let original = DeviceListResponse(devices: [
+            DeviceInfo(
+                uniqueID: "00008140-001A2B3C0AE2401E",
+                localizedName: "iPhone",
+                modelID: "iPhone15,2",
+                manufacturer: "Apple"
+            )
+        ])
+        let data = try JSONEncoder().encode(original)
+        let decoded = try JSONDecoder().decode(DeviceListResponse.self, from: data)
+        XCTAssertEqual(decoded, original)
+    }
+
+    func testJSONUsesExpectedKeys() throws {
+        let device = DeviceInfo(
+            uniqueID: "id",
+            localizedName: "name",
+            modelID: "model",
+            manufacturer: "vendor"
+        )
+        let data = try JSONEncoder().encode(device)
+        let json = try XCTUnwrap(
+            JSONSerialization.jsonObject(with: data) as? [String: String]
+        )
+        XCTAssertEqual(json["uniqueID"], "id")
+        XCTAssertEqual(json["localizedName"], "name")
+        XCTAssertEqual(json["modelID"], "model")
+        XCTAssertEqual(json["manufacturer"], "vendor")
+    }
+}

package/dist/ios/screen-capture/Tests/ScreenCaptureCoreTests/FrameProtocolTests.swift

@@ -0,0 +1,123 @@
+// swiftlint:disable force_unwrapping
+// Force-unwrap is idiomatic in test fixtures (fail fast on bad setup); disabled file-wide.
+
+import XCTest
+@testable import ScreenCaptureCore
+
+final class FrameProtocolTests: XCTestCase {
+    func testEncodeAudioHeaderUsesReservedZeroWidthMarker() {
+        let data = FrameProtocol.encodeAudioHeader(payloadLength: 320)
+
+        XCTAssertEqual(data.count, FrameProtocol.headerSize)
+        // Marker "AMF1" on the wire.
+        XCTAssertEqual(Array(data.prefix(4)), [0x41, 0x4D, 0x46, 0x31])
+        // Field bytes (offset 8): width=0, height=8000 (0x1F40), bytesPerRow=1, timestampMs=320 (0x140).
+        XCTAssertEqual(Array(data[8..<24]), [
+            0, 0, 0, 0,
+            0x40, 0x1F, 0, 0,
+            1, 0, 0, 0,
+            0x40, 1, 0, 0,
+        ])
+        XCTAssertEqual(
+            FrameProtocol.decodeHeader(data),
+            FrameProtocol.Header(width: 0, height: 8_000, bytesPerRow: 1, timestampMs: 320)
+        )
+    }
+
+    func testEncodeHeaderPlacesMarkerChecksumAndLittleEndianFields() {
+        let header = FrameProtocol.Header(
+            width: 0x01020304,
+            height: 0x05060708,
+            bytesPerRow: 0x090A0B0C,
+            timestampMs: 0x0D0E0F10
+        )
+        let data = FrameProtocol.encodeHeader(header)
+        XCTAssertEqual(data.count, FrameProtocol.headerSize)
+        XCTAssertEqual(data.withUnsafeBytes { $0.loadUnaligned(as: UInt32.self).littleEndian }, FrameProtocol.magic)
+        XCTAssertEqual(Array(data[8..<24]), [
+            0x04, 0x03, 0x02, 0x01,
+            0x08, 0x07, 0x06, 0x05,
+            0x0C, 0x0B, 0x0A, 0x09,
+            0x10, 0x0F, 0x0E, 0x0D,
+        ])
+        // The stored checksum matches the CRC-32 of the field bytes.
+        let storedChecksum = data.dropFirst(4).withUnsafeBytes { $0.loadUnaligned(as: UInt32.self).littleEndian }
+        XCTAssertEqual(storedChecksum, FrameProtocol.crc32(data.subdata(in: 8..<24)))
+        XCTAssertEqual(FrameProtocol.decodeHeader(data), header)
+    }
+
+    func testCrc32MatchesStandardCheckVector() {
+        // The canonical CRC-32 check value for the ASCII string "123456789",
+        // shared with the TypeScript decoder so the two agree byte for byte.
+        XCTAssertEqual(FrameProtocol.crc32(Data("123456789".utf8)), 0xCBF4_3926)
+    }
+
+    func testDecodeRejectsWrongMarker() {
+        var data = FrameProtocol.encodeHeader(
+            FrameProtocol.Header(width: 2, height: 2, bytesPerRow: 8, timestampMs: 1)
+        )
+        data[0] ^= 0xFF // corrupt the marker
+        XCTAssertNil(FrameProtocol.decodeHeader(data))
+    }
+
+    func testDecodeRejectsWrongChecksum() {
+        var data = FrameProtocol.encodeHeader(
+            FrameProtocol.Header(width: 2, height: 2, bytesPerRow: 8, timestampMs: 1)
+        )
+        data[8] ^= 0xFF // corrupt a field without fixing the checksum
+        XCTAssertNil(FrameProtocol.decodeHeader(data))
+    }
+
+    func testDecodeHeaderRoundTrip() {
+        let header = FrameProtocol.Header(
+            width: 1170,
+            height: 2532,
+            bytesPerRow: 4680,
+            timestampMs: 1_234_567
+        )
+        let data = FrameProtocol.encodeHeader(header)
+        XCTAssertEqual(FrameProtocol.decodeHeader(data), header)
+    }
+
+    func testDecodeRejectsShortBuffer() {
+        let truncated = Data(repeating: 0, count: FrameProtocol.headerSize - 1)
+        XCTAssertNil(FrameProtocol.decodeHeader(truncated))
+    }
+
+    /// Decoding a header from an unaligned buffer must not trap. The pre-fix
+    /// `load(as:)` requires 4-byte alignment; feeding it a header at an odd
+    /// address traps in debug (issue #3627). `loadUnaligned` decodes correctly.
+    func testDecodeHeaderHandlesUnalignedBuffer() {
+        let header = FrameProtocol.Header(
+            width: 0x1122_3344,
+            height: 0x5566_7788,
+            bytesPerRow: 0x99AA_BBCC,
+            timestampMs: 0xDDEE_FF00
+        )
+        let encoded = FrameProtocol.encodeHeader(header)
+
+        // Place the 16 header bytes at an odd (unaligned) offset in a raw buffer.
+        let raw = UnsafeMutableRawPointer.allocate(
+            byteCount: FrameProtocol.headerSize + 1,
+            alignment: 1
+        )
+        defer { raw.deallocate() }
+        encoded.withUnsafeBytes { src in
+            raw.advanced(by: 1).copyMemory(from: src.baseAddress!, byteCount: FrameProtocol.headerSize)
+        }
+        let unaligned = Data(
+            bytesNoCopy: raw.advanced(by: 1),
+            count: FrameProtocol.headerSize,
+            deallocator: .none
+        )
+
+        XCTAssertEqual(FrameProtocol.decodeHeader(unaligned), header)
+    }
+
+    func testEncodeDecodeRoundTrip() {
+        let header = FrameProtocol.Header(
+            width: 1290, height: 2796, bytesPerRow: 5160, timestampMs: 123_456
+        )
+        XCTAssertEqual(FrameProtocol.decodeHeader(FrameProtocol.encodeHeader(header)), header)
+    }
+}

package/dist/ios/screen-capture/Tests/ScreenCaptureCoreTests/FrameWriterTests.swift

@@ -0,0 +1,62 @@
+// swiftlint:disable force_unwrapping
+// Force-unwrap is idiomatic in test fixtures (fail fast on bad setup); disabled file-wide.
+
+import XCTest
+@testable import ScreenCaptureCore
+
+final class BufferSink: FrameSink {
+    var data = Data()
+    func write(_ chunk: Data) { data.append(chunk) }
+}
+
+final class FrameWriterTests: XCTestCase {
+    func testWritesHeaderFollowedByPayload() {
+        let sink = BufferSink()
+        let start = Date(timeIntervalSince1970: 0)
+        let writer = FrameWriter(sink: sink, startTime: start)
+
+        let width = 2
+        let height = 3
+        let bytesPerRow = 8
+        // 24 bytes of BGRA: 2px × 3 rows × 4 bytes
+        let payload = Array(0..<UInt8(bytesPerRow * height))
+
+        payload.withUnsafeBufferPointer { ptr in
+            writer.write(
+                width: width,
+                height: height,
+                bytesPerRow: bytesPerRow,
+                baseAddress: UnsafeRawPointer(ptr.baseAddress!),
+                timestamp: Date(timeIntervalSince1970: 0.5)
+            )
+        }
+
+        XCTAssertEqual(sink.data.count, FrameProtocol.headerSize + bytesPerRow * height)
+        let header = FrameProtocol.decodeHeader(sink.data.prefix(FrameProtocol.headerSize))
+        XCTAssertEqual(header?.width, UInt32(width))
+        XCTAssertEqual(header?.height, UInt32(height))
+        XCTAssertEqual(header?.bytesPerRow, UInt32(bytesPerRow))
+        XCTAssertEqual(header?.timestampMs, 500)
+        XCTAssertEqual(Array(sink.data.dropFirst(FrameProtocol.headerSize)), payload)
+    }
+
+    func testTimestampClampedToZeroForPriorStartTime() {
+        let sink = BufferSink()
+        let writer = FrameWriter(
+            sink: sink,
+            startTime: Date(timeIntervalSince1970: 100)
+        )
+        let payload: [UInt8] = [0, 1, 2, 3]
+        payload.withUnsafeBufferPointer { ptr in
+            writer.write(
+                width: 1,
+                height: 1,
+                bytesPerRow: 4,
+                baseAddress: UnsafeRawPointer(ptr.baseAddress!),
+                timestamp: Date(timeIntervalSince1970: 0)
+            )
+        }
+        let header = FrameProtocol.decodeHeader(sink.data.prefix(FrameProtocol.headerSize))
+        XCTAssertEqual(header?.timestampMs, 0)
+    }
+}

package/dist/ios/screen-capture/Tests/ScreenCaptureCoreTests/SimulatorAudioCaptureAvailabilityTests.swift

@@ -0,0 +1,27 @@
+import XCTest
+@testable import ScreenCaptureCore
+
+final class SimulatorAudioCaptureAvailabilityTests: XCTestCase {
+    func testAllowsAudioWhenExactlyOneSimulatorWindowIsVisible() {
+        XCTAssertNil(SimulatorAudioCaptureAvailability.errorMessage(for: [window(id: 1)]))
+    }
+
+    func testRejectsAudioWhenMultipleSimulatorWindowsAreVisible() {
+        XCTAssertEqual(
+            SimulatorAudioCaptureAvailability.errorMessage(for: [window(id: 1), window(id: 2)]),
+            "iOS Simulator audio capture requires exactly one visible Simulator window because ScreenCaptureKit cannot isolate audio to a selected Simulator window. Close other Simulator windows and try again."
+        )
+    }
+
+    private func window(id: UInt32) -> SimulatorWindowInfo {
+        SimulatorWindowInfo(
+            windowID: id,
+            title: "iPhone",
+            applicationName: "Simulator",
+            bundleIdentifier: simulatorBundleIdentifier,
+            processID: 1,
+            width: 390,
+            height: 844
+        )
+    }
+}

package/dist/ios/screen-capture/Tests/ScreenCaptureCoreTests/SimulatorWindowInfoTests.swift

@@ -0,0 +1,40 @@
+import XCTest
+@testable import ScreenCaptureCore
+
+final class SimulatorWindowInfoTests: XCTestCase {
+    func testRoundTripsThroughJSON() throws {
+        let original = SimulatorWindowListResponse(windows: [
+            SimulatorWindowInfo(
+                windowID: 12345,
+                title: "iPhone 15 Pro — iOS 17.4",
+                applicationName: "Simulator",
+                bundleIdentifier: simulatorBundleIdentifier,
+                processID: 4242,
+                width: 1170,
+                height: 2532
+            )
+        ])
+        let data = try JSONEncoder().encode(original)
+        let decoded = try JSONDecoder().decode(SimulatorWindowListResponse.self, from: data)
+        XCTAssertEqual(decoded, original)
+    }
+
+    func testTitleMayBeNil() throws {
+        let info = SimulatorWindowInfo(
+            windowID: 1,
+            title: nil,
+            applicationName: "Simulator",
+            bundleIdentifier: simulatorBundleIdentifier,
+            processID: 1,
+            width: 0,
+            height: 0
+        )
+        let data = try JSONEncoder().encode(info)
+        let decoded = try JSONDecoder().decode(SimulatorWindowInfo.self, from: data)
+        XCTAssertNil(decoded.title)
+    }
+
+    func testSimulatorBundleIdentifierConstant() {
+        XCTAssertEqual(simulatorBundleIdentifier, "com.apple.iphonesimulator")
+    }
+}