@mentra/bluetooth-sdk 3.3.0-dev.316 → 3.3.0-dev.320

package/android/src/test/java/com/mentra/bluetoothsdk/sgcs/NimoCanvasCodecTest.kt

@@ -0,0 +1,220 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import org.junit.Assert.*
+import org.junit.Test
+
+class NimoCanvasCodecTest {
+  @Test fun imageSourcesAcceptRawAndMatchingDataUris() {
+    // ImageIO/BitmapFactory validate the complete raster; this boundary validates file kind and size.
+    val png = byteArrayOf(0x89.toByte(), 0x50, 0x4E, 0x47, 13, 10, 26, 10) + ByteArray(24)
+    val bmp = byteArrayOf(0x42, 0x4D) + ByteArray(56)
+    val jpeg = byteArrayOf(0xFF.toByte(), 0xD8.toByte(), 0xFF.toByte()) + ByteArray(24)
+    for ((mime, bytes) in listOf("png" to png, "bmp" to bmp, "jpeg" to jpeg)) {
+      val raw = java.util.Base64.getEncoder().encodeToString(bytes)
+      assertArrayEquals(bytes, NimoCanvasCodec.imageBytes(raw))
+      assertArrayEquals(bytes, NimoCanvasCodec.imageBytes("data:image/$mime;base64,$raw"))
+      val wrongMime = if (mime == "png") "bmp" else "png"
+      assertThrows(IllegalArgumentException::class.java) {
+        NimoCanvasCodec.imageBytes("data:image/$wrongMime;base64,$raw")
+      }
+    }
+  }
+
+  @Test fun unsupportedAndOversizedImageSourcesFailBeforeRasterDecoding() {
+    val encoder = java.util.Base64.getEncoder()
+    assertThrows(IllegalStateException::class.java) { NimoCanvasCodec.imageBytes("data:image/gif;base64,AAAA") }
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.imageBytes(encoder.encodeToString(ByteArray(54))) }
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.imageBytes("a".repeat(2_800_001)) }
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.imageBytes(encoder.encodeToString(ByteArray(2_000_001))) }
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.imageBytes("not valid base64!") }
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.imageBytes("Qk0") }
+  }
+
+  @Test fun guideGoldenPacket() {
+    val frame = NimoCanvasCodec.replace(listOf(
+      NimoCanvasCodec.rectangle(20, 20, 120, 50, 2, 8),
+      NimoCanvasCodec.label("Hello Glass", 160, 30, 300, 40, font = 2)
+    ))
+    val actual = NimoCanvasCodec.frames(4, frame, 512).single()
+    val expected = "BF003600F72D000007043200FD000000020001010C0014001400780032000208FF00031900A0001E002C012800000002FF0B0048656C6C6F20476C617373"
+    assertEquals(expected, actual.joinToString("") { "%02X".format(it.toInt() and 255) })
+  }
+
+  @Test fun fourTonePolarityAndOddPadding() {
+    assertArrayEquals(byteArrayOf(0xE4.toByte(), 0x3F),
+      NimoCanvasCodec.pack2(byteArrayOf(0, 85, 170.toByte(), 255.toByte(), 255.toByte())))
+  }
+
+  @Test fun launchAndExitGoldenPackets() {
+    fun hex(bytes: ByteArray) = bytes.joinToString("") { "%02X".format(it.toInt() and 255) }
+    assertEquals("BF000600F5E4000007010200FD00", hex(NimoCanvasCodec.frames(1, writeCapacity = 512).single()))
+    assertEquals("BF00050086E4000007030100FD", hex(NimoCanvasCodec.frames(3, writeCapacity = 512).single()))
+  }
+
+  @Test fun primitivesValidateGeometryAndUseCompactCircle() {
+    assertEquals(10, NimoCanvasCodec.line(0, 0, 499, 219).payload.size)
+    assertEquals(12, NimoCanvasCodec.rectangle(0, 0, 500, 220).payload.size)
+    assertEquals(9, NimoCanvasCodec.circle(10, 10, 10).payload.size)
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.line(0, 0, 500, 219) }
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.rectangle(Int.MAX_VALUE, 0, 10, 1) }
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.rectangle(0, 0, 501, 220) }
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.circle(0, 10, 10) }
+  }
+
+  @Test fun labelUtf8LengthAndErrors() {
+    val label = NimoCanvasCodec.label("😀é", 0, 0, 100, 20)
+    assertEquals(6, label.textBytes)
+    assertEquals(6, label.payload[12].toInt())
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.label("a\u0000b", 0, 0, 100, 20) }
+    assertThrows(java.nio.charset.CharacterCodingException::class.java) { NimoCanvasCodec.label("\uD800", 0, 0, 100, 20) }
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.label("é".repeat(1025), 0, 0, 100, 20) }
+    assertEquals(2048, NimoCanvasCodec.label("é".repeat(1024), 0, 0, 100, 20).textBytes)
+  }
+
+  @Test fun totalBudgetsAndClear() {
+    assertArrayEquals(byteArrayOf(0, 0, 1), NimoCanvasCodec.replace(emptyList()))
+    val line = NimoCanvasCodec.line(0, 0, 1, 1)
+    NimoCanvasCodec.replace(List(64) { line })
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.replace(List(65) { line }) }
+    val text = NimoCanvasCodec.label("a".repeat(2048), 0, 0, 500, 220)
+    NimoCanvasCodec.replace(List(4) { text })
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.replace(List(5) { text }) }
+    val image = NimoCanvasCodec.bitmap(0, 0, 500, 220, ByteArray(110000))
+    NimoCanvasCodec.replace(listOf(image))
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.replace(listOf(image, image)) }
+    assertThrows(IllegalArgumentException::class.java) {
+      NimoCanvasCodec.replace(listOf(NimoCanvasCodec.Object(4, ByteArray(12278))))
+    }
+  }
+
+  @Test fun hostFrameReservationBoundsNativeEncoding() {
+    val random = java.util.Random(42)
+    for (size in listOf(1, 5, 80, 160, 200)) {
+      val gray = ByteArray(size * size).also { random.nextBytes(it) }
+      val image = NimoCanvasCodec.bitmap(0, 0, size, size, gray)
+      val packed = (gray.size + 3) / 4
+      val reserved = 32 + packed + (packed + 126) / 127
+      assertTrue(3 + image.payload.size <= reserved)
+    }
+    // These are the retained prefixes of the host's over-budget regression scenes.
+    val rows = NimoCanvasCodec.textRows(List(11) { "row" }.joinToString("\n"), 0, 0, 500, 220)
+    assertTrue(NimoCanvasCodec.replace(List(5) { rows }.flatten()).size <= 12280)
+    val images = listOf(200, 80).map { size ->
+      NimoCanvasCodec.bitmap(0, 0, size, size, ByteArray(size * size).also { random.nextBytes(it) })
+    }
+    assertTrue(NimoCanvasCodec.replace(images).size <= 12280)
+  }
+
+  @Test fun explicitNewlinesRetainRowsWithoutRewrapping() {
+    val rows = NimoCanvasCodec.textRows("first\n\nthird", 12, 15, 400, 100)
+    assertEquals(2, rows.size)
+    assertEquals(15, rows[0].payload[2].toInt())
+    assertEquals(55, rows[1].payload[2].toInt())
+    assertEquals(20, rows[1].payload[6].toInt())
+    val single = NimoCanvasCodec.textRows("single", 12, 15, 400, 100).single()
+    assertEquals(20, single.payload[6].toInt())
+  }
+
+  @Test fun rleBoundaryAndLiteralRoundtrip() {
+    fun decode(data: ByteArray): ByteArray {
+      val out = java.io.ByteArrayOutputStream(); var i = 0
+      while (i < data.size) {
+        val tag = data[i++].toInt() and 255
+        val count = tag and 127
+        assertTrue(count > 0)
+        if (tag and 128 != 0) { out.write(data, i, count); i += count }
+        else { repeat(count) { out.write(data[i].toInt() and 255) }; i++ }
+      }
+      return out.toByteArray()
+    }
+    for (size in listOf(1, 2, 3, 126, 127, 128, 254, 27500)) {
+      for (input in listOf(ByteArray(size) { 33 }, ByteArray(size) { (it % 251).toByte() })) {
+        assertArrayEquals(input, decode(NimoCanvasCodec.rle(input)))
+      }
+    }
+    assertArrayEquals(byteArrayOf(3, 1, 0x82.toByte(), 2, 3), NimoCanvasCodec.rle(byteArrayOf(1, 1, 1, 2, 3)))
+  }
+
+  @Test fun bitmapIsCompleteCompressed2BppAndUsesExactOddSize() {
+    val bitmap = NimoCanvasCodec.bitmap(0, 0, 5, 1, byteArrayOf(0, 85, 170.toByte(), 255.toByte(), 255.toByte()))
+    assertEquals(1, bitmap.payload[10].toInt()) // total_chunks
+    assertEquals(2, bitmap.payload[19].toInt()) // image bpp
+    assertEquals(3, bitmap.payload[20].toInt()) // RLE is smallest here
+    assertEquals(2, bitmap.payload[21].toInt()) // original_size ceil(5/4)
+    assertArrayEquals(byteArrayOf(0x82.toByte(), 0xE4.toByte(), 0x3F), bitmap.payload.copyOfRange(29, bitmap.payload.size))
+  }
+
+  @Test fun fragmentationAtNegotiatedCapacityReassemblesWholeAppStream() {
+    val content = NimoCanvasCodec.replace(listOf(NimoCanvasCodec.label("X".repeat(2048), 0, 0, 500, 220)))
+    val baseline = NimoCanvasCodec.frames(4, content, 512).flatMap { it.drop(8) }.toByteArray()
+    for (capacity in listOf(20, 64, 185, 244, 512)) {
+      val frames = NimoCanvasCodec.frames(4, content, capacity)
+      frames.forEachIndexed { index, packet ->
+        assertTrue(packet.size <= capacity)
+        assertEquals(0, packet[1].toInt())
+        val expectedIndex = if (index == frames.lastIndex) 0 else index + 1
+        assertEquals(expectedIndex, (packet[6].toInt() and 255) or ((packet[7].toInt() and 255) shl 8))
+        assertEquals(NimoCanvasCodec.crc16(packet.copyOfRange(8, packet.size)),
+          (packet[4].toInt() and 255) or ((packet[5].toInt() and 255) shl 8))
+      }
+      assertArrayEquals(baseline, frames.flatMap { it.drop(8) }.toByteArray())
+    }
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.frames(4, content, 19) }
+    assertThrows(IllegalArgumentException::class.java) { NimoCanvasCodec.frames(4, ByteArray(12281), 512) }
+  }
+
+  @Test fun strictResponseParserAcceptsStatusOnlyErrors() {
+    fun packet(hex: String) = hex.chunked(2).map { it.toInt(16).toByte() }.toByteArray()
+    val good = packet("BF000900D87900000704050000FD000000")
+    assertArrayEquals(byteArrayOf(0, 0xFD.toByte(), 0, 0, 0), NimoCanvasCodec.response(good)!!.second)
+    assertNull(NimoCanvasCodec.response(good + 0))
+    assertNull(NimoCanvasCodec.response(good.copyOf().also { it[10] = 4 }))
+    assertNull(NimoCanvasCodec.response(good.copyOf().also { it[1] = 2 }))
+    val body = byteArrayOf(7, 4, 1, 0, 7)
+    val crc = NimoCanvasCodec.crc16(body)
+    val statusOnly = byteArrayOf(0xBF.toByte(), 0, 5, 0, crc.toByte(), (crc shr 8).toByte(), 0, 0) + body
+    assertArrayEquals(byteArrayOf(7), NimoCanvasCodec.response(statusOnly)!!.second)
+  }
+
+  @Test fun sceneCompilerKeepsGeometryOrderAndBorderBeforeText() {
+    val text = NimoCanvasCodec.Element("text", 10, 20, 100, 40, "hello", border = 2, radius = 3)
+    val rectangle = NimoCanvasCodec.Element("rect", 100, 100, 50, 20)
+    val actual = NimoCanvasCodec.scene(listOf(text, rectangle)) { _, _, _ -> error("Not an image") }
+    val expected = NimoCanvasCodec.replace(listOf(
+      NimoCanvasCodec.rectangle(10, 20, 100, 40, 2, 3),
+      NimoCanvasCodec.label("hello", 10, 20, 100, 20),
+      NimoCanvasCodec.rectangle(100, 100, 50, 20, 1, 0)
+    ))
+    assertArrayEquals(expected, actual)
+    assertFalse(actual.contentEquals(NimoCanvasCodec.scene(listOf(rectangle, text)) { _, _, _ -> error("Not an image") }))
+    assertFalse(actual.contentEquals(NimoCanvasCodec.scene(listOf(text.copy(x = 11), rectangle)) { _, _, _ -> error("Not an image") }))
+  }
+
+  @Test fun scenePreflightsInvalidImageBudgetBeforeDecodingAnyPng() {
+    val image = NimoCanvasCodec.Element("image", 0, 0, 500, 220, data = "unused")
+    var decoded = 0
+    assertThrows(IllegalArgumentException::class.java) {
+      NimoCanvasCodec.scene(listOf(image, image)) { _, _, _ -> decoded++; ByteArray(110000) }
+    }
+    assertEquals(0, decoded)
+    assertThrows(IllegalArgumentException::class.java) {
+      NimoCanvasCodec.scene(listOf(image.copy(type = "html"))) { _, _, _ -> decoded++; ByteArray(110000) }
+    }
+    assertEquals(0, decoded)
+  }
+
+  @Test fun zlibCompressesDenseRepeatingImagesAndInflatesToPackedPixels() {
+    val gray = ByteArray(32768) { (((it / 17) xor (it / 43)) % 4 * 85).toByte() }
+    val bitmap = NimoCanvasCodec.bitmap(0, 0, 256, 128, gray)
+    assertEquals(7, bitmap.payload[20].toInt())
+    val inflater = java.util.zip.Inflater()
+    try {
+      inflater.setInput(bitmap.payload.copyOfRange(29, bitmap.payload.size))
+      val output = ByteArray((gray.size + 3) / 4)
+      assertEquals(output.size, inflater.inflate(output))
+      assertTrue(inflater.finished())
+      assertArrayEquals(NimoCanvasCodec.pack2(gray), output)
+    } finally { inflater.end() }
+    NimoCanvasCodec.replace(listOf(bitmap))
+  }
+}

