@glassly/bluetooth-sdk 0.1.0-dev.99 → 0.2.8-dev.445

package/android/src/test/java/com/glassly/bluetoothsdk/DisplayPacerTest.kt

@@ -0,0 +1,277 @@
+package com.glassly.bluetoothsdk
+
+import com.glassly.bluetoothsdk.sgcs.SceneElement
+import com.glassly.bluetoothsdk.sgcs.SceneFrame
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class DisplayPacerTest {
+    private class FakeScheduler : DisplayPacer.Scheduler {
+        var delay: Long? = null
+        var block: (() -> Unit)? = null
+        var scheduled = 0
+
+        override fun schedule(delayMs: Long, block: () -> Unit): () -> Unit {
+            scheduled++
+            delay = delayMs
+            this.block = block
+            return {
+                if (this.block === block) {
+                    this.block = null
+                    delay = null
+                }
+            }
+        }
+
+        fun fire() {
+            val b = block ?: error("no timer armed")
+            block = null
+            delay = null
+            b()
+        }
+    }
+
+    private class Harness(fps: Int = 8) {
+        var now = 1_000L
+        val scheduler = FakeScheduler()
+        val scenes = mutableListOf<SceneFrame>()
+        var legacySends = 0
+        val pacer =
+            DisplayPacer(
+                dispatchScene = { scenes.add(it) },
+                sendLegacy = { legacySends++ },
+                clock = { now },
+                scheduler = scheduler,
+            ).also { it.setMaxFps(fps) }
+    }
+
+    private fun element(id: String, change: String = "created", x: Int = 0) =
+        SceneElement(
+            id = id, type = "text", x = x, y = 0, w = 10, h = 10, text = id, data = null,
+            border = 0, radius = 0, change = change, contentHash = "h-$id",
+        )
+
+    private fun frame(
+        vararg elements: SceneElement,
+        removed: List<String> = emptyList(),
+        appId: String = "app",
+        replay: Boolean = false,
+        epoch: Int = 1,
+    ) = SceneFrame(appId = appId, epoch = epoch, replay = replay, elements = elements.toList(), removed = removed)
+
+    private fun SceneFrame.change(id: String) = elements.first { it.id == id }.change
+
+    @Test
+    fun firstSubmitSendsImmediately() {
+        val h = Harness()
+        h.pacer.submitScene(frame(element("a")))
+        assertEquals(1, h.scenes.size)
+        assertNull(h.scheduler.block)
+    }
+
+    @Test
+    fun secondSubmitInsideWindowIsHeldUntilTheSlot() {
+        val h = Harness(fps = 10) // 100 ms slots
+        h.pacer.submitScene(frame(element("a"), epoch = 1))
+        h.now += 30
+        h.pacer.submitScene(frame(element("a", change = "updated"), epoch = 2))
+        assertEquals(1, h.scenes.size)
+        assertEquals(70L, h.scheduler.delay)
+        h.now += 70
+        h.scheduler.fire()
+        assertEquals(2, h.scenes.size)
+        assertEquals(2, h.scenes[1].epoch)
+    }
+
+    @Test
+    fun rapidFramesCoalesceIntoOneMergedSend() {
+        val h = Harness(fps = 10)
+        h.pacer.submitScene(frame(element("a"), epoch = 1))
+        h.now += 10
+        h.pacer.submitScene(frame(element("a", change = "updated"), element("b", change = "created"), epoch = 2))
+        h.now += 10
+        h.pacer.submitScene(frame(element("a", change = "unchanged"), element("b", change = "moved", x = 5), epoch = 3))
+        h.now += 10
+        h.pacer.submitScene(
+            frame(element("a", change = "unchanged"), element("b", change = "unchanged", x = 5), epoch = 4),
+        )
+        assertEquals(1, h.scheduler.scheduled)
+        h.now += 70
+        h.scheduler.fire()
+        assertEquals(2, h.scenes.size)
+        val sent = h.scenes[1]
+        assertEquals(4, sent.epoch)
+        assertEquals("updated", sent.change("a"))
+        assertEquals("created", sent.change("b"))
+        assertEquals(5, sent.elements.first { it.id == "b" }.x)
+    }
+
+    @Test
+    fun updatedThenUnchangedBecomesUpdated() {
+        val h = Harness()
+        h.pacer.submitScene(frame(element("a")))
+        h.now += 1
+        h.pacer.submitScene(frame(element("a", change = "moved", x = 3)))
+        h.now += 1
+        h.pacer.submitScene(frame(element("a", change = "unchanged", x = 3)))
+        h.now += 200
+        h.scheduler.fire()
+        assertEquals("updated", h.scenes[1].change("a"))
+    }
+
+    @Test
+    fun removedThenRecreatedIdIsNotRemoved() {
+        val h = Harness()
+        h.pacer.submitScene(frame(element("a"), element("b")))
+        h.now += 1
+        h.pacer.submitScene(frame(element("a", change = "unchanged"), removed = listOf("b")))
+        h.now += 1
+        h.pacer.submitScene(frame(element("a", change = "unchanged"), element("b", change = "created")))
+        h.now += 200
+        h.scheduler.fire()
+        val sent = h.scenes[1]
+        assertTrue(sent.removed.isEmpty())
+        assertEquals("created", sent.change("b"))
+    }
+
+    @Test
+    fun pendingRemovesSurviveIntoTheMergedFrame() {
+        val h = Harness()
+        h.pacer.submitScene(frame(element("a"), element("b"), element("c")))
+        h.now += 1
+        h.pacer.submitScene(frame(element("a", change = "unchanged"), removed = listOf("b", "c")))
+        h.now += 1
+        h.pacer.submitScene(frame(element("a", change = "unchanged"), removed = listOf("c")))
+        h.now += 200
+        h.scheduler.fire()
+        assertEquals(listOf("b", "c"), h.scenes[1].removed)
+    }
+
+    @Test
+    fun appSwitchDiscardsPending() {
+        val h = Harness()
+        h.pacer.submitScene(frame(element("a"), appId = "one"))
+        h.now += 1
+        h.pacer.submitScene(frame(element("a", change = "updated"), removed = listOf("z"), appId = "one"))
+        h.now += 1
+        h.pacer.submitScene(frame(element("b", change = "created"), appId = "two", replay = true))
+        h.now += 200
+        h.scheduler.fire()
+        val sent = h.scenes[1]
+        assertEquals("two", sent.appId)
+        assertTrue(sent.removed.isEmpty())
+        assertEquals(listOf("b"), sent.elements.map { it.id })
+    }
+
+    @Test
+    fun emptyFrameFlushesImmediatelyWithPendingRemoves() {
+        val h = Harness()
+        h.pacer.submitScene(frame(element("a"), element("b")))
+        h.now += 1
+        h.pacer.submitScene(frame(element("a", change = "unchanged"), removed = listOf("b")))
+        h.now += 1
+        h.pacer.flushScene(frame(removed = listOf("a")))
+        assertEquals(2, h.scenes.size)
+        assertEquals(setOf("a", "b"), h.scenes[1].removed.toSet())
+        assertTrue(h.scenes[1].elements.isEmpty())
+        assertNull(h.scheduler.block)
+        // Nothing left pending: a later timer must not resend.
+        h.now += 200
+        h.pacer.setMaxFps(8)
+        assertEquals(2, h.scenes.size)
+    }
+
+    @Test
+    fun clearViewFlushesImmediatelyAndDropsPendingScene() {
+        val h = Harness()
+        h.pacer.submitScene(frame(element("a")))
+        h.now += 1
+        h.pacer.submitScene(frame(element("a", change = "updated")))
+        assertNotNull(h.scheduler.block)
+        h.pacer.flushLegacy()
+        assertEquals(1, h.legacySends)
+        assertEquals(1, h.scenes.size)
+        assertNull(h.scheduler.block)
+    }
+
+    @Test
+    fun legacyAfterSceneDropsThePendingScene() {
+        val h = Harness()
+        h.pacer.submitScene(frame(element("a")))
+        h.now += 1
+        h.pacer.submitScene(frame(element("a", change = "updated")))
+        h.now += 1
+        h.pacer.submitLegacy()
+        h.now += 200
+        h.scheduler.fire()
+        assertEquals(1, h.scenes.size)
+        assertEquals(1, h.legacySends)
+    }
+
+    @Test
+    fun sceneAfterLegacyDropsThePendingLegacy() {
+        val h = Harness()
+        h.pacer.submitLegacy()
+        assertEquals(1, h.legacySends)
+        h.now += 1
+        h.pacer.submitLegacy()
+        h.now += 1
+        h.pacer.submitScene(frame(element("a")))
+        h.now += 200
+        h.scheduler.fire()
+        assertEquals(1, h.legacySends)
+        assertEquals(1, h.scenes.size)
+    }
+
+    @Test
+    fun setMaxFpsRearmsAPendingTimer() {
+        val h = Harness(fps = 2) // 500 ms slots
+        h.pacer.submitScene(frame(element("a")))
+        h.now += 50
+        h.pacer.submitScene(frame(element("a", change = "updated")))
+        assertEquals(450L, h.scheduler.delay)
+        h.pacer.setMaxFps(20) // 50 ms slots: the slot is already due
+        assertEquals(2, h.scenes.size)
+        assertNull(h.scheduler.block)
+
+        h.now += 10
+        h.pacer.submitScene(frame(element("a", change = "updated")))
+        assertEquals(40L, h.scheduler.delay)
+        h.pacer.setMaxFps(10)
+        assertEquals(90L, h.scheduler.delay)
+        assertEquals(2, h.scenes.size)
+    }
+
+    @Test
+    fun cancelDropsPendingWithoutSending() {
+        val h = Harness()
+        h.pacer.submitScene(frame(element("a")))
+        h.now += 1
+        h.pacer.submitScene(frame(element("a", change = "updated")))
+        h.pacer.cancel()
+        assertNull(h.scheduler.block)
+        h.now += 200
+        h.pacer.setMaxFps(8)
+        assertEquals(1, h.scenes.size)
+        assertFalse(h.scheduler.block != null)
+    }
+
+    @Test
+    fun lateSubmitAfterTheSlotSendsMergedImmediately() {
+        val h = Harness(fps = 10)
+        h.pacer.submitScene(frame(element("a")))
+        h.now += 10
+        h.pacer.submitScene(frame(element("a", change = "updated"), element("b", change = "created")))
+        // The timer is late; a submit past the slot sends now with the pending fold.
+        h.now += 200
+        h.pacer.submitScene(frame(element("a", change = "unchanged"), element("b", change = "unchanged")))
+        assertEquals(2, h.scenes.size)
+        assertEquals("updated", h.scenes[1].change("a"))
+        assertEquals("created", h.scenes[1].change("b"))
+        assertNull(h.scheduler.block)
+    }
+}

