catalyst-core 0.3.0-beta.5 → 0.3.0-canary.2

package/dist/native/androidProject/app/src/test/java/io/yourname/androidproject/camera/BarcodeDetectorTest.kt

@@ -0,0 +1,132 @@
+package io.yourname.androidproject.camera
+
+import androidx.camera.core.ImageProxy
+import com.google.mlkit.vision.barcode.BarcodeScanner
+import com.google.mlkit.vision.barcode.common.Barcode
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Test
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+
+/**
+ * Unit tests for BarcodeDetector (Android coverage batch 3), previously
+ * entirely untested (0/52 lines).
+ *
+ * Scope: close() (scanner null-safe close/clear) and the private
+ * processFrame() early-return branch (imageProxy.image == null -> closes
+ * and returns) are exercised directly/indirectly. resolveFormats() and
+ * formatName() (companion) are pure and exercised via their observable
+ * effects/return values.
+ *
+ * processFrame()'s null-image early-return branch (imageProxy.image ==
+ * null -> imageProxy.close(); return) is reachable via reflection on the
+ * private method without needing a real InputImage/ML Kit Task, and is
+ * exercised that way below.
+ *
+ * Deliberately out of scope: buildImageAnalysis() itself is NOT invoked --
+ * it calls BarcodeScanning.getClient(...) and ImageAnalysis.Builder()...
+ * .build(), both of which are static/builder factories that construct real
+ * ML Kit / CameraX platform objects rather than mockable interfaces (per
+ * project rule 3: builders that delegate to real platform objects are out
+ * of scope). Likewise the non-null-image path through processFrame()
+ * (InputImage.fromMediaImage(...) then
+ * activeScanner.process(image).addOnSuccessListener{...}) is not
+ * exercised: InputImage.fromMediaImage is itself a static factory over a
+ * real android.media.Image, and BarcodeScanner.process() returns a real ML
+ * Kit Task<List<Barcode>> whose Task machinery isn't a simple mockable
+ * single-call the way ImageProxy is -- driving it would require faking ML
+ * Kit's Task/Executor internals, not just this class's collaborators.
+ */
+class BarcodeDetectorTest {
+
+    private val zoomController = mock<ZoomController>()
+
+    // ============================================================
+    // formatName (companion) -- pure, exhaustive over declared formats
+    // ============================================================
+
+    @Test
+    fun `formatName maps every documented barcode format constant to its label`() {
+        assertEquals("QR", BarcodeDetector.formatName(Barcode.FORMAT_QR_CODE))
+        assertEquals("EAN_13", BarcodeDetector.formatName(Barcode.FORMAT_EAN_13))
+        assertEquals("EAN_8", BarcodeDetector.formatName(Barcode.FORMAT_EAN_8))
+        assertEquals("CODE_128", BarcodeDetector.formatName(Barcode.FORMAT_CODE_128))
+        assertEquals("CODE_39", BarcodeDetector.formatName(Barcode.FORMAT_CODE_39))
+        assertEquals("DATA_MATRIX", BarcodeDetector.formatName(Barcode.FORMAT_DATA_MATRIX))
+        assertEquals("PDF417", BarcodeDetector.formatName(Barcode.FORMAT_PDF417))
+        assertEquals("AZTEC", BarcodeDetector.formatName(Barcode.FORMAT_AZTEC))
+        assertEquals("UPC_A", BarcodeDetector.formatName(Barcode.FORMAT_UPC_A))
+        assertEquals("UPC_E", BarcodeDetector.formatName(Barcode.FORMAT_UPC_E))
+    }
+
+    @Test
+    fun `formatName falls back to UNKNOWN for an unrecognized format`() {
+        assertEquals("UNKNOWN", BarcodeDetector.formatName(-999))
+    }
+
+    // ============================================================
+    // close()
+    // ============================================================
+
+    @Test
+    fun `close before any scanner was built does not throw`() {
+        val detector = BarcodeDetector(zoomController) { _, _, _ -> }
+        detector.close()
+    }
+
+    @Test
+    fun `close is safe to call twice`() {
+        val detector = BarcodeDetector(zoomController) { _, _, _ -> }
+        detector.close()
+        detector.close()
+    }
+
+    // ============================================================
+    // suppressResults flag
+    // ============================================================
+
+    @Test
+    fun `suppressResults defaults to false and is settable`() {
+        val detector = BarcodeDetector(zoomController) { _, _, _ -> }
+        assertEquals(false, detector.suppressResults)
+        detector.suppressResults = true
+        assertEquals(true, detector.suppressResults)
+    }
+
+    // ============================================================
+    // Construction sanity
+    // ============================================================
+
+    @Test
+    fun `constructing BarcodeDetector does not throw`() {
+        val detector = BarcodeDetector(zoomController) { _, _, _ -> }
+        assertNotNull(detector)
+    }
+
+    // ============================================================
+    // processFrame (private) -- reached via reflection since
+    // buildImageAnalysis()'s analyzer lambda isn't otherwise reachable
+    // without a real ImageAnalysis pipeline.
+    // ============================================================
+
+    @Test
+    fun `processFrame closes the imageProxy and returns early when the image is null`() {
+        val detector = BarcodeDetector(zoomController) { _, _, _ -> }
+        val imageProxy = mock<ImageProxy>()
+        whenever(imageProxy.image).thenReturn(null)
+        val scanner = mock<BarcodeScanner>()
+
+        val method = BarcodeDetector::class.java.getDeclaredMethod(
+            "processFrame",
+            ImageProxy::class.java,
+            BarcodeScanner::class.java
+        )
+        method.isAccessible = true
+        method.invoke(detector, imageProxy, scanner)
+
+        verify(imageProxy).close()
+        org.mockito.Mockito.verifyNoInteractions(scanner)
+    }
+}

