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

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

@@ -0,0 +1,489 @@
+package com.glassly.bluetoothsdk.sgcs
+
+import org.junit.Assert.assertArrayEquals
+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 G2CfwSceneTest {
+    private fun element(
+        id: String,
+        type: String,
+        x: Int = 0,
+        y: Int = 0,
+        w: Int = 0,
+        h: Int = 0,
+        text: String? = null,
+        border: Int = 0,
+        radius: Int = 0,
+        font: String = "default",
+        fontSize: Int = 0,
+        fill: Boolean = false,
+        color: Int = -1,
+        points: List<Int> = emptyList(),
+        startDeg: Int = 0,
+        endDeg: Int = 0,
+        transitionMs: Int = 0,
+        easing: String = "ease",
+        hash: String = "h",
+        path: List<Int> = emptyList(), pathScale: Int = 256, fillRule: Int = 0, rotationQ8: Int = 0, pivotX: Int? = null, pivotY: Int? = null,
+        depth: Int = 0,
+    ) = SceneElement(
+        id = id, type = type, x = x, y = y, w = w, h = h, text = text, data = null, border = border,
+        radius = radius, change = "created", contentHash = hash, font = font, fontSize = fontSize, fill = fill,
+        color = color,
+        points = points, startDeg = startDeg, endDeg = endDeg, transitionMs = transitionMs, easing = easing,
+        path = path, pathScale = pathScale, fillRule = fillRule, rotationQ8 = rotationQ8, pivotX = pivotX, pivotY = pivotY,
+        depth = depth,
+    )
+
+    private fun frame(elements: List<SceneElement>, replay: Boolean = false) =
+        SceneFrame("app", 1, replay, elements, emptyList())
+
+    private fun encode(scene: G2CfwScene, cache: G2CfwTextureCache, elements: List<SceneElement>, inlineText: Boolean = false, tag: Int? = null, parallax: Int = 0) =
+        scene.encode(frame(elements), 32, 96, cache, { _, w, h -> ByteArray(w * h) { 0xFF.toByte() } }, inlineText, null, tag, parallax)
+
+    private fun le(vararg values: Int): List<Int> = values.flatMap { v -> listOf(v and 0xFF, (v ushr 8) and 0xFF) }
+    private fun u32(v: Int): List<Int> = listOf(v and 0xFF, (v ushr 8) and 0xFF, (v ushr 16) and 0xFF, (v ushr 24) and 0xFF)
+
+    private class Parsed(val request: Int, val flags: Int, val puts: List<List<Int>>, val refs: List<Pair<Int, Int>>, val ops: List<Int>)
+
+    /** Split a SHOW into its parts by walking the wire format. */
+    private fun parse(payload: ByteArray): Parsed {
+        val b = payload.map { it.toInt() and 0xFF }
+        assertEquals(38, b[0])
+        assertEquals("the encoder leaves the epoch to the link", listOf(0, 0), b.subList(1, 3))
+        var pos = 8
+        val puts = mutableListOf<List<Int>>()
+        repeat(b[7]) {
+            assertEquals(1, b[pos])
+            val recordLength = when (val type = b[pos + 9]) {
+                17 -> 13 + b[pos + 9 + 12]
+                18 -> 12 + (b[pos + 9 + 10] or (b[pos + 9 + 11] shl 8))
+                14, 15 -> 12
+                16 -> 16
+                else -> { assertTrue(type in 1..13); 20 }
+            }
+            puts.add(b.subList(pos, pos + 9 + recordLength))
+            pos += 9 + recordLength
+        }
+        val count = b[pos] or (b[pos + 1] shl 8)
+        pos += 2
+        val refs = mutableListOf<Pair<Int, Int>>()
+        repeat(count) {
+            val id = b[pos] or (b[pos + 1] shl 8) or (b[pos + 2] shl 16) or (b[pos + 3] shl 24)
+            val ver = b[pos + 4] or (b[pos + 5] shl 8) or (b[pos + 6] shl 16) or (b[pos + 7] shl 24)
+            refs.add(id to ver)
+            pos += 8
+        }
+        return Parsed(b[3] or (b[4] shl 8), b[5], puts, refs, b.subList(pos, b.size))
+    }
+
+    private fun fresh(): Pair<G2CfwScene, G2CfwTextureCache> {
+        val scene = G2CfwScene()
+        val cache = G2CfwTextureCache()
+        cache.reset(1)
+        scene.reset(1)
+        return scene to cache
+    }
+
+    @Test
+    fun warmUpIsOneShowOfADotWithATween() {
+        val p = parse(G2CfwScene.WARM_UP_SHOW)
+        assertEquals(1, p.flags)
+        assertEquals(1, p.puts.size)
+        assertEquals(listOf(5, 1, 0, 0), p.puts[0].subList(9, 13))
+        assertEquals(listOf(G2CfwScene.WARM_UP_ID to 1), p.refs)
+        assertEquals(listOf(5) + u32(G2CfwScene.WARM_UP_ID) + listOf(1, 0, 2, 0, 0, 255, 255), p.ops.subList(0, 12))
+        assertArrayEquals(byteArrayOf(39, 0, 0, 0, 0, 1, 0), G2CfwScene.HIDE_PAYLOAD)
+        assertArrayEquals(byteArrayOf(41, 0, 0, 0, 0, 0), G2CfwScene.RESET_PAYLOAD)
+    }
+
+    @Test
+    fun shapesBecomeObjectDefinitionsWithOffsetGeometry() {
+        val (scene, cache) = fresh()
+        val encoded = encode(
+            scene, cache,
+            listOf(
+                element("l", "line", points = listOf(10, 20, 30, 40), border = 3, color = 12),
+                element("c", "circle", x = 100, y = 100, w = 41, h = 41, fill = true),
+                element("a", "arc", w = 101, h = 101, border = 4, startDeg = -90, endDeg = 180),
+                element("r", "rect", x = 1, y = 2, w = 30, h = 20, border = 2, radius = 6, fill = true),
+            ),
+            tag = 77,
+        )
+        assertNotNull(encoded)
+        val p = parse(encoded!!.payload)
+        assertEquals(77, p.request)
+        assertEquals(5, p.flags)
+        assertEquals(5, p.puts.size)
+        assertEquals(u32(G2CfwScene.objectId("l", 0)), p.puts[0].subList(1, 5))
+        assertEquals(listOf(1, 1, 12, 3), p.puts[0].subList(9, 13))
+        assertEquals(le(42, 116, 62, 136), p.puts[0].subList(13, 21))
+        assertEquals(listOf(5, 1, 15, 0), p.puts[1].subList(9, 13))
+        assertEquals(le(152, 216, 20), p.puts[1].subList(13, 19))
+        assertEquals(listOf(12, 1, 15, 4), p.puts[2].subList(9, 13))
+        assertEquals(le(-90, 180), p.puts[2].subList(19, 23))
+        assertEquals(listOf(3, 1, 15, 0), p.puts[3].subList(9, 13))
+        assertEquals(listOf(2, 1, 15, 2), p.puts[4].subList(9, 13))
+        assertEquals(
+            listOf(G2CfwScene.objectId("l", 0), G2CfwScene.objectId("c", 0), G2CfwScene.objectId("a", 0), G2CfwScene.objectId("r", 0), G2CfwScene.objectId("r", 1)),
+            p.refs.map { it.first },
+        )
+        assertEquals(p.puts[0][5] or (p.puts[0][6] shl 8) or (p.puts[0][7] shl 16) or (p.puts[0][8] shl 24), p.refs[0].second)
+        assertTrue(p.ops.isEmpty())
+        assertTrue(encoded.uploads.isEmpty())
+        assertTrue(encoded.changed)
+        assertEquals(5, encoded.puts)
+    }
+
+    @Test
+    fun svgDefinitionAndTransformOpsMatchTheWireFormat() {
+        val (scene, cache) = fresh()
+        val path = listOf(0, 0, 0, 0, 0, 1, 160, 0, 0, 0, 1, 160, 0, 160, 0, 4)
+        val svg = element("s", "svg", x = 10, y = 20, path = path, pathScale = 512, fillRule = 1, rotationQ8 = 90 * 256, pivotX = 40, pivotY = 50)
+        val first = parse(encode(scene, cache, listOf(svg))!!.payload)
+        assertEquals(1, first.puts.size)
+        val record = first.puts[0].subList(9, first.puts[0].size)
+        assertEquals(listOf(18, 1, 15, 1), record.subList(0, 4))
+        assertEquals(le(42, 116, 512) + listOf(16, 0), record.subList(4, 12))
+        assertEquals(path, record.subList(12, record.size))
+        val id = G2CfwScene.objectId("s", 0)
+        assertEquals(listOf(9) + u32(id) + listOf(0, 90, 0, 0), first.ops.subList(0, 9))
+        assertEquals(le(72, 146, 0) + listOf(64, 26, 64, 255), first.ops.subList(9, 19))
+        val moved = element("s", "svg", x = 30, y = 20, path = path, pathScale = 256, fillRule = 1, rotationQ8 = 180 * 256, pivotX = 40, pivotY = 50, transitionMs = 330, easing = "linear")
+        val second = encode(scene, cache, listOf(moved))!!
+        val q = parse(second.payload)
+        assertTrue(q.puts.isEmpty())
+        assertEquals(1, q.refs.size)
+        assertEquals(listOf(5) + u32(id) + listOf(0x07, 0x01, 10, 0, 0, 255, 255), q.ops.subList(0, 12))
+        assertEquals(le(62, 116, 256, 15), q.ops.subList(12, 20))
+        assertEquals(listOf(9) + u32(id) + listOf(0, 180, 0, 0), q.ops.subList(20, 29))
+        assertEquals(le(330), q.ops.subList(33, 35))
+        assertEquals(0, second.hits)
+        assertEquals(1, second.tweens)
+    }
+
+    @Test
+    fun movedElementWithTransitionBecomesTween() {
+        val (scene, cache) = fresh()
+        encode(scene, cache, listOf(element("ball", "circle", w = 21, h = 21, fill = true)))
+        val encoded = encode(scene, cache, listOf(element("ball", "circle", x = 200, w = 21, h = 21, fill = true, transitionMs = 330, easing = "linear")))!!
+        val p = parse(encoded.payload)
+        val id = G2CfwScene.objectId("ball", 0)
+        assertTrue(p.puts.isEmpty())
+        assertEquals(listOf(id), p.refs.map { it.first })
+        assertEquals(listOf(5) + u32(id) + listOf(0x07, 0x03, 10, 0, 0, 255, 255), p.ops.subList(0, 12))
+        assertEquals(le(242, 106, 10, 15, 0), p.ops.subList(12, 22))
+        assertEquals(22, p.ops.size)
+        assertEquals(1, encoded.tweens)
+    }
+
+    @Test
+    fun geometryChangeWithoutTransitionAndTypeChangeRedefine() {
+        val (scene, cache) = fresh()
+        encode(scene, cache, listOf(element("s", "circle", w = 11, h = 11)))
+        val moved = parse(encode(scene, cache, listOf(element("s", "circle", x = 5, w = 11, h = 11)))!!.payload)
+        assertEquals(1, moved.puts.size)
+        assertTrue(moved.ops.isEmpty())
+        val retyped = parse(encode(scene, cache, listOf(element("s", "circle", x = 5, w = 11, h = 11, fill = true, transitionMs = 500)))!!.payload)
+        assertEquals(1, retyped.puts.size)
+        assertEquals(5, retyped.puts[0][9])
+        assertTrue(retyped.ops.isEmpty())
+    }
+
+    @Test
+    fun removalLeavesTheListAndReappearanceIsAReference() {
+        val (scene, cache) = fresh()
+        val a = element("a", "circle", w = 11, h = 11)
+        val b = element("b", "circle", w = 11, h = 11)
+        encode(scene, cache, listOf(a, b))
+        val onlyB = encode(scene, cache, listOf(b))!!
+        var p = parse(onlyB.payload)
+        assertTrue(p.puts.isEmpty())
+        assertEquals(listOf(G2CfwScene.objectId("b", 0)), p.refs.map { it.first })
+        assertTrue(onlyB.changed)
+        assertEquals(2, scene.known.size)
+        val both = encode(scene, cache, listOf(a, b))!!
+        p = parse(both.payload)
+        assertTrue(p.puts.isEmpty())
+        assertEquals(2, p.refs.size)
+        assertEquals(2, both.hits)
+        assertFalse(encode(scene, cache, listOf(a, b))!!.changed)
+        scene.hidden()
+        val reopen = encode(scene, cache, listOf(a, b))!!
+        assertTrue(reopen.changed)
+        assertEquals(2, reopen.hits)
+        assertEquals(0, parse(reopen.payload).puts.size)
+    }
+
+    @Test
+    fun hiddenMidTweenObjectsAreSnappedWhenShownAgain() {
+        val (scene, cache) = fresh()
+        encode(scene, cache, listOf(element("ball", "circle", w = 21, h = 21, fill = true)))
+        encode(scene, cache, listOf(element("ball", "circle", x = 200, w = 21, h = 21, fill = true, transitionMs = 3000)))
+        scene.hidden()
+        val p = parse(encode(scene, cache, listOf(element("ball", "circle", x = 200, w = 21, h = 21, fill = true)))!!.payload)
+        assertTrue(p.puts.isEmpty())
+        assertEquals(listOf(5) + u32(G2CfwScene.objectId("ball", 0)) + listOf(0x07, 0x03, 0, 64, 26, 64, 255), p.ops.subList(0, 12))
+        assertEquals(le(242, 106), p.ops.subList(12, 16))
+    }
+
+    @Test
+    fun objectReturningToTheFrameSnapsInsteadOfTweeningFromWhereItLeft() {
+        val (scene, cache) = fresh()
+        val bg = element("bg", "rect", w = 50, h = 10, fill = true)
+        fun ball(x: Int, ms: Int = 0) = element("ball", "circle", x = x, w = 21, h = 21, fill = true, transitionMs = ms, easing = "linear")
+        val id = G2CfwScene.objectId("ball", 0)
+        encode(scene, cache, listOf(bg, ball(200)))
+        encode(scene, cache, listOf(bg, ball(0, 330)))
+        encode(scene, cache, listOf(bg))
+        // Back at its resident definition with a transition: snapped there, not slid over from x=0.
+        val back = encode(scene, cache, listOf(bg, ball(200, 330)))!!
+        val p = parse(back.payload)
+        assertTrue(p.puts.isEmpty())
+        assertEquals(0, back.tweens)
+        assertEquals(listOf(5) + u32(id) + listOf(0x07, 0x03, 0, 0, 0, 255, 255), p.ops.subList(0, 12))
+        assertEquals(le(242, 106), p.ops.subList(12, 16))
+        // Once on screen it animates again.
+        val slid = encode(scene, cache, listOf(bg, ball(0, 330)))!!
+        assertEquals(1, slid.tweens)
+        assertEquals(listOf(0x07, 0x03, 10), parse(slid.payload).ops.subList(5, 8))
+    }
+
+    @Test
+    fun forgetRedefinesOnlyTheMissingObjects() {
+        val (scene, cache) = fresh()
+        val a = element("a", "circle", w = 11, h = 11)
+        val b = element("b", "circle", w = 11, h = 11)
+        encode(scene, cache, listOf(a, b))
+        scene.forget(listOf(G2CfwScene.objectId("a", 0)))
+        val p = parse(encode(scene, cache, listOf(a, b))!!.payload)
+        assertEquals(1, p.puts.size)
+        assertEquals(u32(G2CfwScene.objectId("a", 0)), p.puts[0].subList(1, 5))
+        assertEquals(2, p.refs.size)
+        scene.invalidate()
+        assertEquals(2, parse(encode(scene, cache, listOf(a, b))!!.payload).puts.size)
+    }
+
+    @Test
+    fun builtinTextAndRasterTilesUseAssets() {
+        val (scene, cache) = fresh()
+        val encoded = encode(
+            scene, cache,
+            listOf(
+                element("t", "text", w = 100, h = 30, text = "hi", font = "builtin"),
+                element("i", "image", y = 40, w = 300, h = 10, hash = "img"),
+            ),
+        )!!
+        val p = parse(encoded.payload)
+        assertEquals(3, p.puts.size)
+        assertEquals(listOf(15, 1, 0x1F, 0), p.puts[0].subList(9, 13))
+        val stringId = G2CfwTextureCache.hash31("t:hi")
+        assertEquals(u32(stringId), p.puts[0].subList(17, 21))
+        assertEquals(listOf(14, 1, 0x0F, 0), p.puts[1].subList(9, 13))
+        assertEquals(le(32, 136), p.puts[1].subList(13, 17))
+        assertEquals(le(287, 136), p.puts[2].subList(13, 17))
+        assertEquals(1, encoded.uploads.size)
+        val upload = encoded.uploads[0].map { it.toInt() and 0xFF }
+        assertEquals(listOf(37, 0, 0, 0, 0), upload.subList(0, 5))
+        assertEquals(0, upload[5])
+        assertEquals(u32(stringId), upload.subList(6, 10))
+        assertEquals(G2CfwTextureCache.KIND_STRING, upload[14])
+        assertEquals(u32(2), upload.subList(15, 19))
+        assertEquals("hi".toByteArray().map { it.toInt() }, upload.subList(25, 27))
+        assertEquals(G2CfwTextureCache.KIND_IMAGE, upload[36])
+        assertEquals(2, setOf(p.puts[1].subList(17, 21), p.puts[2].subList(17, 21)).size)
+        assertTrue(encode(scene, cache, listOf(element("t", "text", w = 100, h = 30, text = "hi", font = "builtin")))!!.uploads.isEmpty())
+    }
+
+    @Test
+    fun imagesShareAssetsByPixelsAndFadeAsTweens() {
+        val (scene, cache) = fresh()
+        val first = encode(
+            scene, cache,
+            listOf(
+                element("a", "image", w = 10, h = 10, color = 15, hash = "one"),
+                element("b", "image", x = 20, w = 10, h = 10, color = 15, hash = "two"),
+            ),
+        )!!
+        val p = parse(first.payload)
+        assertEquals(p.puts[0].subList(17, 21), p.puts[1].subList(17, 21))
+        assertEquals(1, first.uploads.size)
+        val faded = encode(
+            scene, cache,
+            listOf(
+                element("a", "image", w = 10, h = 10, color = 8, hash = "one", transitionMs = 330),
+                element("b", "image", x = 20, w = 10, h = 10, color = 15, hash = "two"),
+            ),
+        )!!
+        val q = parse(faded.payload)
+        assertTrue(q.puts.isEmpty())
+        assertEquals(listOf(0x03, 0x01, 10), q.ops.subList(5, 8))
+        assertEquals(le(32, 96, 8), q.ops.subList(12, 18))
+    }
+
+    @Test
+    fun tooManyObjectsReturnsNull() {
+        val (scene, cache) = fresh()
+        val many = (0 until 257).map { element("e$it", "circle", w = 5, h = 5) }
+        assertNull(encode(scene, cache, many))
+        assertNotNull(encode(scene, cache, many.take(256)))
+    }
+
+    @Test
+    fun textBytesStripControlsAndCutAtCodepoints() {
+        assertArrayEquals(byteArrayOf(0x61, 0x62), G2CfwScene.textBytes("a\u0001bé", 3))
+        assertArrayEquals("héllo".toByteArray(Charsets.UTF_8), G2CfwScene.textBytes("héllo", 64))
+    }
+
+    @Test
+    fun inlineTextRecordsCarryTheirBytesAndAnimate() {
+        val (scene, cache) = fresh()
+        fun t(y: Int, text: String, color: Int, ms: Int) = element("t", "text", x = 10, y = y, w = 200, h = 60, text = text, color = color, transitionMs = ms)
+        val first = encode(scene, cache, listOf(t(10, "hi\nthere", 9, 0)), inlineText = true)!!
+        val p = parse(first.payload)
+        assertEquals(2, p.puts.size)
+        assertEquals(listOf(17, 1, 0x19, 0), p.puts[0].subList(9, 13))
+        assertEquals(le(44, 108, 198, 58), p.puts[0].subList(13, 21))
+        assertEquals(listOf(2, 0x68, 0x69), p.puts[0].subList(21, 24))
+        assertEquals(le(44, 135, 198, 31), p.puts[1].subList(13, 21))
+        assertEquals("there".toByteArray().map { it.toInt() }, p.puts[1].subList(22, 27))
+        assertTrue(first.uploads.isEmpty())
+        val q = parse(encode(scene, cache, listOf(t(40, "hi\nthere", 9, 330)), inlineText = true)!!.payload)
+        assertTrue(q.puts.isEmpty())
+        assertEquals(listOf(0x0F, 0x01, 10), q.ops.subList(5, 8))
+        assertEquals(le(44, 138, 198, 58, 0x19), q.ops.subList(12, 22))
+        assertEquals(1, parse(encode(scene, cache, listOf(t(40, "ho\nthere", 9, 330)), inlineText = true)!!.payload).puts.size)
+        val r = parse(encode(scene, cache, listOf(t(40, "ho\nthere", 3, 330)), inlineText = true)!!.payload)
+        assertEquals(44, r.ops.size)
+        assertEquals(le(0x13), r.ops.subList(20, 22))
+    }
+
+    private val mono = G2CfwScene.MonoFace({ 6 to 12 }) { _, _, w, h -> ByteArray(w * h) { 0xFF.toByte() } }
+
+    @Test
+    fun monoTextBecomesCachedFontRunsThatTween() {
+        val (scene, cache) = fresh()
+        val grid = element("g", "text", w = 60, h = 24, text = "ab\ncd", font = "mono", fontSize = 12)
+        val encoded = scene.encode(frame(listOf(grid)), 32, 96, cache, { _, _, _ -> null }, true, mono)!!
+        val p = parse(encoded.payload)
+        assertEquals(2, p.puts.size)
+        assertEquals(listOf(16, 1, 15, 0), p.puts[0].subList(9, 13))
+        assertEquals(le(34, 98), p.puts[0].subList(13, 17))
+        val fontId = G2CfwTextureCache.hash31("font:12:6x12:ascii")
+        assertEquals(u32(fontId), p.puts[0].subList(21, 25))
+        assertEquals(u32(G2CfwTextureCache.hash31("t:ascii:ab")), p.puts[0].subList(17, 21))
+        assertFalse(encoded.uploads.isEmpty())
+        val entries = encoded.uploads.flatMap { it.drop(5) }.map { it.toInt() and 0xFF }
+        assertEquals(0, entries[0])
+        assertEquals(u32(fontId), entries.subList(1, 5))
+        assertEquals(G2CfwTextureCache.KIND_FONT, entries[9])
+        assertEquals(96 * 4 + 95 * (2 + 2), entries[10] or (entries[11] shl 8) or (entries[12] shl 16))
+        val moved = scene.encode(frame(listOf(element("g", "text", y = 20, w = 60, h = 24, text = "ab\ncd", font = "mono", fontSize = 12, transitionMs = 330))), 32, 96, cache, { _, _, _ -> null }, true, mono)!!
+        val q = parse(moved.payload)
+        assertTrue(q.puts.isEmpty())
+        assertTrue(moved.uploads.isEmpty())
+        assertEquals(listOf(0x03, 0x01, 10), q.ops.subList(5, 8))
+        assertEquals(le(34, 118, 15), q.ops.subList(12, 18))
+    }
+
+    @Test
+    fun halfBlockGridUsesASeparateFontAndNonAsciiKeepsTiles() {
+        val (scene, cache) = fresh()
+        val blocks = element("b", "text", w = 60, h = 12, text = "▀▄█ ", font = "mono", fontSize = 12)
+        val p = parse(scene.encode(frame(listOf(blocks)), 32, 96, cache, { _, _, _ -> null }, true, mono)!!.payload)
+        assertEquals(1, p.puts.size)
+        assertEquals(u32(G2CfwTextureCache.hash31("font:12:6x12:blocks")), p.puts[0].subList(21, 25))
+        assertEquals(u32(G2CfwTextureCache.hash31("t:blocks:▀▄█ ")), p.puts[0].subList(17, 21))
+        val mixed = element("m", "text", w = 60, h = 12, text = "a▀", font = "mono", fontSize = 12)
+        val tiles = scene.encode(frame(listOf(mixed)), 32, 96, cache, { _, w, h -> ByteArray(w * h) { 0xFF.toByte() } }, true, mono)!!
+        assertEquals(14, parse(tiles.payload).puts[0][9])
+    }
+
+    @Test
+    fun movingBackToTheResidentDefinitionWithoutTransitionSnapsInsteadOfRedefining() {
+        val (scene, cache) = fresh()
+        val home = element("row", "rect", x = 300, y = 40, w = 200, h = 30, border = 1, hash = "r")
+        val away = element("row", "rect", x = 20, y = 80, w = 500, h = 30, border = 1, transitionMs = 300, hash = "r")
+        val first = encode(scene, cache, listOf(home))!!
+        assertEquals(1, first.puts)
+        val moved = encode(scene, cache, listOf(away))!!
+        assertEquals("a transition tweens the row away; its version stays", 1, moved.tweens)
+        // Back home with no transition: a PUT of the same version would be a firmware
+        // no-op and leave the row where the tween put it, so the encoder snaps it.
+        val back = encode(scene, cache, listOf(home))!!
+        assertEquals(0, back.puts)
+        assertEquals(1, back.hits)
+        assertTrue(back.changed)
+        val p = parse(back.payload)
+        assertEquals("same version as the original definition", parse(first.payload).refs.map { it.second }, p.refs.map { it.second })
+        assertEquals("a TWEEN op", 5, p.ops[0])
+        assertEquals("of zero frames", 0, p.ops[7])
+        assertFalse(encode(scene, cache, listOf(home))!!.changed)
+        val restyled = element("row", "rect", x = 300, y = 40, w = 200, h = 30, border = 3, hash = "r")
+        assertEquals(1, encode(scene, cache, listOf(restyled))!!.puts)
+    }
+
+    @Test
+    fun depthShiftsEachLensMirrorTheOppositeWayAndFlatEncodesIgnoreIt() {
+
+        val cache = G2CfwTextureCache().also { it.reset(1) }
+        val card = element("card", "rect", x = 100, y = 40, w = 200, h = 100, border = 2, depth = 8, hash = "c")
+        val flat = element("bg", "rect", x = 10, y = 10, w = 50, h = 50, border = 1, hash = "b")
+        val left = G2CfwScene().also { it.reset(1) }
+        val right = G2CfwScene().also { it.reset(1) }
+        val mono = G2CfwScene().also { it.reset(1) }
+        val l = parse(encode(left, cache, listOf(flat, card), parallax = 1)!!.payload)
+        val r = parse(encode(right, cache, listOf(flat, card), parallax = -1)!!.payload)
+        val m = parse(encode(mono, cache, listOf(flat, card))!!.payload)
+        // A put is [1][id u32][version u32] + the record [type][flags][color][width][x i16][y i16]…
+        fun x(put: List<Int>) = (put[9 + 4] or (put[9 + 5] shl 8)).toShort().toInt()
+        assertEquals("flat elements sit at the window origin on every lens", 32 + 10, x(l.puts[0]))
+        assertEquals(32 + 10, x(r.puts[0]))
+        assertEquals("the left lens draws a near element further right", 32 + 100 + 8, x(l.puts[1]))
+        assertEquals("and the right lens further left", 32 + 100 - 8, x(r.puts[1]))
+        assertEquals("a flat encode ignores depth", 32 + 100, x(m.puts[1]))
+        assertEquals(l.puts[0], r.puts[0])
+        assertTrue(l.puts[1] != r.puts[1])
+        assertEquals("same object id on both lenses", l.refs[1].first, r.refs[1].first)
+        assertTrue("different versions", l.refs[1].second != r.refs[1].second)
+
+        // Bringing the card to the frame's plane with a transition tweens x on each lens, in opposite directions.
+        val level = element("card", "rect", x = 100, y = 40, w = 200, h = 100, border = 2, transitionMs = 330, hash = "c")
+        val l2 = encode(left, cache, listOf(flat, level), parallax = 1)!!
+        val r2 = encode(right, cache, listOf(flat, level), parallax = -1)!!
+        assertEquals(1, l2.tweens)
+        assertEquals(1, r2.tweens)
+        assertFalse(l2.payload.contentEquals(r2.payload))
+        assertEquals(0, parse(l2.payload).puts.size)
+    }
+
+    @Test
+    fun adoptCopiesTheMirrorSoTheSecondLensStartsFromSharedResidency() {
+        val (left, cache) = fresh()
+        val flat = element("bg", "rect", x = 10, y = 10, w = 50, h = 50, border = 1, hash = "b")
+        assertNotNull(encode(left, cache, listOf(flat)))
+        val right = G2CfwScene()
+        right.adopt(left)
+        assertEquals(1, right.generation)
+        assertEquals(left.active, right.active)
+        val again = encode(right, cache, listOf(flat), parallax = -1)!!
+        assertEquals("what the left lens holds, the right holds too", 0, again.puts)
+        assertEquals(1, again.hits)
+        assertFalse(again.changed)
+    }
+
+    @Test
+    fun onlyNonAnimatedImageFramesPreferRaster() {
+
+        val image = element("i", "image", w = 10, h = 10)
+        assertTrue(G2CfwScene.prefersRaster(frame(listOf(image))))
+        assertFalse(G2CfwScene.prefersRaster(frame(listOf(image, element("c", "circle", w = 5, h = 5)))))
+        assertFalse(G2CfwScene.prefersRaster(frame(listOf(element("i", "image", w = 10, h = 10, transitionMs = 100)))))
+        assertFalse(G2CfwScene.prefersRaster(frame(emptyList())))
+    }
+}