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

package/ios/Tests/BluetoothSDKTests/G2CfwSceneTests.swift

@@ -0,0 +1,497 @@
+@testable import BluetoothSDK
+import Foundation
+import XCTest
+
+final class G2CfwSceneTests: XCTestCase {
+    private func element(
+        _ id: String, type: String, x: Int32 = 0, y: Int32 = 0, w: Int32 = 0, h: Int32 = 0,
+        text: String? = nil, border: Int32 = 0, radius: Int32 = 0, font: String = "default", fontSize: Int32 = 0,
+        fill: Bool = false, color: Int32 = -1, points: [Int32] = [], startDeg: Int32 = 0, endDeg: Int32 = 0,
+        transitionMs: Int32 = 0, easing: String = "ease", hash: String = "h",
+        path: [UInt8] = [], pathScale: Int32 = 256, fillRule: Int32 = 0, rotationQ8: Int32 = 0, pivotX: Int32? = nil, pivotY: Int32? = nil,
+        depth: Int32 = 0
+    ) -> SceneElement {
+        SceneElement(
+            id: id, type: type, x: x, y: y, w: w, h: h, text: text, data: nil, 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 func frame(_ elements: [SceneElement], replay: Bool = false) -> SceneFrame {
+        SceneFrame(appId: "app", epoch: 1, replay: replay, elements: elements, removed: [])
+    }
+
+    private func encode(_ scene: G2CfwScene, _ cache: G2CfwTextureCache, _ elements: [SceneElement],
+                        replay: Bool = false, inlineText: Bool = false, tag: Int? = nil, parallax: Int = 0) -> G2CfwScene.Encoded?
+    {
+        scene.encode(frame(elements, replay: replay), originX: 32, originY: 96, inlineText: inlineText,
+                     tag: tag, parallax: parallax, cache: cache)
+        { _, w, h in
+            Data(repeating: 0xFF, count: w * h)
+        }
+    }
+
+    /// Little-endian int16 bytes of each value, concatenated.
+    private func le(_ values: Int...) -> [UInt8] {
+        var out: [UInt8] = []
+        for v in values {
+            let bits = UInt16(bitPattern: Int16(v))
+            out.append(UInt8(bits & 0xFF))
+            out.append(UInt8(bits >> 8))
+        }
+        return out
+    }
+
+    private func u32(_ v: UInt32) -> [UInt8] {
+        [UInt8(v & 0xFF), UInt8((v >> 8) & 0xFF), UInt8((v >> 16) & 0xFF), UInt8((v >> 24) & 0xFF)]
+    }
+
+    /// `[38][epoch 0][request][flags][bg][puts]`
+    private let header = 8
+
+    /// Split a SHOW into its parts by walking the wire format.
+    private func parse(_ payload: Data) -> (request: Int, flags: UInt8, puts: [[UInt8]], refs: [(UInt32, UInt32)], ops: [UInt8]) {
+        let b = [UInt8](payload)
+        XCTAssertEqual(b[0], 38)
+        XCTAssertEqual(Array(b[1 ..< 3]), [0, 0], "the encoder leaves the epoch to the link")
+        let request = Int(b[3]) | Int(b[4]) << 8
+        var pos = header
+        var puts: [[UInt8]] = []
+        for _ in 0 ..< Int(b[7]) {
+            XCTAssertEqual(b[pos], 1)
+            let type = b[pos + 9]
+            let recordLength: Int
+            switch type {
+            case 17: recordLength = 13 + Int(b[pos + 9 + 12])
+            case 18: recordLength = 12 + Int(b[pos + 9 + 10]) | Int(b[pos + 9 + 11]) << 8
+            case 14, 15: recordLength = 12
+            case 16: recordLength = 16
+            default: recordLength = 20
+            }
+            puts.append(Array(b[pos ..< pos + 9 + recordLength]))
+            pos += 9 + recordLength
+        }
+        let count = Int(b[pos]) | Int(b[pos + 1]) << 8
+        pos += 2
+        var refs: [(UInt32, UInt32)] = []
+        for _ in 0 ..< count {
+            let id = UInt32(b[pos]) | UInt32(b[pos + 1]) << 8 | UInt32(b[pos + 2]) << 16 | UInt32(b[pos + 3]) << 24
+            let ver = UInt32(b[pos + 4]) | UInt32(b[pos + 5]) << 8 | UInt32(b[pos + 6]) << 16 | UInt32(b[pos + 7]) << 24
+            refs.append((id, ver))
+            pos += 8
+        }
+        return (request, b[5], puts, refs, Array(b[pos...]))
+    }
+
+    private func fresh() -> (G2CfwScene, G2CfwTextureCache) {
+        let scene = G2CfwScene(), cache = G2CfwTextureCache()
+        scene.reset(generation: 1); cache.reset(generation: 1)
+        return (scene, cache)
+    }
+
+    /// The warm-up is one SHOW: a black 1 px dot defined, referenced and tweened for two frames.
+    func testWarmUpIsOneShowOfADotWithATween() {
+        let p = parse(G2CfwScene.warmUpShow)
+        XCTAssertEqual(p.flags, 0x01)
+        XCTAssertEqual(p.puts.count, 1)
+        XCTAssertEqual(Array(p.puts[0][9 ..< 13]), [5, 1, 0, 0])
+        XCTAssertEqual(p.refs.count, 1)
+        XCTAssertEqual(p.refs[0].0, G2CfwScene.warmUpId)
+        XCTAssertEqual(Array(p.ops[0 ..< 5]), [5] + u32(G2CfwScene.warmUpId))
+        XCTAssertEqual(Array(p.ops[5 ..< 12]), [0x01, 0x00, 2, 0, 0, 255, 255])
+        XCTAssertEqual(G2CfwScene.hidePayload, Data([39, 0, 0, 0, 0, 1, 0]))
+        XCTAssertEqual(G2CfwScene.resetPayload, Data([41, 0, 0, 0, 0, 0]))
+    }
+
+    func testShapesBecomeObjectDefinitionsWithOffsetGeometry() throws {
+        let (scene, cache) = fresh()
+        let encoded = try XCTUnwrap(encode(scene, cache, [
+            element("l", type: "line", border: 3, color: 12, points: [10, 20, 30, 40]),
+            element("c", type: "circle", x: 100, y: 100, w: 41, h: 41, fill: true),
+            element("a", type: "arc", x: 0, y: 0, w: 101, h: 101, border: 4, startDeg: -90, endDeg: 180),
+            element("r", type: "rect", x: 1, y: 2, w: 30, h: 20, border: 2, radius: 6, fill: true),
+        ], tag: 77))
+        let p = parse(encoded.payload)
+        XCTAssertEqual(p.request, 77)
+        XCTAssertEqual(p.flags, 0x05, "PRESENT + TAG")
+        XCTAssertEqual(p.puts.count, 5)
+        XCTAssertEqual(Array(p.puts[0][1 ..< 5]), u32(G2CfwScene.objectId("l", 0)))
+        XCTAssertEqual(Array(p.puts[0][9 ..< 13]), [1, 1, 12, 3])
+        XCTAssertEqual(Array(p.puts[0][13 ..< 21]), le(42, 116, 62, 136))
+        XCTAssertEqual(Array(p.puts[1][9 ..< 13]), [5, 1, 15, 0])
+        XCTAssertEqual(Array(p.puts[1][13 ..< 19]), le(152, 216, 20))
+        XCTAssertEqual(Array(p.puts[2][9 ..< 13]), [12, 1, 15, 4])
+        XCTAssertEqual(Array(p.puts[2][19 ..< 23]), le(-90, 180))
+        XCTAssertEqual(Array(p.puts[3][9 ..< 13]), [3, 1, 15, 0])
+        XCTAssertEqual(Array(p.puts[4][9 ..< 13]), [2, 1, 15, 2])
+        XCTAssertEqual(p.refs.map { $0.0 }, [G2CfwScene.objectId("l", 0), G2CfwScene.objectId("c", 0), G2CfwScene.objectId("a", 0), G2CfwScene.objectId("r", 0), G2CfwScene.objectId("r", 1)])
+        let putVersion = UInt32(p.puts[0][5]) | UInt32(p.puts[0][6]) << 8
+        let putVersionHigh = UInt32(p.puts[0][7]) << 16 | UInt32(p.puts[0][8]) << 24
+        XCTAssertEqual(p.refs[0].1, putVersion | putVersionHigh)
+        XCTAssertTrue(p.ops.isEmpty)
+        XCTAssertTrue(encoded.uploads.isEmpty)
+        XCTAssertTrue(encoded.changed)
+        XCTAssertEqual(encoded.puts, 5)
+        XCTAssertEqual(scene.objectIds, [[G2CfwScene.objectId("l", 0)], [G2CfwScene.objectId("c", 0)], [G2CfwScene.objectId("a", 0)], [G2CfwScene.objectId("r", 0), G2CfwScene.objectId("r", 1)]])
+    }
+
+    func testSvgDefinitionAndTransformOpsMatchTheWireFormat() throws {
+        let (scene, cache) = fresh()
+        let path: [UInt8] = [0, 0, 0, 0, 0, 1, 160, 0, 0, 0, 1, 160, 0, 160, 0, 4]
+        let svg = element("s", type: "svg", x: 10, y: 20, path: path, pathScale: 512, fillRule: 1, rotationQ8: 90 * 256, pivotX: 40, pivotY: 50)
+        let first = try XCTUnwrap(encode(scene, cache, [svg]))
+        let p = parse(first.payload)
+        XCTAssertEqual(p.puts.count, 1)
+        let record = Array(p.puts[0][9...])
+        XCTAssertEqual(Array(record[0 ..< 4]), [18, 1, 15, 1])
+        XCTAssertEqual(Array(record[4 ..< 12]), le(42, 116, 512) + [16, 0])
+        XCTAssertEqual(Array(record[12...]), path)
+        // rotated at definition time: a 0 ms ROTATE follows
+        let id = G2CfwScene.objectId("s", 0)
+        XCTAssertEqual(Array(p.ops[0 ..< 5]), [9] + u32(id))
+        XCTAssertEqual(Array(p.ops[5 ..< 9]), [0, 90, 0, 0])
+        XCTAssertEqual(Array(p.ops[9 ..< 19]), le(72, 146, 0) + [64, 26, 64, 255])
+        // move + scale + rotate with a transition: a TWEEN and a ROTATE on a pure reference
+        let moved = element("s", type: "svg", x: 30, y: 20, transitionMs: 330, easing: "linear", path: path, pathScale: 256, fillRule: 1, rotationQ8: 180 * 256, pivotX: 40, pivotY: 50)
+        let second = try XCTUnwrap(encode(scene, cache, [moved]))
+        let q = parse(second.payload)
+        XCTAssertTrue(q.puts.isEmpty)
+        XCTAssertEqual(q.refs.count, 1)
+        XCTAssertEqual(Array(q.ops[0 ..< 12]), [5] + u32(id) + [0x07, 0x01, 10, 0, 0, 255, 255])
+        XCTAssertEqual(Array(q.ops[12 ..< 20]), le(62, 116, 256, 15))
+        XCTAssertEqual(Array(q.ops[20 ..< 25]), [9] + u32(id))
+        XCTAssertEqual(Array(q.ops[25 ..< 29]), [0, 180, 0, 0])
+        XCTAssertEqual(Array(q.ops[33 ..< 35]), le(330))
+        XCTAssertEqual(second.hits, 0)
+        XCTAssertEqual(second.tweens, 1)
+    }
+
+    func testMovedElementWithTransitionBecomesTween() throws {
+        let (scene, cache) = fresh()
+        _ = encode(scene, cache, [element("ball", type: "circle", x: 0, y: 0, w: 21, h: 21, fill: true)])
+        let encoded = try XCTUnwrap(encode(scene, cache, [
+            element("ball", type: "circle", x: 200, y: 0, w: 21, h: 21, fill: true, transitionMs: 330, easing: "linear"),
+        ]))
+        let p = parse(encoded.payload)
+        let id = G2CfwScene.objectId("ball", 0)
+        XCTAssertTrue(p.puts.isEmpty)
+        XCTAssertEqual(p.refs.map { $0.0 }, [id])
+        XCTAssertEqual(Array(p.ops[0 ..< 12]), [5] + u32(id) + [0x07, 0x03, 10, 0, 0, 255, 255])
+        XCTAssertEqual(Array(p.ops[12 ..< 22]), le(242, 106, 10, 15, 0)) // cx cy r color width: unchanged ones ride along
+        XCTAssertEqual(p.ops.count, 22)
+        XCTAssertEqual(encoded.hits, 0)
+        XCTAssertEqual(encoded.tweens, 1)
+    }
+
+    func testGeometryChangeWithoutTransitionAndTypeChangeRedefine() throws {
+        let (scene, cache) = fresh()
+        _ = encode(scene, cache, [element("s", type: "circle", x: 0, y: 0, w: 11, h: 11)])
+        let moved = try XCTUnwrap(encode(scene, cache, [element("s", type: "circle", x: 5, y: 0, w: 11, h: 11)]))
+        var p = parse(moved.payload)
+        XCTAssertEqual(p.puts.count, 1)
+        XCTAssertTrue(p.ops.isEmpty)
+        let retyped = try XCTUnwrap(encode(scene, cache, [element("s", type: "circle", x: 5, y: 0, w: 11, h: 11, fill: true, transitionMs: 500)]))
+        p = parse(retyped.payload)
+        XCTAssertEqual(p.puts.count, 1)
+        XCTAssertEqual(p.puts[0][9], 5)
+        XCTAssertTrue(p.ops.isEmpty)
+    }
+
+    func testRemovalLeavesTheListAndReappearanceIsAReference() throws {
+        let (scene, cache) = fresh()
+        let a = element("a", type: "circle", x: 0, y: 0, w: 11, h: 11), b = element("b", type: "circle", x: 0, y: 0, w: 11, h: 11)
+        _ = encode(scene, cache, [a, b])
+        let onlyB = try XCTUnwrap(encode(scene, cache, [b]))
+        var p = parse(onlyB.payload)
+        XCTAssertTrue(p.puts.isEmpty)
+        XCTAssertEqual(p.refs.map { $0.0 }, [G2CfwScene.objectId("b", 0)])
+        XCTAssertTrue(onlyB.changed)
+        XCTAssertEqual(scene.known.count, 2, "a stays cached")
+        let both = try XCTUnwrap(encode(scene, cache, [a, b]))
+        p = parse(both.payload)
+        XCTAssertTrue(p.puts.isEmpty)
+        XCTAssertEqual(p.refs.count, 2)
+        XCTAssertEqual(both.hits, 2)
+        // the same frame again is nothing to send
+        let same = try XCTUnwrap(encode(scene, cache, [a, b]))
+        XCTAssertFalse(same.changed)
+        // after a hide the same frame is a SHOW of references again
+        scene.hidden()
+        let reopen = try XCTUnwrap(encode(scene, cache, [a, b]))
+        XCTAssertTrue(reopen.changed)
+        XCTAssertEqual(reopen.hits, 2)
+        XCTAssertEqual(parse(reopen.payload).puts.count, 0)
+    }
+
+    func testHiddenMidTweenObjectsAreSnappedWhenShownAgain() throws {
+        let (scene, cache) = fresh()
+        _ = encode(scene, cache, [element("ball", type: "circle", x: 0, y: 0, w: 21, h: 21, fill: true)])
+        _ = encode(scene, cache, [element("ball", type: "circle", x: 200, y: 0, w: 21, h: 21, fill: true, transitionMs: 3000)])
+        scene.hidden()
+        let reopen = try XCTUnwrap(encode(scene, cache, [element("ball", type: "circle", x: 200, y: 0, w: 21, h: 21, fill: true)]))
+        let p = parse(reopen.payload)
+        XCTAssertTrue(p.puts.isEmpty)
+        XCTAssertEqual(Array(p.ops[0 ..< 12]), [5] + u32(G2CfwScene.objectId("ball", 0)) + [0x07, 0x03, 0, 64, 26, 64, 255])
+        XCTAssertEqual(Array(p.ops[12 ..< 16]), le(242, 106))
+    }
+
+    func testObjectReturningToTheFrameSnapsInsteadOfTweeningFromWhereItLeft() throws {
+        let (scene, cache) = fresh()
+        let bg = element("bg", type: "rect", w: 50, h: 10, fill: true)
+        func ball(_ x: Int32, _ ms: Int32 = 0) -> SceneElement {
+            element("ball", type: "circle", x: x, w: 21, h: 21, fill: true, transitionMs: ms, easing: "linear")
+        }
+        let id = G2CfwScene.objectId("ball", 0)
+        _ = encode(scene, cache, [bg, ball(200)])
+        _ = encode(scene, cache, [bg, ball(0, 330)])
+        _ = encode(scene, cache, [bg])
+        // Back at its resident definition with a transition: snapped there, not slid over from x=0.
+        let back = try XCTUnwrap(encode(scene, cache, [bg, ball(200, 330)]))
+        let p = parse(back.payload)
+        XCTAssertTrue(p.puts.isEmpty)
+        XCTAssertEqual(back.tweens, 0)
+        XCTAssertEqual(Array(p.ops[0 ..< 12]), [5] + u32(id) + [0x07, 0x03, 0, 0, 0, 255, 255])
+        XCTAssertEqual(Array(p.ops[12 ..< 16]), le(242, 106))
+        // Once on screen it animates again.
+        let slid = try XCTUnwrap(encode(scene, cache, [bg, ball(0, 330)]))
+        XCTAssertEqual(slid.tweens, 1)
+        XCTAssertEqual(Array(parse(slid.payload).ops[5 ..< 8]), [0x07, 0x03, 10])
+    }
+
+    func testForgetRedefinesOnlyTheMissingObjects() throws {
+        let (scene, cache) = fresh()
+        let a = element("a", type: "circle", x: 0, y: 0, w: 11, h: 11), b = element("b", type: "circle", x: 0, y: 0, w: 11, h: 11)
+        _ = encode(scene, cache, [a, b])
+        scene.forget(objectIds: [G2CfwScene.objectId("a", 0)])
+        let again = try XCTUnwrap(encode(scene, cache, [a, b]))
+        let p = parse(again.payload)
+        XCTAssertEqual(p.puts.count, 1)
+        XCTAssertEqual(Array(p.puts[0][1 ..< 5]), u32(G2CfwScene.objectId("a", 0)))
+        XCTAssertEqual(p.refs.count, 2)
+        scene.invalidate()
+        XCTAssertEqual(parse(try XCTUnwrap(encode(scene, cache, [a, b])).payload).puts.count, 2)
+    }
+
+    func testBuiltinTextAndRasterTilesUseAssets() throws {
+        let (scene, cache) = fresh()
+        let encoded = try XCTUnwrap(encode(scene, cache, [
+            element("t", type: "text", x: 0, y: 0, w: 100, h: 30, text: "hi", font: "builtin"),
+            element("i", type: "image", x: 0, y: 40, w: 300, h: 10, hash: "img"),
+        ]))
+        let p = parse(encoded.payload)
+        XCTAssertEqual(p.puts.count, 3)
+        XCTAssertEqual(Array(p.puts[0][9 ..< 13]), [15, 1, 0x1F, 0])
+        let stringId = G2CfwTextureCache.hash31("t:hi")
+        XCTAssertEqual(Array(p.puts[0][17 ..< 21]), u32(stringId))
+        XCTAssertEqual(Array(p.puts[1][9 ..< 13]), [14, 1, 0x0F, 0])
+        XCTAssertEqual(Array(p.puts[1][13 ..< 17]), le(32, 136))
+        XCTAssertEqual(Array(p.puts[2][13 ..< 17]), le(287, 136), "second tile starts at 255")
+        // the uploads: one PUT with the string and the two tiles (identical pixels share one asset)
+        XCTAssertEqual(encoded.uploads.count, 1)
+        let upload = [UInt8](encoded.uploads[0])
+        XCTAssertEqual(Array(upload[0 ..< 5]), [37, 0, 0, 0, 0])
+        XCTAssertEqual(upload[5], 0)
+        XCTAssertEqual(Array(upload[6 ..< 10]), u32(stringId))
+        XCTAssertEqual(upload[14], G2CfwTextureCache.kindString)
+        XCTAssertEqual(Array(upload[15 ..< 19]), u32(2))
+        XCTAssertEqual(Array(upload[25 ..< 27]), Array("hi".utf8))
+        XCTAssertEqual(upload[27], 0)
+        XCTAssertEqual(upload[36], G2CfwTextureCache.kindImage)
+        let tiles = Set([Array(p.puts[1][17 ..< 21]), Array(p.puts[2][17 ..< 21])])
+        XCTAssertEqual(tiles.count, 2, "255x10 and 45x10 tiles are distinct assets")
+        XCTAssertTrue(encode(scene, cache, [element("t", type: "text", x: 0, y: 0, w: 100, h: 30, text: "hi", font: "builtin")])!.uploads.isEmpty, "resident assets do not re-upload")
+    }
+
+    func testImagesShareAssetsByPixelsAndFadeAsTweens() throws {
+        let (scene, cache) = fresh()
+        let first = try XCTUnwrap(encode(scene, cache, [
+            element("a", type: "image", x: 0, y: 0, w: 10, h: 10, color: 15, hash: "one"),
+            element("b", type: "image", x: 20, y: 0, w: 10, h: 10, color: 15, hash: "two"),
+        ]))
+        let p = parse(first.payload)
+        XCTAssertEqual(Array(p.puts[0][17 ..< 21]), Array(p.puts[1][17 ..< 21]))
+        XCTAssertEqual(first.uploads.count, 1)
+        let faded = try XCTUnwrap(encode(scene, cache, [
+            element("a", type: "image", x: 0, y: 0, w: 10, h: 10, color: 8, transitionMs: 330, hash: "one"),
+            element("b", type: "image", x: 20, y: 0, w: 10, h: 10, color: 15, hash: "two"),
+        ]))
+        let q = parse(faded.payload)
+        XCTAssertTrue(q.puts.isEmpty)
+        XCTAssertEqual(Array(q.ops[5 ..< 8]), [0x03, 0x01, 10])
+        XCTAssertEqual(Array(q.ops[12 ..< 18]), le(32, 96, 8))
+    }
+
+    func testTooManyObjectsReturnsNil() {
+        let (scene, cache) = fresh()
+        let many = (0 ..< 257).map { element("e\($0)", type: "circle", x: 0, y: 0, w: 5, h: 5) }
+        XCTAssertNil(encode(scene, cache, many))
+        XCTAssertNotNil(encode(scene, cache, Array(many.prefix(256))))
+    }
+
+    func testTextBytesStripControlsAndCutAtCodepoints() {
+        XCTAssertEqual(G2CfwScene.textBytes("a\u{1}b\u{e9}", max: 3), [0x61, 0x62])
+        XCTAssertEqual(G2CfwScene.textBytes("héllo", max: 64), Array("héllo".utf8))
+    }
+
+    func testInlineTextRecordsCarryTheirBytesAndAnimate() throws {
+        let (scene, cache) = fresh()
+        let t = { (y: Int32, text: String, color: Int32, ms: Int32) in
+            self.element("t", type: "text", x: 10, y: y, w: 200, h: 60, text: text, color: color, transitionMs: ms)
+        }
+        let first = try XCTUnwrap(encode(scene, cache, [t(10, "hi\nthere", 9, 0)], inlineText: true))
+        let p = parse(first.payload)
+        XCTAssertEqual(p.puts.count, 2)
+        XCTAssertEqual(Array(p.puts[0][9 ..< 13]), [17, 1, 0x19, 0])
+        XCTAssertEqual(Array(p.puts[0][13 ..< 21]), le(44, 108, 198, 58))
+        XCTAssertEqual(Array(p.puts[0][21 ..< 24]), [2, 0x68, 0x69])
+        XCTAssertEqual(Array(p.puts[1][13 ..< 21]), le(44, 135, 198, 31))
+        XCTAssertEqual(Array(p.puts[1][22 ..< 27]), Array("there".utf8))
+        XCTAssertTrue(first.uploads.isEmpty)
+        let moved = try XCTUnwrap(encode(scene, cache, [t(40, "hi\nthere", 9, 330)], inlineText: true))
+        let q = parse(moved.payload)
+        XCTAssertTrue(q.puts.isEmpty)
+        XCTAssertEqual(Array(q.ops[5 ..< 8]), [0x0F, 0x01, 10])
+        XCTAssertEqual(Array(q.ops[12 ..< 22]), le(44, 138, 198, 58, 0x19))
+        let changed = try XCTUnwrap(encode(scene, cache, [t(40, "ho\nthere", 9, 330)], inlineText: true))
+        XCTAssertEqual(parse(changed.payload).puts.count, 1)
+        let faded = try XCTUnwrap(encode(scene, cache, [t(40, "ho\nthere", 3, 330)], inlineText: true))
+        let r = parse(faded.payload)
+        XCTAssertEqual(r.ops.count, 44)
+        XCTAssertEqual(Array(r.ops[20 ..< 22]), le(0x13))
+    }
+
+    private var mono: G2CfwScene.MonoFace {
+        G2CfwScene.MonoFace(metrics: { _ in (6, 12) }) { _, _, w, h in Data(repeating: 0xFF, count: w * h) }
+    }
+
+    func testMonoTextBecomesCachedFontRunsThatTween() throws {
+        let (scene, cache) = fresh()
+        let grid = element("g", type: "text", x: 0, y: 0, w: 60, h: 24, text: "ab\ncd", font: "mono", fontSize: 12)
+        let encoded = try XCTUnwrap(scene.encode(frame([grid]), originX: 32, originY: 96, inlineText: true, mono: mono, cache: cache) { _, _, _ in nil })
+        let p = parse(encoded.payload)
+        XCTAssertEqual(p.puts.count, 2)
+        XCTAssertEqual(Array(p.puts[0][9 ..< 13]), [16, 1, 15, 0])
+        XCTAssertEqual(Array(p.puts[0][13 ..< 17]), le(34, 98))
+        let fontId = G2CfwTextureCache.hash31("font:12:6x12:ascii")
+        XCTAssertEqual(Array(p.puts[0][21 ..< 25]), u32(fontId))
+        XCTAssertEqual(Array(p.puts[0][17 ..< 21]), u32(G2CfwTextureCache.hash31("t:ascii:ab")))
+        // the font is one asset with all 95 glyphs, uploaded once, then the two strings
+        XCTAssertFalse(encoded.uploads.isEmpty)
+        let entries = encoded.uploads.flatMap { [UInt8]($0).dropFirst(5) }
+        XCTAssertEqual(entries[0], 0)
+        XCTAssertEqual(Array(entries[1 ..< 5]), u32(fontId))
+        XCTAssertEqual(entries[9], G2CfwTextureCache.kindFont)
+        let total = Int(entries[10]) | Int(entries[11]) << 8 | Int(entries[12]) << 16
+        XCTAssertEqual(total, 96 * 4 + 95 * (2 + 2), "table + 95 glyphs of 72 white pixels (one 2-byte RLE token each)")
+        let moved = try XCTUnwrap(scene.encode(frame([element("g", type: "text", x: 0, y: 20, w: 60, h: 24, text: "ab\ncd", font: "mono", fontSize: 12, transitionMs: 330)]), originX: 32, originY: 96, inlineText: true, mono: mono, cache: cache) { _, _, _ in nil })
+        let q = parse(moved.payload)
+        XCTAssertTrue(q.puts.isEmpty)
+        XCTAssertTrue(moved.uploads.isEmpty)
+        XCTAssertEqual(Array(q.ops[5 ..< 8]), [0x03, 0x01, 10], "x, y and the options byte (a fade-capable texture)")
+        XCTAssertEqual(Array(q.ops[12 ..< 18]), le(34, 118, 15))
+    }
+
+    func testHalfBlockGridUsesASeparateFontAndNonAsciiKeepsTiles() throws {
+        let (scene, cache) = fresh()
+        let blocks = element("b", type: "text", x: 0, y: 0, w: 60, h: 12, text: "▀▄█ ", font: "mono", fontSize: 12)
+        let encoded = try XCTUnwrap(scene.encode(frame([blocks]), originX: 32, originY: 96, inlineText: true, mono: mono, cache: cache) { _, _, _ in nil })
+        let p = parse(encoded.payload)
+        XCTAssertEqual(p.puts.count, 1)
+        XCTAssertEqual(Array(p.puts[0][21 ..< 25]), u32(G2CfwTextureCache.hash31("font:12:6x12:blocks")))
+        XCTAssertEqual(Array(p.puts[0][17 ..< 21]), u32(G2CfwTextureCache.hash31("t:blocks:▀▄█ ")))
+        let mixed = element("m", type: "text", x: 0, y: 0, w: 60, h: 12, text: "a▀", font: "mono", fontSize: 12)
+        let tiles = try XCTUnwrap(scene.encode(frame([mixed]), originX: 32, originY: 96, inlineText: true, mono: mono, cache: cache) { _, w, h in Data(repeating: 0xFF, count: w * h) })
+        XCTAssertEqual(parse(tiles.payload).puts[0][9], 14)
+    }
+
+    func testMovingBackToTheResidentDefinitionWithoutTransitionSnapsInsteadOfRedefining() throws {
+        let (scene, cache) = fresh()
+        let home = element("row", type: "rect", x: 300, y: 40, w: 200, h: 30, border: 1, hash: "r")
+        let away = element("row", type: "rect", x: 20, y: 80, w: 500, h: 30, border: 1, transitionMs: 300, hash: "r")
+        let first = try XCTUnwrap(encode(scene, cache, [home]))
+        XCTAssertEqual(first.puts, 1)
+        let moved = try XCTUnwrap(encode(scene, cache, [away]))
+        XCTAssertEqual(moved.tweens, 1, "a transition tweens the row away; its version stays")
+        // 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 with a zero-frame tween instead.
+        let back = try XCTUnwrap(encode(scene, cache, [home]))
+        XCTAssertEqual(back.puts, 0)
+        XCTAssertEqual(back.hits, 1)
+        XCTAssertTrue(back.changed)
+        let p = parse(back.payload)
+        XCTAssertEqual(p.refs.map(\.1), parse(first.payload).refs.map(\.1), "same version as the original definition")
+        XCTAssertEqual(p.ops.first, 5, "a TWEEN op")
+        XCTAssertEqual(p.ops[7], 0, "of zero frames")
+        // The next identical frame is a plain hit.
+        let again = try XCTUnwrap(encode(scene, cache, [home]))
+        XCTAssertFalse(again.changed)
+        // A genuinely new definition still redefines.
+        let restyled = element("row", type: "rect", x: 300, y: 40, w: 200, h: 30, border: 3, hash: "r")
+        XCTAssertEqual(try XCTUnwrap(encode(scene, cache, [restyled])).puts, 1)
+    }
+
+    func testDepthShiftsEachLensMirrorTheOppositeWayAndFlatEncodesIgnoreIt() throws {
+
+        let cache = G2CfwTextureCache()
+        let card = element("card", type: "rect", x: 100, y: 40, w: 200, h: 100, border: 2, hash: "c", depth: 8)
+
+        let flat = element("bg", type: "rect", x: 10, y: 10, w: 50, h: 50, border: 1, hash: "b")
+        let left = G2CfwScene(), right = G2CfwScene(), mono = G2CfwScene()
+        cache.reset(generation: 1)
+        left.reset(generation: 1); right.reset(generation: 1); mono.reset(generation: 1)
+        let l = parse(try XCTUnwrap(encode(left, cache, [flat, card], parallax: 1)).payload)
+        let r = parse(try XCTUnwrap(encode(right, cache, [flat, card], parallax: -1)).payload)
+        let m = parse(try XCTUnwrap(encode(mono, cache, [flat, card])).payload)
+        // A put is [1][id u32][version u32] + the record [type][flags][color][width][x i16][y i16]…
+        func x(_ put: [UInt8]) -> Int { Int(Int16(bitPattern: UInt16(put[9 + 4]) | UInt16(put[9 + 5]) << 8)) }
+        XCTAssertEqual(x(l.puts[0]), 32 + 10, "flat elements sit at the window origin on every lens")
+        XCTAssertEqual(x(r.puts[0]), 32 + 10)
+        XCTAssertEqual(x(l.puts[1]), 32 + 100 + 8, "the left lens draws a near element further right")
+        XCTAssertEqual(x(r.puts[1]), 32 + 100 - 8, "and the right lens further left")
+        XCTAssertEqual(x(m.puts[1]), 32 + 100, "a flat encode ignores depth")
+        XCTAssertEqual(l.puts[0], r.puts[0], "the flat element's definition is identical on both lenses")
+        XCTAssertNotEqual(l.puts[1], r.puts[1])
+        XCTAssertEqual(l.refs[1].0, r.refs[1].0, "same object id on both lenses, different versions")
+        XCTAssertNotEqual(l.refs[1].1, r.refs[1].1)
+
+        // Bringing the card to the frame's plane with a transition tweens x on each lens, in opposite directions.
+        let level = element("card", type: "rect", x: 100, y: 40, w: 200, h: 100, border: 2, transitionMs: 330, hash: "c")
+        let l2 = try XCTUnwrap(encode(left, cache, [flat, level], parallax: 1))
+        let r2 = try XCTUnwrap(encode(right, cache, [flat, level], parallax: -1))
+        XCTAssertEqual(l2.tweens, 1)
+        XCTAssertEqual(r2.tweens, 1)
+        XCTAssertNotEqual(l2.payload, r2.payload)
+        XCTAssertEqual(parse(l2.payload).puts.count, 0)
+    }
+
+    func testAdoptCopiesTheMirrorSoTheSecondLensStartsFromSharedResidency() throws {
+        let cache = G2CfwTextureCache()
+        let flat = element("bg", type: "rect", x: 10, y: 10, w: 50, h: 50, border: 1, hash: "b")
+        let left = G2CfwScene(), right = G2CfwScene()
+        cache.reset(generation: 3)
+        left.reset(generation: 3)
+        _ = try XCTUnwrap(encode(left, cache, [flat]))
+
+        right.adopt(left)
+        XCTAssertEqual(right.generation, 3)
+        XCTAssertEqual(right.active, left.active)
+        let again = try XCTUnwrap(encode(right, cache, [flat], parallax: -1))
+        XCTAssertEqual(again.puts, 0, "what the left lens holds, the right holds too")
+        XCTAssertEqual(again.hits, 1)
+        XCTAssertFalse(again.changed)
+    }
+
+    func testOnlyNonAnimatedImageFramesPreferRaster() {
+
+        let image = element("i", type: "image", w: 10, h: 10)
+        XCTAssertTrue(G2CfwScene.prefersRaster(frame([image])))
+        XCTAssertFalse(G2CfwScene.prefersRaster(frame([image, element("c", type: "circle", w: 5, h: 5)])))
+        XCTAssertFalse(G2CfwScene.prefersRaster(frame([element("i", type: "image", w: 10, h: 10, transitionMs: 100)])))
+        XCTAssertFalse(G2CfwScene.prefersRaster(frame([])))
+    }
+}