package/dist/native/androidProject/app/src/test/java/io/yourname/androidproject/camera/HoldControllerTest.kt

@@ -0,0 +1,155 @@
+package io.yourname.androidproject.camera
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+
+/**
+ * Unit tests for HoldController (Android coverage batch 3), previously
+ * entirely untested (0/28 lines).
+ *
+ * Scope: isNewValue() (pure AtomicReference compare-and-set logic) and
+ * reset() (clears state, no Handler dispatch required to observe its
+ * effect via barcodeDetector.suppressResults / lastDetectedValue) are
+ * covered directly. startHold()'s call into
+ * stateMachine.transition(HOLD) and barcodeDetector.suppressResults=true
+ * are also observable without the Handler ever firing.
+ *
+ * Deliberately out of scope, per this project's established
+ * PerfEventBufferTest precedent (documented there and required reading for
+ * this file): HoldController constructs a real
+ * Handler(Looper.getMainLooper()) at field-init time. There is no real
+ * Looper in a JVM unit test, so handler.postDelayed(...)'s posted runnable
+ * (the "hold ended, resume streaming" callback) never fires here -- the
+ * resumeRunnable's *body* (barcodeDetector.suppressResults = false,
+ * stateMachine.transition(STREAMING)) is not exercised or asserted on.
+ * Only the parts of startHold()/reset() that run synchronously before/
+ * around the postDelayed/removeCallbacks calls are covered.
+ */
+class HoldControllerTest {
+
+    private val stateMachine = mock<VideoStreamStateMachine>()
+    private val barcodeDetector = mock<BarcodeDetector>()
+
+    private fun newController() = HoldController(stateMachine, barcodeDetector)
+
+    // ============================================================
+    // startHold()
+    // ============================================================
+
+    @Test
+    fun `startHold suppresses barcode results when the state transition succeeds`() {
+        whenever(stateMachine.transition(VideoStreamState.HOLD)).thenReturn(true)
+
+        val controller = newController()
+        controller.startHold()
+
+        // barcodeDetector is a Mockito mock -- its "suppressResults" setter
+        // is intercepted rather than writing a real backing field, so the
+        // observable effect is the setter invocation, not a later getter
+        // read (which would just return the default/stubbed value).
+        verify(barcodeDetector).suppressResults = true
+        verify(stateMachine).transition(VideoStreamState.HOLD)
+    }
+
+    @Test
+    fun `startHold does not suppress results when the state transition fails`() {
+        whenever(stateMachine.transition(VideoStreamState.HOLD)).thenReturn(false)
+
+        val controller = newController()
+        controller.startHold()
+
+        // Early return on a failed transition -- suppressResults is never
+        // touched.
+        org.mockito.Mockito.verifyNoInteractions(barcodeDetector)
+    }
+
+    @Test
+    fun `startHold called twice cancels the previously scheduled runnable`() {
+        whenever(stateMachine.transition(VideoStreamState.HOLD)).thenReturn(true)
+
+        val controller = newController()
+        controller.startHold()
+        // Second call should not throw even though a runnable is already
+        // pending -- exercises the resumeRunnable?.let { handler.removeCallbacks(it) }
+        // branch with a non-null previous runnable.
+        controller.startHold()
+
+        verify(barcodeDetector, org.mockito.kotlin.times(2)).suppressResults = true
+    }
+
+    // ============================================================
+    // reset()
+    // ============================================================
+
+    @Test
+    fun `reset clears suppressResults and lastDetectedValue`() {
+        whenever(stateMachine.transition(VideoStreamState.HOLD)).thenReturn(true)
+
+        val controller = newController()
+        controller.isNewValue("abc123")
+        controller.startHold()
+
+        controller.reset()
+
+        // suppressResults is set true by startHold(), then false again by
+        // reset() -- verify the final call rather than reading back a
+        // mocked getter (see the startHold tests above for why).
+        verify(barcodeDetector).suppressResults = false
+        assertNull(controller.lastDetectedValue)
+    }
+
+    @Test
+    fun `reset with no pending hold does not throw`() {
+        val controller = newController()
+        controller.reset()
+        assertNull(controller.lastDetectedValue)
+    }
+
+    // ============================================================
+    // isNewValue()
+    // ============================================================
+
+    @Test
+    fun `isNewValue returns true for the first value seen and updates lastDetectedValue`() {
+        val controller = newController()
+
+        val result = controller.isNewValue("abc123")
+
+        assertTrue(result)
+        assertEquals("abc123", controller.lastDetectedValue)
+    }
+
+    @Test
+    fun `isNewValue returns false for a repeat of the last detected value`() {
+        val controller = newController()
+
+        controller.isNewValue("abc123")
+        val result = controller.isNewValue("abc123")
+
+        assertFalse(result)
+        assertEquals("abc123", controller.lastDetectedValue)
+    }
+
+    @Test
+    fun `isNewValue returns true when the value differs from the last detected one`() {
+        val controller = newController()
+
+        controller.isNewValue("abc123")
+        val result = controller.isNewValue("xyz789")
+
+        assertTrue(result)
+        assertEquals("xyz789", controller.lastDetectedValue)
+    }
+
+    @Test
+    fun `lastDetectedValue is null before any detection`() {
+        val controller = newController()
+        assertNull(controller.lastDetectedValue)
+    }
+}