package/android/src/test/java/com/glassly/bluetoothsdk/G2BleLinkTest.kt

@@ -0,0 +1,70 @@
+package com.glassly.bluetoothsdk
+
+import com.glassly.bluetoothsdk.sgcs.G2BleLink
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+/** Pins the BLE link control wire format shared with g2flash's patches/ble_link.c. */
+class G2BleLinkTest {
+    private fun le16(v: Int) = byteArrayOf((v and 0xFF).toByte(), (v shr 8).toByte())
+
+    @Test
+    fun controlPacketFramesField127OnDeviceReceiveInfo() {
+        assertArrayEquals(
+            byteArrayOf(0x08, 0x01, 0x10, 0x00, 0xFA.toByte(), 0x07, 4, 0x42, 0x4C, 1, 1),
+            G2BleLink.controlPacket(G2BleLink.Op.FAST),
+        )
+        assertEquals(0.toByte(), G2BleLink.controlPacket(G2BleLink.Op.STOCK).last())
+        assertEquals(2.toByte(), G2BleLink.controlPacket(G2BleLink.Op.QUERY).last())
+    }
+
+    @Test
+    fun decodesFullStatusWithLivePair() {
+        val body = byteArrayOf(0x42, 0x4C, 1, 1, 1, 0xA3.toByte(), 0xA3.toByte()) + le16(6) + le16(6) + le16(0) + le16(12) + le16(0)
+        val status = G2BleLink.decodeStatus(body)
+        assertEquals(
+            G2BleLink.Status(
+                fast = true,
+                side = 1,
+                wanted = G2BleLink.Mode.Fast,
+                applied = G2BleLink.Mode.Fast,
+                requestedMinMs = 7.5,
+                requestedMaxMs = 7.5,
+                requestedLatency = 0,
+                liveIntervalMs = 15.0,
+                liveLatency = 0,
+            ),
+            status,
+        )
+        assertEquals("FAST wanted=fast applied=fast requested 7.50-7.50 ms / latency 0 live 15.00 ms / latency 0", status?.summary)
+    }
+
+    @Test
+    fun decodesThirteenByteStatusWithoutLivePair() {
+        val body = byteArrayOf(0x42, 0x4C, 1, 0, 2, 0xA4.toByte(), 0) + le16(36) + le16(72) + le16(4)
+        val status = G2BleLink.decodeStatus(body)!!
+        assertEquals(false, status.fast)
+        assertEquals(2, status.side)
+        assertEquals(G2BleLink.Mode.Slow, status.wanted)
+        assertEquals(G2BleLink.Mode.Pending, status.applied)
+        assertEquals(45.0, status.requestedMinMs, 0.0)
+        assertEquals(90.0, status.requestedMaxMs, 0.0)
+        assertEquals(4, status.requestedLatency)
+        assertNull(status.liveIntervalMs)
+        assertNull(status.liveLatency)
+        assertEquals("stock wanted=slow applied=pending requested 45.00-90.00 ms / latency 4", status.summary)
+    }
+
+    @Test
+    fun rejectsForeignShortOrVersionedBodies() {
+        assertNull(G2BleLink.decodeStatus(byteArrayOf(0x41, 0x4E, 1, 1, 1, 0xA3.toByte(), 0xA3.toByte()) + le16(6) + le16(6) + le16(0)))
+        assertNull(G2BleLink.decodeStatus(byteArrayOf(0x42, 0x4C, 2, 1, 1, 0xA3.toByte(), 0xA3.toByte()) + le16(6) + le16(6) + le16(0)))
+        assertNull(G2BleLink.decodeStatus(byteArrayOf(0x42, 0x4C, 1, 1, 1, 0xA3.toByte(), 0xA3.toByte()) + le16(6) + le16(6)))
+        assertEquals(
+            G2BleLink.Mode.Other(0x99),
+            G2BleLink.decodeStatus(byteArrayOf(0x42, 0x4C, 1, 0, 1, 0x99.toByte(), 0) + le16(0) + le16(0) + le16(0))?.wanted,
+        )
+    }
+}