package/android/src/test/java/com/mentra/bluetoothsdk/sgcs/NimoCanvasCoordinatorTest.kt

@@ -0,0 +1,308 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import org.junit.Assert.*
+import org.junit.Test
+
+class NimoCanvasCoordinatorTest {
+    private class Clock : NimoScheduler {
+        private data class Job(val time: Long, val task: () -> Unit, var canceled: Boolean = false)
+        private var now = 0L
+        private val jobs = mutableListOf<Job>()
+        override fun post(delayMs: Long, task: () -> Unit): () -> Unit {
+            val job = Job(now + delayMs, task)
+            jobs += job
+            return { job.canceled = true }
+        }
+        fun advance(ms: Long) {
+            val end = now + ms
+            while (true) {
+                val job = jobs.filter { it.time <= end }.minByOrNull { it.time } ?: break
+                jobs.remove(job); now = job.time
+                if (!job.canceled) job.task()
+            }
+            now = end
+        }
+    }
+
+    private class Fixture {
+        val clock = Clock()
+        var connection: Any = Any()
+        val characteristic = Any()
+        val writes = mutableListOf<ByteArray>()
+        val failures = mutableListOf<String>()
+        val rejections = mutableListOf<Int>()
+        var holdPreemptions = 0
+        var rejectWrites = false
+        val queue = NimoGattQueue<Any>(clock, { _, bytes -> writes += bytes; !rejectWrites }, { failures += it })
+        val canvas = NimoCanvasCoordinator(clock, { 20 },
+            { frames, started, completed -> queue.enqueue(connection, characteristic, frames, started, completed) },
+            { queue.reset(); failures += it }, { rejections += it }, { holdPreemptions++ })
+        init { queue.connected(connection) }
+        fun written(success: Boolean = true) {
+            queue.written(connection, characteristic, success)
+            clock.advance(5)
+        }
+        fun ack(key: Int, status: Int = 0) = canvas.response(key, if (status != 0) byteArrayOf(status.toByte())
+            else if (key == 4) byteArrayOf(0, 0xFD.toByte(), 0, 0, 0) else byteArrayOf(0, 0xFD.toByte()))
+        fun launch(frame: ByteArray = byteArrayOf(0, 0, 1)) {
+            canvas.offer(frame, "one:1"); canvas.readiness(true)
+            written(); ack(1)
+        }
+        fun finishUpdate(frame: ByteArray) { repeat(NimoCanvasCodec.frames(4, frame, 20).size) { written() }; ack(4) }
+    }
+
+    @Test fun bothNotificationDescriptorsGateCharacteristicWrites() {
+        val f = Fixture()
+        val rx = Any(); val mic = Any()
+        val subscribed = mutableListOf<String>()
+        f.queue.subscribe(f.connection, rx, { subscribed += "rx"; true }) {
+            f.queue.subscribe(f.connection, mic, { subscribed += "mic"; true }) {}
+        }
+        f.canvas.offer(byteArrayOf(0, 0, 1), "one"); f.canvas.readiness(true)
+        assertTrue(f.writes.isEmpty())
+        f.queue.descriptorWritten(f.connection, Any(), true)
+        assertTrue(f.writes.isEmpty())
+        f.queue.descriptorWritten(f.connection, rx, true)
+        assertEquals(listOf("rx", "mic"), subscribed)
+        assertTrue(f.writes.isEmpty())
+        f.queue.descriptorWritten(f.connection, mic, true)
+        assertEquals(1, f.writes.size)
+    }
+
+    @Test fun entireFragmentChainRemainsContiguousAmongOtherCommands() {
+        val f = Fixture()
+        val frame = ByteArray(85) { it.toByte() }
+        f.launch(frame)
+        val update = NimoCanvasCodec.frames(4, frame, 20)
+        val other = byteArrayOf(42)
+        f.queue.enqueue(f.connection, f.characteristic, listOf(other))
+        repeat(update.size) { f.written() }
+        assertEquals(update.size + 2, f.writes.size)
+        update.forEachIndexed { i, bytes -> assertArrayEquals(bytes, f.writes[i + 1]) }
+        assertArrayEquals(other, f.writes.last())
+    }
+
+    @Test fun earlyAndDuplicateAcksCannotReleaseAnUnfinishedChain() {
+        val f = Fixture()
+        val a = ByteArray(60) { it.toByte() }; val b = byteArrayOf(0, 0, 1)
+        f.launch(a)
+        f.canvas.offer(b, "one:1")
+        f.ack(4) // Before the final fragment has started: stale/uncorrelated.
+        val fragments = NimoCanvasCodec.frames(4, a, 20).size
+        repeat(fragments - 1) { f.written() }
+        val before = f.writes.size
+        f.ack(4) // Final fragment started, but its callback has not completed.
+        f.ack(4, 6) // Duplicate must not replace the first valid early ACK.
+        assertEquals(before, f.writes.size)
+        f.queue.written(f.connection, f.characteristic, true)
+        f.queue.written(f.connection, f.characteristic, true) // Duplicate callback within pacing window.
+        assertEquals(before, f.writes.size)
+        f.clock.advance(5)
+        assertEquals(before + 1, f.writes.size)
+        assertTrue(f.rejections.isEmpty())
+        f.finishUpdate(b)
+        f.ack(4) // Late duplicate with no business command in flight.
+        assertTrue(f.failures.isEmpty())
+    }
+
+    @Test fun finalCallbackFailureAndMissingCallbackNeverReleaseNextFragment() {
+        for (missing in listOf(false, true)) {
+            val f = Fixture(); f.launch(ByteArray(60))
+            val before = f.writes.size
+            if (missing) f.clock.advance(3_000) else f.written(false)
+            assertEquals(before, f.writes.size)
+            assertEquals(1, f.failures.size)
+            f.queue.written(f.connection, f.characteristic, true)
+            f.clock.advance(5)
+            assertEquals(before, f.writes.size)
+        }
+    }
+
+    @Test fun writeStartRetriesAreBoundedAndDescriptorFailuresReset() {
+        val f = Fixture(); f.rejectWrites = true
+        f.canvas.offer(byteArrayOf(0, 0, 1), "one"); f.canvas.readiness(true)
+        f.clock.advance(200)
+        assertEquals(3, f.writes.size)
+        assertEquals(1, f.failures.size)
+        for (failure in listOf("start", "callback", "missing")) {
+            val link = Fixture(); val descriptor = Any()
+            link.queue.subscribe(link.connection, descriptor, { failure != "start" }) { fail("Must not become ready") }
+            if (failure == "callback") link.queue.descriptorWritten(link.connection, descriptor, false)
+            if (failure == "missing") link.clock.advance(5_000)
+            assertEquals(1, link.failures.size)
+        }
+    }
+
+    @Test fun ackDeadlineResetsAndReplacedConnectionCallbacksAreIgnored() {
+        val f = Fixture(); f.launch()
+        f.written() // Update is transported, but no business ACK.
+        f.clock.advance(45_000)
+        assertEquals(1, f.failures.size)
+        f.ack(4)
+        val old = f.connection
+        f.connection = Any(); f.queue.connected(f.connection)
+        f.canvas.readiness(true)
+        val before = f.writes.size
+        f.queue.written(old, f.characteristic, true)
+        f.clock.advance(5)
+        assertEquals(before, f.writes.size)
+        f.written(); f.ack(1); f.finishUpdate(byteArrayOf(0, 0, 1))
+        assertEquals(1, f.failures.size)
+    }
+
+    @Test fun rejectedUpdateImmediatelyDrainsDifferentQueuedScene() {
+        val f = Fixture(); f.launch()
+        f.written()
+        val b = byteArrayOf(1, 0, 1)
+        f.canvas.offer(b, "one:1")
+        val before = f.writes.size
+        f.ack(4, 6)
+        assertEquals(listOf(6), f.rejections)
+        assertEquals(before + 1, f.writes.size)
+        assertArrayEquals(NimoCanvasCodec.frames(4, b, 20).first(), f.writes.last())
+    }
+
+    @Test fun confirmedReadinessRelaunchesAfterNotReadyAndPreservesLatestScene() {
+        val f = Fixture(); f.launch(); f.written()
+        f.ack(4, 7)
+        val b = byteArrayOf(1, 0, 1)
+        f.canvas.offer(b, "one:1")
+        val before = f.writes.size
+        f.canvas.readiness(true)
+        assertEquals(before, f.writes.size)
+        f.canvas.confirmedReadiness(true)
+        assertEquals(before + 1, f.writes.size)
+        assertArrayEquals(NimoCanvasCodec.frames(1, writeCapacity = 20).single(), f.writes.last())
+        f.written(); f.ack(1)
+        assertArrayEquals(NimoCanvasCodec.frames(4, b, 20).single(), f.writes.last())
+        f.finishUpdate(b)
+        assertEquals(listOf(7), f.rejections)
+        assertTrue(f.failures.isEmpty())
+    }
+
+    @Test fun newerSceneSurvivesExitReportAndWaitsForExitAck() {
+        val f = Fixture(); f.launch(); f.finishUpdate(byteArrayOf(0, 0, 1))
+        f.canvas.exit()
+        f.canvas.offer(byteArrayOf(1, 0, 1), "two:1")
+        assertFalse(f.canvas.nativeApp(0xFD, false))
+        f.written()
+        val before = f.writes.size
+        f.ack(3)
+        assertEquals(before + 1, f.writes.size)
+        assertArrayEquals(NimoCanvasCodec.frames(1, writeCapacity = 20).single(), f.writes.last())
+    }
+
+    @Test fun actualNativeTakeoverDuringExitInvalidatesEncodingAndDoesNotRelaunch() {
+        val f = Fixture(); f.launch(); f.finishUpdate(byteArrayOf(0, 0, 1))
+        f.canvas.exit()
+        f.canvas.offer(byteArrayOf(1, 0, 1), "two:1")
+        assertTrue(f.canvas.nativeApp(0, true))
+        f.written()
+        val before = f.writes.size
+        f.ack(3)
+        assertEquals(before, f.writes.size)
+        assertTrue(f.failures.isEmpty())
+    }
+
+    @Test fun diagnosticHoldWaitsForCurrentBusinessAckAndThenResumesLatestScene() {
+        val f = Fixture()
+        val initial = byteArrayOf(0, 0, 1)
+        val latest = byteArrayOf(2, 0, 1)
+        f.launch(initial)
+        var ready = 0
+        f.canvas.hold { ready++ }
+        f.canvas.offer(byteArrayOf(1, 0, 1), "one:1")
+        f.canvas.offer(latest, "one:1")
+
+        assertEquals(0, ready)
+        f.finishUpdate(initial)
+        assertEquals(1, ready)
+        val beforeRelease = f.writes.size
+
+        f.canvas.releaseHold()
+
+        assertEquals(beforeRelease + 1, f.writes.size)
+        assertArrayEquals(NimoCanvasCodec.frames(4, latest, 20).first(), f.writes.last())
+    }
+
+    @Test fun scopeTakeoverPreemptsHoldWithoutFlushingHeldScene() {
+        val f = Fixture()
+        val initial = byteArrayOf(0, 0, 1)
+        val held = byteArrayOf(1, 0, 1)
+        val takeover = byteArrayOf(2, 0, 1)
+        f.launch(initial); f.finishUpdate(initial)
+        var ready = 0
+        f.canvas.hold { ready++ }
+        f.canvas.offer(held, "one:1")
+        val beforeTakeover = f.writes.size
+
+        f.canvas.offer(takeover, "two:1")
+
+        assertEquals(1, ready)
+        assertEquals(1, f.holdPreemptions)
+        assertEquals(beforeTakeover + 1, f.writes.size)
+        assertArrayEquals(NimoCanvasCodec.frames(4, takeover, 20).first(), f.writes.last())
+    }
+
+    @Test fun firstScopePreemptsHoldAcquiredBeforeAnyCanvasScene() {
+        val f = Fixture()
+        var ready = 0
+        f.canvas.readiness(true)
+        f.canvas.hold { ready++ }
+        assertEquals(1, ready)
+
+        f.canvas.offer(byteArrayOf(0, 0, 1), "first:1")
+
+        assertEquals(1, f.holdPreemptions)
+        assertEquals(1, f.writes.size)
+        assertArrayEquals(NimoCanvasCodec.frames(1, writeCapacity = 20).single(), f.writes.single())
+    }
+
+    @Test fun reentrantCompletionCannotReleaseNewConnectionWrite() {
+        val f = Fixture(); val old = f.connection
+        f.queue.enqueue(old, f.characteristic, listOf(byteArrayOf(1)), completed = {
+            f.queue.reset()
+            f.connection = Any(); f.queue.connected(f.connection)
+            f.queue.enqueue(f.connection, f.characteristic, listOf(byteArrayOf(2), byteArrayOf(3)))
+        })
+        f.written()
+        assertEquals(2, f.writes.size)
+        f.queue.written(old, f.characteristic, true)
+        f.clock.advance(5)
+        assertEquals(2, f.writes.size)
+        f.written()
+        assertEquals(3, f.writes.size)
+        assertArrayEquals(byteArrayOf(3), f.writes.last())
+    }
+
+    @Test fun staleEncodeAfterNewSceneExitDisconnectOrDisposalCannotDeliver() {
+        for (invalidate in listOf("new", "exit", "disconnect", "dispose")) {
+            val main = Clock(); val worker = Clock()
+            val delivered = mutableListOf<Int>(); var releases = 0; var stopped = 0
+            val encoder = NimoCanvasEncoder(main, worker, { stopped++ }, { throw it })
+            encoder.submit({ byteArrayOf(1) }, { releases++ }) { delivered += it[0].toInt() }
+            worker.advance(0) // Completed encoding is now pending on Main.
+            when (invalidate) {
+                "new" -> encoder.submit({ byteArrayOf(2) }, { releases++ }) { delivered += it[0].toInt() }
+                "dispose" -> encoder.close()
+                else -> encoder.invalidate()
+            }
+            worker.advance(0); main.advance(0)
+            assertEquals(if (invalidate == "new") listOf(2) else emptyList(), delivered)
+            encoder.close(); encoder.close()
+            assertEquals(1, stopped)
+            assertEquals(if (invalidate == "new") 2 else 1, releases)
+        }
+    }
+
+    @Test fun canceledAndDisposedBitmapSourcesAreReleasedExactlyOnce() {
+        val main = Clock(); val worker = Clock(); var encoded = 0; var released = 0
+        val encoder = NimoCanvasEncoder(main, worker, {}, { throw it })
+        encoder.submit({ encoded++; byteArrayOf(1) }, { released++ }) { fail("Canceled work delivered") }
+        encoder.invalidate(); worker.advance(0); main.advance(0)
+        assertEquals(0, encoded); assertEquals(1, released)
+        encoder.close()
+        assertFalse(encoder.submit({ encoded++; byteArrayOf(2) }, { released++ }) {})
+        assertEquals(0, encoded); assertEquals(2, released)
+    }
+}