package/dist/native/androidProject/app/src/test/java/io/yourname/androidproject/camera/TorchControllerTest.kt

@@ -0,0 +1,150 @@
+package io.yourname.androidproject.camera
+
+import android.content.Context
+import androidx.camera.core.Camera
+import androidx.camera.core.CameraControl
+import com.google.common.util.concurrent.ListenableFuture
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.mockito.kotlin.any
+import org.mockito.kotlin.argumentCaptor
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+
+/**
+ * Unit tests for TorchController (Android coverage batch 3), previously
+ * entirely untested (0/26 lines).
+ *
+ * Scope: attachCamera/detachCamera (pure field assignment) and setTorch's
+ * three branches (no camera attached, front-camera guard, and the actual
+ * enableTorch(...).addListener(...) call on a mocked Camera/CameraControl/
+ * ListenableFuture) are all covered without needing a real CameraX
+ * pipeline -- Camera/CameraControl are interfaces and ListenableFuture is
+ * a plain interface too, all mockable. notifyReset() is pure (invokes the
+ * callback, logs).
+ *
+ * ContextCompat.getMainExecutor(context) is called with a mocked Context;
+ * per DownloadUtilsTest/OfflineCacheServiceTest precedent, no
+ * mockStatic(ContextCompat) is needed here -- getMainExecutor() on a
+ * plain mocked Context under the mockable android.jar
+ * (isReturnDefaultValues=true / Robolectric not in use) still needs a
+ * Looper to resolve on a real device, but in this project's JVM-mock
+ * setup, ContextCompat.getMainExecutor() ultimately just wraps
+ * context.getMainLooper(); a mocked Context's getMainLooper() returns
+ * null under the mockable jar's default-value stubbing. Since the
+ * listener is added to the ListenableFuture's addListener(Runnable,
+ * Executor) directly and we intercept that call on a mocked
+ * ListenableFuture (never a real Guava future backed by the executor),
+ * the executor value itself is never actually invoked/dereferenced here
+ * -- only that setTorch reaches the addListener call and, when we
+ * manually invoke the captured Runnable, that onTorchChanged fires.
+ */
+class TorchControllerTest {
+
+    private val context = mock<Context>()
+
+    // ============================================================
+    // attachCamera / detachCamera
+    // ============================================================
+
+    @Test
+    fun `attachCamera then detachCamera does not throw`() {
+        val callback = mutableListOf<Boolean>()
+        val controller = TorchController(context) { callback.add(it) }
+        val camera = mock<Camera>()
+
+        controller.attachCamera(camera, "back")
+        controller.detachCamera()
+
+        assertNotNull(controller)
+    }
+
+    // ============================================================
+    // setTorch
+    // ============================================================
+
+    @Test
+    fun `setTorch with no camera attached does not throw and does not invoke callback`() {
+        val callback = mutableListOf<Boolean>()
+        val controller = TorchController(context) { callback.add(it) }
+
+        controller.setTorch(true)
+
+        assertTrue(callback.isEmpty())
+    }
+
+    @Test
+    fun `setTorch on a front-facing camera is ignored`() {
+        val callback = mutableListOf<Boolean>()
+        val controller = TorchController(context) { callback.add(it) }
+        val camera = mock<Camera>()
+        controller.attachCamera(camera, "front")
+
+        controller.setTorch(true)
+
+        assertTrue(callback.isEmpty())
+        org.mockito.Mockito.verifyNoInteractions(camera)
+    }
+
+    @Test
+    fun `setTorch on a back-facing camera enables torch and fires the callback once the future resolves`() {
+        val callback = mutableListOf<Boolean>()
+        val controller = TorchController(context) { callback.add(it) }
+        val camera = mock<Camera>()
+        val cameraControl = mock<CameraControl>()
+        @Suppress("UNCHECKED_CAST")
+        val future = mock<ListenableFuture<Void>>()
+        whenever(camera.cameraControl).doReturn(cameraControl)
+        whenever(cameraControl.enableTorch(true)).doReturn(future)
+        controller.attachCamera(camera, "back")
+
+        controller.setTorch(true)
+
+        // Capture the Runnable passed to addListener and invoke it
+        // manually -- there's no real Looper/Executor running the
+        // listener for us in a JVM unit test.
+        val runnableCaptor = argumentCaptor<Runnable>()
+        verify(future).addListener(runnableCaptor.capture(), any())
+        runnableCaptor.firstValue.run()
+
+        assertEquals(listOf(true), callback)
+    }
+
+    @Test
+    fun `setTorch(false) disables torch`() {
+        val callback = mutableListOf<Boolean>()
+        val controller = TorchController(context) { callback.add(it) }
+        val camera = mock<Camera>()
+        val cameraControl = mock<CameraControl>()
+        val future = mock<ListenableFuture<Void>>()
+        whenever(camera.cameraControl).doReturn(cameraControl)
+        whenever(cameraControl.enableTorch(false)).doReturn(future)
+        controller.attachCamera(camera, "back")
+
+        controller.setTorch(false)
+
+        val runnableCaptor = argumentCaptor<Runnable>()
+        verify(future).addListener(runnableCaptor.capture(), any())
+        runnableCaptor.firstValue.run()
+
+        assertEquals(listOf(false), callback)
+    }
+
+    // ============================================================
+    // notifyReset
+    // ============================================================
+
+    @Test
+    fun `notifyReset invokes the callback with false`() {
+        val callback = mutableListOf<Boolean>()
+        val controller = TorchController(context) { callback.add(it) }
+
+        controller.notifyReset()
+
+        assertEquals(listOf(false), callback)
+    }
+}