package/android/src/test/java/com/glassly/bluetoothsdk/sgcs/G2CfwClassificationTest.kt

@@ -2,17 +2,10 @@ package com.glassly.bluetoothsdk.sgcs
 
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
-import org.junit.Assert.assertNotNull
 import org.junit.Assert.assertNull
 import org.junit.Assert.assertTrue
 import org.junit.Test
 
-/**
- * Pins the stock-vs-CFW identity rules that gate the connect banner. A
- * regression here re-opens the stuck "// Glassly connected" bug: text drawn
- * down the stock path before classification, cleared down the CFW path after
- * it, never leaves the glass.
- */
 class G2CfwClassificationTest {
     private fun classify(
         capability: String?,
@@ -20,70 +13,66 @@ class G2CfwClassificationTest {
         current: String? = null,
     ) = G2CfwClassification.classify(capability?.toByteArray(Charsets.UTF_8), definitive, current)
 
-    // ── CFW detection ───────────────────────────────────────────────────────
-
     @Test
-    fun cfwBannerClassifiesWithFeaturesAndRevision() {
-        val result = classify("EVENCFW/15 img640 imgz rle directfb font15")
-        assertNotNull(result)
-        assertTrue(result!!.isCfw)
-        assertEquals("EVENCFW/15 img640 imgz rle directfb font15", result.capabilityString)
-        assertEquals(listOf("img640", "imgz", "rle", "directfb", "font15"), result.features)
-        assertEquals(15, result.protocolVersion)
+    fun glasslyUsesOneContractWithoutRevisionOrTokenNegotiation() {
+        for (banner in listOf("GLASSLYCFW/24", "GLASSLYCFW/24 shapes36 scene37 anim38", "GLASSLYCFW/25")) {
+            val result = classify(banner)!!
+            assertEquals(G2CfwClassification.Family.GLASSLY, result.family)
+            assertTrue(result.isCfw)
+            assertTrue(result.isGlassly)
+            assertEquals(if (banner == "GLASSLYCFW/25") "Glassly CFW v25" else "Glassly CFW v24", result.displayName)
+            assertEquals(banner, result.capabilityString)
+        }
     }
 
     @Test
-    fun cfwDetectionDoesNotWaitForADefinitiveResponse() {
-        // The banner may ride any settings packet; requiring `definitive` would
-        // delay classification past the connect banner and re-split the paths.
-        assertTrue(classify("EVENCFW/12 img640", definitive = false)!!.isCfw)
+    fun revisionIsRetainedIndependentlyOfTheFirmwareFamily() {
+        assertEquals(24, classify("GLASSLYCFW/24 shapes36 scene37 anim38")!!.revision)
+        assertEquals(25, classify("GLASSLYCFW/25")!!.revision)
+        assertEquals(22, classify("EVENCFW/22 img640")!!.revision)
+        assertEquals(24, classify("GLASSLYCFW/24\u0000\u0000")!!.revision)
+        assertNull(G2CfwClassification.STOCK.revision)
+        for (banner in listOf("GLASSLYCFW/", "GLASSLYCFW/beta", "GLASSLYCFW/0", "GLASSLYCFW/-1")) {
+            val result = classify(banner)!!
+            assertNull(result.revision)
+            assertTrue(result.isGlassly)
+        }
     }
 
     @Test
-    fun cfwBannerTrimsNulTermination() {
-        val bytes = "EVENCFW/12 img640".toByteArray(Charsets.UTF_8) + byteArrayOf(0, 0)
-        val result = G2CfwClassification.classify(bytes, definitive = false, currentCapability = null)
-        assertEquals("EVENCFW/12 img640", result!!.capabilityString)
-        assertEquals(listOf("img640"), result.features)
+    fun evenCfwIsUpstreamAndNeverGlassly() {
+        for (banner in listOf("EVENCFW/22 img640 imgz rle font15 ringbat17", "EVENCFW/24 shapes36 scene37 anim38")) {
+            val result = classify(banner)!!
+            assertEquals(G2CfwClassification.Family.UPSTREAM, result.family)
+            assertTrue(result.isCfw)
+            assertFalse(result.isGlassly)
+            assertEquals("g2flash CFW", result.displayName)
+        }
     }
 
     @Test
-    fun malformedRevisionFallsBackToZero() {
-        val result = classify("EVENCFW/beta img640")
-        assertTrue(result!!.isCfw)
-        assertEquals(0, result.protocolVersion)
-    }
-
-    // ── Stock classification ────────────────────────────────────────────────
-
-    @Test
-    fun definitiveAbsenceClassifiesStock() {
-        val result = classify(null, definitive = true)
-        assertNotNull(result)
-        assertFalse(result!!.isCfw)
-        assertEquals(G2CfwClassification.STOCK, result)
+    fun bannerTrimsNulTermination() {
+        assertEquals("GLASSLYCFW/24", classify("GLASSLYCFW/24\u0000\u0000")!!.capabilityString)
     }
 
     @Test
-    fun definitiveNonCfwPayloadClassifiesStock() {
-        assertEquals(G2CfwClassification.STOCK, classify("something-else", definitive = true))
-    }
-
-    // ── Packets that prove nothing ──────────────────────────────────────────
-
-    @Test
-    fun nonDefinitiveAbsenceLeavesConnectionUnclassified() {
-        // Individual settings packets can legitimately omit field 100 or
-        // arrive truncated — only a deviceReceiveRequest response is proof.
-        assertNull(classify(null, definitive = false))
-        assertNull(classify("garbage", definitive = false))
+    fun definitiveAbsenceOrUnrecognizedPrefixClassifiesStock() {
+        for (banner in listOf(null, "something-else", "GLASSLYCFW-invalid", "EVENCFW-invalid")) {
+            val result = classify(banner, definitive = true)!!
+            assertEquals(G2CfwClassification.STOCK, result)
+            assertFalse(result.isCfw)
+            assertFalse(result.isGlassly)
+            assertNull(result.displayName)
+        }
     }
 
     @Test
-    fun definitiveAbsenceNeverDowngradesDetectedCfw() {
-        // Firmware identity is connection-sticky: downgrading would
-        // reinterpret an installed mode-6 carrier as a stock BMP.
-        assertNull(classify(null, definitive = true, current = "EVENCFW/15 img640"))
-        assertNull(classify("garbage", definitive = true, current = "EVENCFW/15 img640"))
+    fun partialSettingsPacketsPreserveTheKnownRenderPath() {
+        assertNull(classify(null))
+        assertNull(classify("garbage"))
+        for (banner in listOf("GLASSLYCFW/24", "EVENCFW/22")) {
+            assertNull(classify(null, definitive = true, current = banner))
+            assertNull(classify("garbage", definitive = true, current = banner))
+        }
     }
 }

package/android/src/test/java/com/glassly/bluetoothsdk/sgcs/G2CfwRendererTest.kt

@@ -1,5 +1,6 @@
 package com.glassly.bluetoothsdk.sgcs
 
+import org.junit.Assert.assertArrayEquals
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNotNull
 import org.junit.Assert.assertNull
@@ -14,6 +15,72 @@ import org.robolectric.annotation.GraphicsMode
 @Config(sdk = [33])
 @GraphicsMode(GraphicsMode.Mode.NATIVE)
 class G2CfwRendererTest {
+    @Test
+    fun globalDepthMovesFlatScenesWithoutMiniappDepth() {
+        val content = frame(rect(border = 1).copy(x = 100, y = 40, w = 100, h = 50))
+        // Start flat, split the retained mirror, change sides, then converge again.
+        listOf(2, 1, 3, 2).forEachIndexed { index, setting ->
+            val b = boxes(4, G2CfwRenderer.depthLevelForSetting(setting))
+            val encoded = G2CfwRenderer.encodeVector(content, b, 900, index == 0, true)!!
+            if (setting == 2) {
+                assertEquals(listOf(G2CfwTransport.LENS_BOTH), encoded.shows.map { it.lenses })
+                assertEquals(132, firstRectX(encoded.shows[0].payload))
+            } else {
+                assertEquals(listOf(G2CfwTransport.LENS_LEFT, G2CfwTransport.LENS_RIGHT), encoded.shows.map { it.lenses })
+                assertEquals(if (setting == 1) 140 else 124, firstRectX(encoded.shows[0].payload))
+                assertEquals(if (setting == 1) 124 else 140, firstRectX(encoded.shows[1].payload))
+            }
+        }
+    }
+
+    @Test
+    fun elementDepthIsRelativeToEachGlobalLensOrigin() {
+        val content = frame(rect(border = 1).copy(x = 100, y = 40, w = 100, h = 50, depth = 5))
+        val b = boxes(4, G2CfwRenderer.depthLevelForSetting(3))
+        val encoded = G2CfwRenderer.encodeVector(content, b, 901, true, true)!!
+        assertEquals(listOf(G2CfwTransport.LENS_LEFT, G2CfwTransport.LENS_RIGHT), encoded.shows.map { it.lenses })
+        assertEquals(24 + 100 + 5, firstRectX(encoded.shows[0].payload))
+        assertEquals(40 + 100 - 5, firstRectX(encoded.shows[1].payload))
+    }
+
+    private fun firstRectX(payload: ByteArray): Int {
+        val bytes = payload.map { it.toInt() and 0xFF }
+        assertEquals(38, bytes[0]) // SHOW
+        assertEquals(1, bytes[7]) // one object PUT
+        // SHOW header (8), PUT opcode/id/version (9), type/flags/color/width (4).
+        return (bytes[21] or (bytes[22] shl 8)).toShort().toInt()
+    }
+
+    @Test
+    fun globalDepthSettingsMapToAllThreeFirmwareLevels() {
+        assertEquals(listOf(0, 1, 2), listOf(1, 2, 3).map { G2CfwRenderer.depthLevelForSetting(it) })
+        assertEquals(0, G2CfwRenderer.depthLevelForSetting(Int.MIN_VALUE))
+        assertEquals(2, G2CfwRenderer.depthLevelForSetting(Int.MAX_VALUE))
+    }
+
+    @Test
+    fun rasterFallbackBakesTextIntoStereoWindows() {
+        for (font in listOf("builtin", "mono")) {
+            val text = rect(border = 0).copy(
+                type = "text", x = 10, y = 10, w = 200, h = 60, text = "Depth", font = font, fontSize = 20,
+            )
+            for (setting in listOf(1, 3)) {
+                val b = boxes(4, G2CfwRenderer.depthLevelForSetting(setting))
+                val update = G2CfwRenderer.encodeUpdate(
+                    frame(text), b, previousRaster = null, forcedRects = emptyList(),
+                    fids = (1..G2CfwRenderer.REQUIRED_FID_COUNT).toList(),
+                    textDraws = emptyList(), allowRectCopy = true, blankBoxes = null, omitBuiltinText = false,
+                    textureGlyphsEnabled = true, textureImagesEnabled = true,
+                )!!
+                assertTrue("$font text must remain visible", update.raster.any { it.toInt() != 0 })
+                val payload = update.payload!!
+                assertEquals("a stereo bitmap, without lens-equal text/cache commands", 0x83, payload[0].toInt() and 0xFF)
+                assertEquals(b.leftX, (payload[1].toInt() and 0xFF) * 4)
+                assertEquals(b.rightX, (payload[5].toInt() and 0xFF) * 4)
+            }
+        }
+    }
+
     @Test
     fun placementMatchesStockWindowTablesAndClamps() {
         val defaults = boxes(height = 4, depth = 2)
@@ -52,7 +119,8 @@ class G2CfwRendererTest {
             listOf(0x83, 6, 64, 144, 144, 10, 64, 144, 144, 0x34, 0x12),
             payload!!.take(11).map { it.toInt() and 0xFF },
         )
-        assertEquals(0x78, payload[11].toInt() and 0xFF)
+        // Plain RLE follows the header (the transport compresses): 576*288 black pixels.
+        assertEquals(listOf(0x00, 0x00, 0xFF, 0xFF), payload.copyOfRange(11, 15).map { it.toInt() and 0xFF })
         assertNull(G2CfwRenderer.stereoFrame(ByteArray(10), boxes(4, 2), 1))
     }
 
@@ -94,7 +162,11 @@ class G2CfwRendererTest {
         val payload = G2CfwRenderer.blackPayload()
         assertNotNull(payload)
         assertEquals(6, payload!![0].toInt() and 0xFF)
-        assertEquals(0x78, payload[1].toInt() and 0xFF)
+        // 307,200 black pixels as RLE: four 65,535 runs and a 45,060 remainder.
+        assertEquals(
+            listOf(0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0x04, 0xB0),
+            payload.drop(1).map { it.toInt() and 0xFF },
+        )
     }
 
     @Test
@@ -212,7 +284,8 @@ class G2CfwRendererTest {
             listOf(0x83, (24 + 100) / 4, (128 + 50) / 2, 8, 8, (40 + 100) / 4, (128 + 50) / 2, 8, 8, 5, 0),
             payload!!.take(11).map { it.toInt() and 0xFF },
         )
-        assertEquals(0x78, payload[11].toInt() and 0xFF)
+        // Plain RLE of the 32x16 box follows (the transport compresses).
+        assertArrayEquals(G2CfwRenderer.rleEncode(G2CfwRenderer.pack4Bpp(ByteArray(32 * 16))), payload.copyOfRange(11, payload.size))
         assertNull(
             G2CfwRenderer.boxDeltaFrame(raster(576, 288), 576, G2CfwRenderer.CanvasRect(3, 0, 32, 16), b, 1)
         )
@@ -272,8 +345,8 @@ class G2CfwRendererTest {
         val draws = G2CfwRenderer.builtinTextDraws(frame(element), b)
         assertEquals(
             listOf(
-                G2CfwRenderer.TextDraw(32 + 10 + 2, 128 + 20 + 2, "one"),
-                G2CfwRenderer.TextDraw(32 + 10 + 2, 128 + 20 + 2 + 27, "two"),
+                G2CfwRenderer.TextDraw(32 + 10 + 2, 128 + 20 + 2, "one", 200),
+                G2CfwRenderer.TextDraw(32 + 10 + 2, 128 + 20 + 2 + 27, "two", 200),
             ),
             draws,
         )