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

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

@@ -35,46 +35,49 @@ class G2CfwTextureCacheTest {
         )
     }
 
-    // ── Cache model ─────────────────────────────────────────────────────────
+    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)
+
+    // ── Asset mirror ────────────────────────────────────────────────────────
 
     @Test
-    fun allocationsSkipTheZeroGuardAndPatchTheFontTable() {
+    fun fontsUploadWholeAsOneAssetWithRelativeGlyphOffsets() {
         val cache = G2CfwTextureCache()
         cache.reset(1)
-        val font = cache.font(fontSize = 12, cellWidth = 4, lineHeight = 2)
+        val raster = ByteArray(8) { 0xFF.toByte() } // 4×2 white cell
+        var rasterized = 0
+        val font = cache.font(fontSize = 12, cellWidth = 4, lineHeight = 2, codes = listOf(65, 66)) { code ->
+            rasterized += 1
+            if (code == 65) raster else null
+        }
         assertNotNull(font)
         font!!
-        // Bytes 0..1 stay zero (invalid-image guard); the table lands at 2.
-        assertEquals(2, font.tableOffset)
-
-        val raster = ByteArray(8) { 0xFF.toByte() } // 4×2 white cell
-        assertTrue(cache.ensureGlyph(font, 'A'.code) { raster })
-        // Second ensure is a no-op (no duplicate uploads).
-        assertTrue(cache.ensureGlyph(font, 'A'.code) { raster })
+        assertEquals(2, rasterized)
+        assertEquals(setOf(65), font.glyphs)
+        assertEquals(G2CfwTextureCache.hash31("font:12:4x2:ascii"), font.id)
+        assertTrue(cache.font(12, 4, 2, codes = listOf(65, 66)) { rasterized += 1; null } === font)
+        assertEquals(2, rasterized)
 
         val payloads = cache.takeUploadPayloads()
         assertEquals(1, payloads.size)
-        // [12] + glyph entry: image right after the 192-byte table (offset
-        // 194), [offset16][len16][w=4][h=2][RLE 8 white pixels = 0x8F] —
-        // + table-patch entry for slot ('A' - 32) pointing at that offset.
-        val glyphOffset = 2 + 96 * 2 // 194
-        val patchOffset = 2 + ('A'.code - 32) * 2
-        assertArrayEquals(
-            byteArrayOf(
-                12,
-                (glyphOffset and 0xFF).toByte(), (glyphOffset ushr 8).toByte(), 3, 0, 4, 2, 0x8F.toByte(),
-                (patchOffset and 0xFF).toByte(), (patchOffset ushr 8).toByte(), 2, 0,
-                (glyphOffset and 0xFF).toByte(), (glyphOffset ushr 8).toByte(),
-            ),
-            payloads[0],
-        )
-
+        val p = payloads[0].map { it.toInt() and 0xFF }
+        assertEquals(listOf(37, 0, 0, 0, 0), p.subList(0, 5))
+        assertEquals(0, p[5])
+        assertEquals(u32(font.id), p.subList(6, 10))
+        assertEquals(G2CfwTextureCache.KIND_FONT, p[14])
+        val total = 96 * 4 + 2 + 1
+        assertEquals(u32(total), p.subList(15, 19))
+        assertEquals(u32(0), p.subList(19, 23))
+        assertEquals(listOf(total and 0xFF, total ushr 8), p.subList(23, 25))
+        val table = p.subList(25, 25 + 96 * 4)
+        assertEquals(u32(96 * 4), table.subList((65 - 32) * 4, (65 - 32) * 4 + 4))
+        assertEquals(listOf(0, 0, 0, 0), table.subList((66 - 32) * 4, (66 - 32) * 4 + 4))
+        assertEquals(listOf(4, 2, 0x8F), p.subList(25 + 96 * 4, 25 + total))
         assertTrue(cache.takeUploadPayloads().isEmpty())
+        cache.forget(listOf(font.id))
+        cache.font(12, 4, 2, codes = listOf(65)) { raster }
+        assertEquals(1, cache.takeUploadPayloads().size)
         cache.reset(2)
-        // After a reset the same glyph re-uploads.
-        val font2 = cache.font(fontSize = 12, cellWidth = 4, lineHeight = 2)
-        assertNotNull(font2)
-        assertTrue(cache.ensureGlyph(font2!!, 'A'.code) { raster })
+        cache.font(12, 4, 2, codes = listOf(65)) { raster }
         assertEquals(1, cache.takeUploadPayloads().size)
     }
 
@@ -85,37 +88,91 @@ class G2CfwTextureCacheTest {
         assertFalse(cache.noteImageSighting("icon@10x10"))
         assertTrue(cache.noteImageSighting("icon@10x10"))
         val gray = ByteArray(100) { 0x80.toByte() }
-        val offset = cache.ensureImage("icon@10x10", gray, width = 10, height = 10)
-        assertNotNull(offset)
-        assertEquals(offset, cache.ensureImage("icon@10x10", gray, width = 10, height = 10))
+        val id = cache.ensureImage("icon@10x10", gray, width = 10, height = 10)
+        assertEquals(G2CfwTextureCache.hash31("icon@10x10"), id)
+        assertEquals(id, cache.ensureImage("icon@10x10", gray, width = 10, height = 10))
         assertNull(cache.ensureImage("big", ByteArray(300 * 10), width = 300, height = 10))
+        assertEquals(1, cache.takeUploadPayloads().size)
+        assertTrue(cache.holds(id!!))
+    }
+
+    @Test
+    fun stringsAreBoundedAndLargeAssetsAreChunked() {
+        val cache = G2CfwTextureCache()
+        cache.reset(1)
+        assertNull(cache.ensureBytes("empty", ByteArray(0)))
+        assertNull(cache.ensureBytes("nul", byteArrayOf(65, 0)))
+        assertNull(cache.ensureBytes("long", ByteArray(129) { 65 }))
+        assertNotNull(cache.ensureBytes("ok", ByteArray(128) { 65 }))
+        val entries = G2CfwTextureCache.putAssetEntries(7, 9, 0, ByteArray(20000) { 1 })
+        assertEquals(3, entries.size)
+        var offset = 0
+        for (entry in entries) {
+            val e = entry.map { it.toInt() and 0xFF }
+            assertEquals(u32(20000), e.subList(10, 14))
+            assertEquals(u32(offset), e.subList(14, 18))
+            val len = e[18] or (e[19] shl 8)
+            assertEquals(20 + len, e.size)
+            offset += len
+        }
+        assertEquals(20000, offset)
+    }
+
+    @Test
+    fun uploadPayloadsNameTheAssetsTheyPut() {
+        val cache = G2CfwTextureCache()
+        cache.reset(1)
+        val noise = ByteArray(255 * 255) { (it * 37).toByte() }
+        val a = cache.ensureBytes("a", byteArrayOf(65, 66))!!
+        val big = cache.ensureImage("noise", noise, 255, 255)!!
+        val b = cache.ensureBytes("b", byteArrayOf(67))!!
+        val payloads = cache.takeUploadPayloads()
+        assertTrue("the image spans several payloads", payloads.size > 1)
+        val ids = payloads.map { G2CfwTextureCache.assetIdsInUploadPayload(it) }
+        assertEquals(setOf(a, big, b), ids.flatten().toSet())
+        assertEquals(a, ids.first().first())
+        assertEquals(b, ids.last().last())
+        assertTrue(G2CfwTextureCache.assetIdsInUploadPayload(byteArrayOf(38, 0, 0, 0, 0, 0)).isEmpty())
+    }
+
+    @Test
+    fun predictedOverflowForgetsTheLeastRecentlyUsedAssets() {
+        val cache = G2CfwTextureCache()
+        cache.reset(1)
+        val noise = ByteArray(255 * 255) { (it * 37).toByte() }
+        val ids = (0 until 5).map { cache.ensureImage("n$it", noise, 255, 255)!! }
+        assertTrue(cache.exhausted)
+        assertFalse(cache.holds(ids[0]))
+        assertTrue(cache.holds(ids[4]))
+        assertTrue(cache.predictedBytes <= G2CfwTextureCache.STORE_SIZE)
     }
 
     // ── Draw payload wire formats ───────────────────────────────────────────
 
     @Test
-    fun imageDrawPayloadMatchesMode13Wire() {
-        val payload = G2CfwTextureCache.imageDrawPayload(offset = 0x1234, x = 300, y = 130, options = 0x0F)
+    fun imageDrawPayloadMatchesMode19Wire() {
+        val payload = G2CfwTextureCache.imageDrawPayload(assetId = 0x1234, x = 300, y = -2, options = 0x0F)
         assertNotNull(payload)
         assertArrayEquals(
-            byteArrayOf(13, 0x34, 0x12, 0x2C, 0x01, 130.toByte(), 0, 0x0F),
+            byteArrayOf(19, 0x34, 0x12, 0, 0, 0x2C, 0x01, 0xFE.toByte(), 0xFF.toByte(), 0x0F),
             payload,
         )
+        assertNull(G2CfwTextureCache.imageDrawPayload(assetId = 0, x = 0, y = 0, options = 0))
     }
 
     @Test
-    fun stringRunPayloadMatchesMode14Wire() {
+    fun stringRunPayloadMatchesMode20Wire() {
         val chars = "Hi".toByteArray(Charsets.US_ASCII)
-        val payload =
-            G2CfwTextureCache.stringRunPayload(fontTableOffset = 2, x = 40, y = 150, options = 0x0F, chars = chars)
+        val payload = G2CfwTextureCache.stringRunPayload(fontId = 2, x = 40, y = 150, options = 0x0F, chars = chars)
         assertNotNull(payload)
         assertArrayEquals(
-            byteArrayOf(14, 2, 0, 40, 0, 150.toByte(), 0, 0x0F, 2) + chars,
+            byteArrayOf(20, 2, 0, 0, 0, 40, 0, 150.toByte(), 0, 0x0F, 2) + chars,
             payload,
         )
         // Control/non-ASCII bytes are x-adjust commands on the wire — rejected.
         assertNull(G2CfwTextureCache.stringRunPayload(2, 0, 0, 0, byteArrayOf(10)))
         assertNull(G2CfwTextureCache.stringRunPayload(2, 0, 0, 0, byteArrayOf(200.toByte())))
+        assertNull(G2CfwTextureCache.stringRunPayload(0, 0, 0, 0, chars))
     }
 
     // ── End-to-end mono fast path ───────────────────────────────────────────
@@ -162,10 +219,10 @@ class G2CfwTextureCacheTest {
         assertNotNull(second)
         second!!
         assertFalse(second.usedFullFrame)
-        // The changed cells travel as mode-12 uploads + mode-14 runs; no
+        // The changed cells travel as a font-asset PUT + mode-20 runs; no
         // bitmap delta (0x83) should remain for a pure-ASCII grid change.
         assertTrue(second.uploads.isNotEmpty())
-        assertTrue(second.uploads.all { it.first() == 12.toByte() })
+        assertTrue(second.uploads.all { it.first() == 37.toByte() })
         val payload = second.payload
         assertNotNull(payload)
         payload!!
@@ -178,10 +235,10 @@ class G2CfwTextureCacheTest {
                 if (pos < payload.size) segments.add(payload[pos])
                 pos += len
             }
-            assertTrue(segments.contains(14.toByte()))
+            assertTrue(segments.contains(20.toByte()))
             assertFalse(segments.contains(0x83.toByte()))
         } else {
-            assertEquals(14.toByte(), payload.first())
+            assertEquals(20.toByte(), payload.first())
         }
 
         // A lens-unequal window must fall back to plain bitmap deltas.

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

@@ -0,0 +1,252 @@
+package com.glassly.bluetoothsdk.sgcs
+
+import java.util.zip.Inflater
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeoutOrNull
+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
+
+/**
+ * Wire contract of the SID-0xf0 message stream (g2flash message_transport.c,
+ * GLASSLYCFW/31). The probe in g2flash (`send_message_probe.py --dry-run`)
+ * produces the same packets for the same input.
+ */
+class G2CfwTransportTest {
+    private fun inflateRecords(records: List<ByteArray>): List<ByteArray> {
+        val inflater = Inflater()
+        val out = mutableListOf<ByteArray>()
+        for (record in records) {
+            val flags = record[0].toInt() and 0xFF
+            val length = (record[1].toInt() and 0xFF) or ((record[2].toInt() and 0xFF) shl 8)
+            assertEquals(record.size - 5, length)
+            val body = record.copyOfRange(5, record.size)
+            if (flags and G2CfwTransport.FLAG_COMPRESSED == 0) {
+                out.add(body)
+                continue
+            }
+            // Every compressed record ends in a complete SYNC_FLUSH marker.
+            assertEquals(listOf(0x00, 0x00, 0xFF, 0xFF), body.takeLast(4).map { it.toInt() and 0xFF })
+            // As the firmware does: a RESET_CONTEXT record starts a fresh inflate stream.
+            if (flags and G2CfwTransport.FLAG_RESET_CONTEXT != 0) inflater.reset()
+            inflater.setInput(body)
+
+            val buffer = ByteArray(0x10000)
+            val produced = inflater.inflate(buffer)
+            assertTrue(inflater.needsInput())
+            out.add(buffer.copyOf(produced))
+        }
+        inflater.end()
+        return out
+    }
+
+    @Test
+    fun recordsShareOneContextAndCarryThePlainCrc() {
+        val encoder = G2CfwTransport.Encoder()
+        val first = byteArrayOf(6) + ByteArray(5000)
+        val second = byteArrayOf(3, 1, 2, 3, 4, 5, 0) + ByteArray(300) { 0x1F }
+        val r1 = encoder.record(first, 3)!!
+        val r2 = encoder.record(second, 3)!!
+        // First record resets the context (flag 8); the second continues it.
+        assertEquals(3 or 4 or 8, r1[0].toInt() and 0xFF)
+        assertEquals(3 or 4, r2[0].toInt() and 0xFF)
+        assertEquals(G2CfwTransport.crc16(first), (r1[3].toInt() and 0xFF) or ((r1[4].toInt() and 0xFF) shl 8))
+        assertEquals(G2CfwTransport.crc16(second), (r2[3].toInt() and 0xFF) or ((r2[4].toInt() and 0xFF) shl 8))
+        assertTrue(r1.size < 100) // 5000 zero bytes deflate to a few
+        val decoded = inflateRecords(listOf(r1, r2))
+        assertArrayEquals(first, decoded[0])
+        assertArrayEquals(second, decoded[1])
+        // After a NACK/timeout the context restarts and the next record says so.
+        encoder.resetContext()
+        val r3 = encoder.record(second, 1)!!
+        assertEquals(1 or 4 or 8, r3[0].toInt() and 0xFF)
+        assertArrayEquals(second, inflateRecords(listOf(r3))[0])
+        assertNull(encoder.record(ByteArray(0x10000), 3))
+        assertNull(encoder.record(byteArrayOf(7, 0xFF.toByte()), 4))
+    }
+
+    @Test
+    fun lensTargetedRecordsAreSelfContainedSoTheSkippingLensStaysInSync() {
+        val encoder = G2CfwTransport.Encoder()
+        val shared = byteArrayOf(38, 0, 0, 0, 0, 1, 0) + ByteArray(400) { 0x2A }
+        val leftOnly = byteArrayOf(38, 0, 0, 1, 0, 1, 0) + ByteArray(400) { 0x2B }
+        val rightOnly = byteArrayOf(38, 0, 0, 2, 0, 1, 0) + ByteArray(400) { 0x2C }
+        val r1 = encoder.record(shared, 3)!!
+        val r2 = encoder.record(leftOnly, 1)!!
+        val r3 = encoder.record(rightOnly, 2)!!
+        val r4 = encoder.record(shared, 3)!!
+        val r5 = encoder.record(shared, 3)!!
+        assertEquals("a left-only record starts a fresh context", 1 or 4 or 8, r2[0].toInt() and 0xFF)
+        assertEquals(2 or 4 or 8, r3[0].toInt() and 0xFF)
+        assertEquals("and the record after it starts fresh again", 3 or 4 or 8, r4[0].toInt() and 0xFF)
+        assertEquals("then the shared context resumes", 3 or 4, r5[0].toInt() and 0xFF)
+        // Each lens inflates exactly the records addressed to it.
+        val left = inflateRecords(listOf(r1, r2, r4, r5))
+        assertArrayEquals(leftOnly, left[1]); assertArrayEquals(shared, left[3])
+        val right = inflateRecords(listOf(r1, r3, r4, r5))
+        assertArrayEquals(rightOnly, right[1]); assertArrayEquals(shared, right[3])
+    }
+
+
+    @Test
+    fun packetsMatchTheProbeFraming() {
+        val stream = ByteArray(500) { (it and 0xFF).toByte() }
+        val packets = G2CfwTransport.packets(stream, 254, 3, chunkBytes = 200)
+        assertEquals(3, packets.size)
+        // [aa 21 seq len+2 1 1 f0 0][options][chunk][crc lo][crc hi]
+        assertEquals(listOf(0xAA, 0x21, 254, 203, 1, 1, 0xF0, 0, 3 or 0x80), packets[0].take(9).map { it.toInt() and 0xFF })
+        assertEquals(listOf(0xAA, 0x21, 255, 203, 1, 1, 0xF0, 0, 3), packets[1].take(9).map { it.toInt() and 0xFF })
+        assertEquals(listOf(0xAA, 0x21, 0, 103, 1, 1, 0xF0, 0, 3 or 0x40), packets[2].take(9).map { it.toInt() and 0xFF })
+        assertEquals(8 + 1 + 100 + 2, packets[2].size)
+        for (packet in packets) {
+            val body = packet.copyOfRange(8, packet.size - 2)
+            val crc = G2CfwTransport.crc16(body)
+            assertEquals(crc and 0xFF, packet[packet.size - 2].toInt() and 0xFF)
+            assertEquals(crc ushr 8, packet[packet.size - 1].toInt() and 0xFF)
+            assertEquals(packet.size - 8, packet[3].toInt() and 0xFF)
+        }
+        val joined = packets.flatMap { it.copyOfRange(9, it.size - 2).toList() }.toByteArray()
+        assertArrayEquals(stream, joined)
+        // An empty stream is one RESET|END packet.
+        val empty = G2CfwTransport.packets(ByteArray(0), 7, 1)
+        assertEquals(1, empty.size)
+        assertEquals(listOf(0xAA, 0x21, 7, 3, 1, 1, 0xF0, 0, 1 or 0x80 or 0x40), empty[0].take(9).map { it.toInt() and 0xFF })
+        assertTrue(G2CfwTransport.MAX_CHUNK_BYTES <= 252)
+    }
+
+    @Test
+    fun ackParsingIncludesHistoryAndRejectsMalformedReplies() {
+        val body = byteArrayOf(1, 7, 0, 0, 2, 0x34, 0x12, 0xCD.toByte(), 0xAB.toByte(), 6, 1, 0, 0x10, 0, 0x22, 0x11)
+        val ack = G2CfwTransport.parseAck(body)!!
+        assertTrue(ack.success)
+        assertEquals(2, ack.lens)
+        assertEquals(G2CfwTransport.AckEntry(7, 0, 0x1234, 0xABCD), ack.current)
+        assertEquals(2, ack.entries.size)
+        assertEquals(G2CfwTransport.AckEntry(6, 1, 0x10, 0x1122), ack.entries[1])
+        val nack = G2CfwTransport.parseAck(byteArrayOf(3, 7, 0, 0, 1, 0, 0, 0, 0))!!
+        assertFalse(nack.success)
+        assertNull(G2CfwTransport.parseAck(byteArrayOf(3, 7, 0, 0, 1, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 0))) // NACK has no history
+        assertNull(G2CfwTransport.parseAck(byteArrayOf(2, 7, 0, 0, 1, 0, 0, 0, 0)))
+        assertNull(G2CfwTransport.parseAck(byteArrayOf(1, 7, 0, 0, 3, 0, 0, 0, 0)))
+        assertNull(G2CfwTransport.parseAck(byteArrayOf(1, 7, 0, 0)))
+
+        // Notify frame as the glasses send it: [aa 12 seq len 1 1 f0 0][body][crc].
+        val crc = G2CfwTransport.crc16(body)
+        val frame = byteArrayOf(0xAA.toByte(), 0x12, 9, (body.size + 2).toByte(), 1, 1, 0xF0.toByte(), 0) + body +
+            byteArrayOf((crc and 0xFF).toByte(), (crc ushr 8).toByte())
+        assertArrayEquals(body, G2CfwTransport.replyBody(frame))
+        val corrupt = frame.copyOf().also { it[10] = (it[10].toInt() xor 1).toByte() }
+        assertNull(G2CfwTransport.replyBody(corrupt))
+        val otherService = frame.copyOf().also { it[6] = 0xE0.toByte() }
+        assertNull(G2CfwTransport.replyBody(otherService))
+    }
+
+    @Test
+    fun ackBoxCompletesWhenBothLensesAckAndFailsOnNack() = runBlocking {
+        val box = G2CfwAckBox()
+        val left = G2CfwTransport.parseAck(byteArrayOf(1, 5, 0, 0, 1, 2, 0, 0, 0))!!
+        val right = G2CfwTransport.parseAck(byteArrayOf(1, 5, 0, 0, 2, 2, 0, 0, 0))!!
+        val first = box.arm(5, 3)
+        assertFalse(box.resolve(left)) // one lens is not enough
+        assertFalse(box.resolve(left)) // duplicate is harmless
+        assertTrue(box.resolve(right))
+        assertEquals(true, withTimeoutOrNull(1000) { first.await() })
+        assertEquals("ack", box.lastOutcome)
+        assertTrue(box.lastSuccessMs > 0)
+
+        val nack = G2CfwTransport.parseAck(byteArrayOf(3, 6, 0, 0, 2, 0, 0, 0, 0))!!
+        val second = box.arm(6, 3)
+        assertFalse(box.resolve(left)) // wrong stream
+        assertTrue(box.resolve(nack))
+        assertEquals(false, withTimeoutOrNull(1000) { second.await() })
+        assertEquals("nack", box.lastOutcome)
+
+        val third = box.arm(7, 1)
+        assertNull(withTimeoutOrNull(50) { third.await() })
+        box.disarm(third, "timeout")
+        assertEquals("timeout", box.lastOutcome)
+        assertFalse(box.resolve(G2CfwTransport.parseAck(byteArrayOf(1, 7, 0, 0, 1, 0, 0, 0, 0))!!))
+    }
+
+    @Test
+    fun expiredQueueGuardsStayExpiredAfterStreamIdReuse() {
+        val box = G2CfwAckBox()
+        val expired = box.arm(7, 3)
+        val oldGuard = { box.isPending(expired) }
+        assertTrue(oldGuard())
+        box.disarm(expired, "timeout")
+        assertFalse(oldGuard())
+        val replacement = box.arm(7, 3)
+        assertFalse(oldGuard())
+        assertTrue(box.isPending(replacement))
+        // Cleanup from an old coroutine cannot disarm a newer generation.
+        box.disarm(expired, "cancelled")
+        assertTrue(box.isPending(replacement))
+        box.disarm(replacement, "cancelled")
+        assertFalse(box.isPending(replacement))
+    }
+
+    @Test
+    fun queueGuardExpiresOnCancellationNackAndFullAckButNotPartialAck() {
+        val box = G2CfwAckBox()
+        val cancelled = box.arm(7, 3)
+        cancelled.cancel()
+        assertFalse(box.isPending(cancelled))
+        val pending = box.arm(7, 3)
+        val entry = listOf(G2CfwTransport.AckEntry(7, 0, 0, 0))
+        assertFalse(box.resolve(G2CfwTransport.Ack(true, 1, entry)))
+        assertTrue(box.isPending(pending))
+        assertTrue(box.resolve(G2CfwTransport.Ack(true, 2, entry)))
+        assertFalse(box.isPending(pending))
+        val rejected = box.arm(7, 3)
+        assertTrue(box.resolve(G2CfwTransport.Ack(false, 1, entry)))
+        assertFalse(box.isPending(rejected))
+    }
+
+    @Test
+    fun cacheRepliesParseAndStampFillsEpochAndRequest() {
+        val body = byteArrayOf(5, 9, 0, 0, 2, 38, 7, 0, 2, 0x34, 0x12, 5, 0, 0, 0, 2, 1, 1, 0, 0, 0, 0, 1, 0, 0)
+        val reply = G2CfwTransport.parseCacheReply(body)
+        assertNotNull(reply)
+        reply!!
+        assertEquals(9, reply.streamId)
+        assertEquals(2, reply.lens)
+        assertEquals(38, reply.mode)
+        assertEquals(7, reply.request)
+        assertEquals(G2CfwTransport.CacheReply.MISSING, reply.status)
+        assertEquals(0x1234, reply.epoch)
+        assertEquals(5L, reply.revision)
+        assertEquals(listOf(1, 256), reply.missingIds)
+        assertTrue(reply.summary.startsWith("missing"))
+        assertNull(G2CfwTransport.parseCacheReply(byteArrayOf(1, 9, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)))
+        assertNull(G2CfwTransport.parseAck(body))
+
+        val show = byteArrayOf(38, 0, 0, 0, 0, 1, 0, 0, 0, 0)
+        assertTrue(G2CfwTransport.isCacheMessage(show))
+        assertFalse(G2CfwTransport.isCacheMessage(byteArrayOf(36, 0, 0, 0, 0)))
+        assertEquals(listOf(38, 0x34, 0x12, 2, 1), G2CfwTransport.stamp(show, 0x1234, 0x0102).take(5).map { it.toInt() and 0xFF })
+        assertEquals(listOf(38, 1, 0, 9, 0), G2CfwTransport.stamp(byteArrayOf(38, 0, 0, 9, 0, 1, 0, 0, 0, 0), 1, 7).take(5).map { it.toInt() and 0xFF })
+        assertEquals(listOf(40, 1, 0, 0, 0), G2CfwTransport.stamp(byteArrayOf(40, 0, 0, 0, 0, 0, 0, 0, 0), 1, 7).take(5).map { it.toInt() and 0xFF })
+
+        val box = G2CfwAckBox()
+        val deferred = box.arm(9, G2CfwTransport.LENS_BOTH)
+        box.record(reply)
+        assertFalse(box.resolve(G2CfwTransport.Ack(true, 2, listOf(G2CfwTransport.AckEntry(9, 0, 1, 0)))))
+        assertTrue(box.resolve(G2CfwTransport.Ack(true, 1, listOf(G2CfwTransport.AckEntry(9, 0, 1, 0)))))
+        assertTrue(deferred.isCompleted)
+        assertEquals(reply, box.cacheReplies()[2])
+        assertNull(box.cacheReplies()[1])
+    }
+
+    @Test
+    fun ackTimeoutScalesWithStreamSize() {
+        assertEquals(3500L, G2CfwTransport.ackTimeoutMs(0))
+        assertEquals(3500L + 65535, G2CfwTransport.ackTimeoutMs(65535))
+        // A 4.5 KB upload chunk acked in ~4.1 s on GLASSLYCFW/39; the deadline must clear it.
+        assertTrue(G2CfwTransport.ackTimeoutMs(4500) > 6000L)
+    }
+}

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

@@ -0,0 +1,64 @@
+package com.glassly.bluetoothsdk.sgcs
+
+import org.junit.Assert.*
+import org.junit.Test
+
+class G2DisplayDiagnosticsTest {
+    @Test fun samplesAreThrottledResetAndLeaveOutEmptyValues() {
+        val diagnostics = G2DisplayDiagnostics(0)
+        diagnostics.count("framesIn")
+        diagnostics.count("txBytes", 100)
+        diagnostics.timing("transferMs", 10)
+        diagnostics.timing("transferMs", 31)
+        diagnostics.timing("encodeMs", 0)
+        assertNull(diagnostics.sample(900, 9000, emptyMap()))
+        val first = diagnostics.sample(1000, 10000, mapOf("app" to "system.gesture-dots", "payloadQueue" to 0, "page" to false))!!
+        assertEquals(100, first["txBytes"])
+        assertEquals(20.5, first["transferMsAvg"])
+        assertEquals(31L, first["transferMsMax"])
+        assertNull(first["transferMsTotal"])
+        assertNull(first["encodeMsAvg"])
+        assertEquals(10000L, first["t"])
+        assertEquals("system.gesture-dots", first["app"])
+        assertNull(first["payloadQueue"])
+        assertNull(first["page"])
+        assertNull(first["timeouts"])
+        assertEquals(8, (first["run"] as String).length)
+        diagnostics.count("framesIn")
+        val second = diagnostics.sample(2000, 11000, emptyMap())!!
+        assertNull(second["txBytes"])
+        assertNull(second["transferMsAvg"])
+        assertEquals(first["run"], second["run"])
+        assertEquals(2, second["id"])
+    }
+
+    @Test fun idleWindowsAreSkippedUnlessBusyOrLate() {
+        val diagnostics = G2DisplayDiagnostics(0)
+        diagnostics.count("imuReceived")
+        diagnostics.count("txBytes", 32)
+        diagnostics.timing("notifyDispatchMs", 1)
+        assertNull(diagnostics.sample(1000, 10000, emptyMap()))
+        assertNotNull(diagnostics.sample(2000, 11000, mapOf("payloadQueue" to 2), busy = true))
+        assertNull(diagnostics.sample(3000, 12000, emptyMap()))
+    }
+
+    @Test fun concurrentWriterCountersAreNotLostAndLongWindowsRemainVisible() {
+        val diagnostics = G2DisplayDiagnostics(0)
+        val workers = List(4) { Thread { repeat(1000) { diagnostics.count("txPackets") } } }
+        workers.forEach { it.start() }
+        workers.forEach { it.join() }
+        val sample = diagnostics.sample(25000, 100000, emptyMap())!!
+        assertEquals(4000, sample["txPackets"])
+        assertEquals(25000L, sample["windowMs"])
+    }
+
+    @Test fun sessionFactsAreLoggedOnChangeAndOnceAMinute() {
+        val diagnostics = G2DisplayDiagnostics(0)
+        val facts = mapOf("platform" to "android", "cfw" to "GLASSLYCFW/39")
+        assertEquals("session", diagnostics.session(1000, 10000, facts)!!["type"])
+        assertNull(diagnostics.session(30_000, 39_000, facts))
+        assertNotNull(diagnostics.session(31_000, 40_000, facts + ("cfw" to "stock")))
+        assertNull(diagnostics.session(90_000, 99_000, facts + ("cfw" to "stock")))
+        assertNotNull(diagnostics.session(91_000, 100_000, facts + ("cfw" to "stock")))
+    }
+}