package/dist/native/androidProject/app/src/test/java/io/yourname/androidproject/camera/VideoStreamStateMachineTest.kt

@@ -0,0 +1,120 @@
+package io.yourname.androidproject.camera
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Unit tests for VideoStreamStateMachine, ported from iOS's
+ * VideoStreamStateMachineTests.swift. Android's implementation uses
+ * CopyOnWriteArrayList + @Synchronized rather than iOS's NSLock +
+ * weak-listener boxing, so there's no weak-dealloc-compaction case to
+ * port — everything else (valid/invalid transitions, listener
+ * notify/no-notify, removeListener) carries over directly.
+ */
+class VideoStreamStateMachineTest {
+
+    private class RecordingListener : VideoStreamStateListener {
+        val events = mutableListOf<Pair<VideoStreamState, VideoStreamState>>()
+        override fun onStateChanged(prev: VideoStreamState, next: VideoStreamState) {
+            events.add(prev to next)
+        }
+    }
+
+    @Test
+    fun `a valid transition updates state and returns true`() {
+        val machine = VideoStreamStateMachine()
+
+        val result = machine.transition(VideoStreamState.STARTING)
+
+        assertTrue(result)
+        assertEquals(VideoStreamState.STARTING, machine.state)
+    }
+
+    @Test
+    fun `an invalid transition leaves state unchanged and returns false`() {
+        val machine = VideoStreamStateMachine()
+
+        // IDLE -> STREAMING is not a valid direct transition.
+        val result = machine.transition(VideoStreamState.STREAMING)
+
+        assertFalse(result)
+        assertEquals(VideoStreamState.IDLE, machine.state)
+    }
+
+    @Test
+    fun `isActive reflects the current state`() {
+        val machine = VideoStreamStateMachine()
+        assertFalse(machine.isActive)
+
+        machine.transition(VideoStreamState.STARTING)
+        assertFalse(machine.isActive)
+
+        machine.transition(VideoStreamState.STREAMING)
+        assertTrue(machine.isActive)
+    }
+
+    @Test
+    fun `a listener receives onStateChanged on a valid transition`() {
+        val machine = VideoStreamStateMachine()
+        val listener = RecordingListener()
+        machine.addListener(listener)
+
+        machine.transition(VideoStreamState.STARTING)
+
+        assertEquals(listOf(VideoStreamState.IDLE to VideoStreamState.STARTING), listener.events)
+    }
+
+    @Test
+    fun `a listener does not fire on an invalid transition`() {
+        val machine = VideoStreamStateMachine()
+        val listener = RecordingListener()
+        machine.addListener(listener)
+
+        machine.transition(VideoStreamState.STREAMING) // invalid from IDLE
+
+        assertTrue(listener.events.isEmpty())
+    }
+
+    @Test
+    fun `removeListener stops further notifications`() {
+        val machine = VideoStreamStateMachine()
+        val listener = RecordingListener()
+        machine.addListener(listener)
+        machine.transition(VideoStreamState.STARTING)
+        assertEquals(1, listener.events.size)
+
+        machine.removeListener(listener)
+        machine.transition(VideoStreamState.STREAMING)
+
+        // No new event recorded after removal.
+        assertEquals(1, listener.events.size)
+    }
+
+    @Test
+    fun `addListener does not register the same listener twice`() {
+        val machine = VideoStreamStateMachine()
+        val listener = RecordingListener()
+        machine.addListener(listener)
+        machine.addListener(listener)
+
+        machine.transition(VideoStreamState.STARTING)
+
+        assertEquals(1, listener.events.size)
+    }
+
+    @Test
+    fun `multiple listeners all receive the same transition event`() {
+        val machine = VideoStreamStateMachine()
+        val listenerA = RecordingListener()
+        val listenerB = RecordingListener()
+        machine.addListener(listenerA)
+        machine.addListener(listenerB)
+
+        machine.transition(VideoStreamState.STARTING)
+
+        assertEquals(1, listenerA.events.size)
+        assertEquals(1, listenerB.events.size)
+    }
+}

package/dist/native/androidProject/app/src/test/java/io/yourname/androidproject/camera/VideoStreamStateTest.kt

@@ -0,0 +1,62 @@
+package io.yourname.androidproject.camera
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Exhaustive truth-table tests for VideoStreamState, ported directly from
+ * iOS's VideoStreamStateTests.swift (CoreLogic/Tests/CatalystCoreLogicTests)
+ * — this Kotlin enum is a byte-for-byte match of the Swift one (same
+ * states, same canTransitionTo table, same isActive derivation), so the
+ * same 6x6 truth table applies unchanged.
+ */
+class VideoStreamStateTest {
+
+    private val allStates = VideoStreamState.values().toList()
+
+    // Every valid transition documented in VideoStreamState.kt's own
+    // header comment, expressed as (from, to) pairs.
+    private val validTransitions = setOf(
+        VideoStreamState.IDLE to VideoStreamState.STARTING,
+        VideoStreamState.STARTING to VideoStreamState.STREAMING,
+        VideoStreamState.STARTING to VideoStreamState.IDLE,
+        VideoStreamState.STREAMING to VideoStreamState.HOLD,
+        VideoStreamState.HOLD to VideoStreamState.STREAMING,
+        VideoStreamState.STREAMING to VideoStreamState.FLIPPING,
+        VideoStreamState.FLIPPING to VideoStreamState.STREAMING,
+        VideoStreamState.STREAMING to VideoStreamState.STOPPING,
+        VideoStreamState.FLIPPING to VideoStreamState.STOPPING,
+        VideoStreamState.HOLD to VideoStreamState.STOPPING,
+        VideoStreamState.STOPPING to VideoStreamState.IDLE
+    )
+
+    @Test
+    fun `canTransitionTo matches the documented transition table for all 36 state pairs`() {
+        for (from in allStates) {
+            for (to in allStates) {
+                val expected = validTransitions.contains(from to to)
+                assertEquals(
+                    "canTransitionTo($from -> $to) expected $expected",
+                    expected,
+                    from.canTransitionTo(to)
+                )
+            }
+        }
+    }
+
+    @Test
+    fun `isActive is true for STREAMING, HOLD, and FLIPPING`() {
+        assertTrue(VideoStreamState.STREAMING.isActive)
+        assertTrue(VideoStreamState.HOLD.isActive)
+        assertTrue(VideoStreamState.FLIPPING.isActive)
+    }
+
+    @Test
+    fun `isActive is false for IDLE, STARTING, and STOPPING`() {
+        assertFalse(VideoStreamState.IDLE.isActive)
+        assertFalse(VideoStreamState.STARTING.isActive)
+        assertFalse(VideoStreamState.STOPPING.isActive)
+    }
+}