test(opencode): add ShortVec, UInt16, Maps, Long, and ByteArray tests

- ShortVecTest: encode/decode roundtrips, boundary values, encodeList
- UInt16Test: little-endian encoding for 0, 255, 256, 65535
- MapsTest: getOrPutIfNonNull conditional insertion
- LongTest: floored millisecond-to-second truncation
- ByteArrayExtensionsTest: toPublicKey, toMint, toSignature, toHash

Author: bmc08gt

services/opencode/src/test/kotlin/com/getcode/opencode/internal/extensions/ByteArrayExtensionsTest.kt

@@ -0,0 +1,42 @@
+package com.getcode.opencode.internal.extensions
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class ByteArrayExtensionsTest {
+
+    @Test
+    fun toPublicKeyPreservesBytes() {
+        val bytes = ByteArray(32) { (it + 1).toByte() }
+        val key = bytes.toPublicKey()
+        assertEquals(bytes.toList(), key.bytes)
+    }
+
+    @Test
+    fun toMintPreservesBytes() {
+        val bytes = ByteArray(32) { it.toByte() }
+        val mint = bytes.toMint()
+        assertEquals(bytes.toList(), mint.bytes)
+    }
+
+    @Test
+    fun toSignaturePreservesBytes() {
+        val bytes = ByteArray(64) { it.toByte() }
+        val signature = bytes.toSignature()
+        assertEquals(bytes.toList(), signature.bytes)
+    }
+
+    @Test
+    fun toHashPreservesBytes() {
+        val bytes = ByteArray(32) { (it * 2).toByte() }
+        val hash = bytes.toHash()
+        assertEquals(bytes.toList(), hash.bytes)
+    }
+
+    @Test
+    fun ubyteArrayToPublicKey() {
+        val ubytes = UByteArray(32) { (it + 1).toUByte() }
+        val key = ubytes.toPublicKey()
+        assertEquals(32, key.bytes.size)
+    }
+}

services/opencode/src/test/kotlin/com/getcode/opencode/internal/solana/ShortVecTest.kt

@@ -0,0 +1,137 @@
+package com.getcode.opencode.internal.solana
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class ShortVecTest {
+
+    // --- encodeLen / decodeLen roundtrip ---
+
+    @Test
+    fun encodeLenZero() {
+        val encoded = ShortVec.encodeLen(0)
+        assertEquals(listOf<Byte>(0), encoded)
+    }
+
+    @Test
+    fun encodeLenSmallValue() {
+        val encoded = ShortVec.encodeLen(5)
+        assertEquals(listOf<Byte>(5), encoded)
+    }
+
+    @Test
+    fun encodeLenMaxSingleByte() {
+        val encoded = ShortVec.encodeLen(0x7f)
+        assertEquals(1, encoded.size)
+        assertEquals(0x7f.toByte(), encoded[0])
+    }
+
+    @Test
+    fun encodeLenTwoBytes() {
+        val encoded = ShortVec.encodeLen(0x80)
+        assertEquals(2, encoded.size)
+    }
+
+    @Test
+    fun encodeLenLargerValue() {
+        val encoded = ShortVec.encodeLen(0x3FFF)
+        assertEquals(2, encoded.size)
+    }
+
+    @Test
+    fun encodeLenThreeBytes() {
+        val encoded = ShortVec.encodeLen(0x4000)
+        assertEquals(3, encoded.size)
+    }
+
+    @Test
+    fun roundtripZero() {
+        val encoded = ShortVec.encodeLen(0)
+        val (decoded, _) = ShortVec.decodeLen(encoded)
+        assertEquals(0, decoded)
+    }
+
+    @Test
+    fun roundtripSmall() {
+        val encoded = ShortVec.encodeLen(42)
+        val (decoded, _) = ShortVec.decodeLen(encoded)
+        assertEquals(42, decoded)
+    }
+
+    @Test
+    fun roundtripBoundary127() {
+        val encoded = ShortVec.encodeLen(127)
+        val (decoded, _) = ShortVec.decodeLen(encoded)
+        assertEquals(127, decoded)
+    }
+
+    @Test
+    fun roundtripBoundary128() {
+        val encoded = ShortVec.encodeLen(128)
+        val (decoded, _) = ShortVec.decodeLen(encoded)
+        assertEquals(128, decoded)
+    }
+
+    @Test
+    fun roundtripBoundary16383() {
+        val encoded = ShortVec.encodeLen(16383)
+        val (decoded, _) = ShortVec.decodeLen(encoded)
+        assertEquals(16383, decoded)
+    }
+
+    @Test
+    fun roundtripBoundary16384() {
+        val encoded = ShortVec.encodeLen(16384)
+        val (decoded, _) = ShortVec.decodeLen(encoded)
+        assertEquals(16384, decoded)
+    }
+
+    @Test
+    fun decodeLenReturnsTailBytes() {
+        val encoded = ShortVec.encodeLen(5)
+        val extra = listOf<Byte>(0xA, 0xB, 0xC)
+        val input = encoded + extra
+        val (value, remaining) = ShortVec.decodeLen(input)
+        assertEquals(5, value)
+        assertEquals(extra, remaining)
+    }
+
+    // --- encode / encodeList ---
+
+    @Test
+    fun encodePrependsLength() {
+        val data = listOf<Byte>(1, 2, 3)
+        val encoded = ShortVec.encode(data)
+        assertEquals(listOf<Byte>(3, 1, 2, 3), encoded)
+    }
+
+    @Test
+    fun encodeEmptyList() {
+        val encoded = ShortVec.encode(emptyList())
+        assertEquals(listOf<Byte>(0), encoded)
+    }
+
+    @Test
+    fun encodeListMultipleItems() {
+        val items = listOf(
+            listOf<Byte>(1, 2),
+            listOf<Byte>(3, 4, 5)
+        )
+        val encoded = ShortVec.encodeList(items)
+        // 2 items, then [1,2], then [3,4,5]
+        assertEquals(listOf<Byte>(2, 1, 2, 3, 4, 5), encoded)
+    }
+
+    @Test
+    fun encodeListEmpty() {
+        val encoded = ShortVec.encodeList(emptyList())
+        assertEquals(listOf<Byte>(0), encoded)
+    }
+
+    @Test
+    fun encodeListSingleItem() {
+        val items = listOf(listOf<Byte>(0xA, 0xB))
+        val encoded = ShortVec.encodeList(items)
+        assertEquals(listOf<Byte>(1, 0xA, 0xB), encoded)
+    }
+}

services/opencode/src/test/kotlin/com/getcode/opencode/internal/solana/extensions/UInt16Test.kt

@@ -0,0 +1,43 @@
+package com.getcode.opencode.internal.solana.extensions
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class UInt16Test {
+
+    @Test
+    fun zeroEncodesCorrectly() {
+        assertEquals(listOf<Byte>(0, 0), 0.toU16Bytes())
+    }
+
+    @Test
+    fun oneEncodesCorrectly() {
+        assertEquals(listOf<Byte>(1, 0), 1.toU16Bytes())
+    }
+
+    @Test
+    fun maxSingleByteValue() {
+        assertEquals(listOf<Byte>(0xFF.toByte(), 0), 255.toU16Bytes())
+    }
+
+    @Test
+    fun value256EncodesLittleEndian() {
+        assertEquals(listOf<Byte>(0, 1), 256.toU16Bytes())
+    }
+
+    @Test
+    fun value257() {
+        assertEquals(listOf<Byte>(1, 1), 257.toU16Bytes())
+    }
+
+    @Test
+    fun maxUInt16() {
+        assertEquals(listOf<Byte>(0xFF.toByte(), 0xFF.toByte()), 65535.toU16Bytes())
+    }
+
+    @Test
+    fun arbitraryValue() {
+        // 0x1234 = 4660 → little-endian: [0x34, 0x12]
+        assertEquals(listOf<Byte>(0x34, 0x12), 0x1234.toU16Bytes())
+    }
+}

services/opencode/src/test/kotlin/com/getcode/opencode/utils/LongTest.kt

@@ -0,0 +1,42 @@
+package com.getcode.opencode.utils
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class LongTest {
+
+    @Test
+    fun flooredZero() {
+        assertEquals(0L, 0L.floored)
+    }
+
+    @Test
+    fun flooredExactSecond() {
+        assertEquals(1000L, 1000L.floored)
+    }
+
+    @Test
+    fun flooredRoundsDown() {
+        assertEquals(1000L, 1500L.floored)
+    }
+
+    @Test
+    fun flooredSubSecond() {
+        assertEquals(0L, 500L.floored)
+    }
+
+    @Test
+    fun flooredExactMultipleSeconds() {
+        assertEquals(5000L, 5000L.floored)
+    }
+
+    @Test
+    fun flooredLargeValue() {
+        assertEquals(1710504000000L, 1710504000999L.floored)
+    }
+
+    @Test
+    fun flooredJustBelowSecond() {
+        assertEquals(0L, 999L.floored)
+    }
+}

services/opencode/src/test/kotlin/com/getcode/opencode/utils/MapsTest.kt

@@ -0,0 +1,43 @@
+package com.getcode.opencode.utils
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+
+class MapsTest {
+
+    @Test
+    fun getOrPutIfNonNullReturnsExistingValue() {
+        val map = mutableMapOf("a" to 1)
+        val result = map.getOrPutIfNonNull("a") { 99 }
+        assertEquals(1, result)
+        assertEquals(1, map["a"])
+    }
+
+    @Test
+    fun getOrPutIfNonNullInsertsNewValue() {
+        val map = mutableMapOf<String, Int>()
+        val result = map.getOrPutIfNonNull("a") { 42 }
+        assertEquals(42, result)
+        assertEquals(42, map["a"])
+    }
+
+    @Test
+    fun getOrPutIfNonNullSkipsNullDefault() {
+        val map = mutableMapOf<String, Int>()
+        val result = map.getOrPutIfNonNull("a") { null }
+        assertNull(result)
+        assertNull(map["a"])
+    }
+
+    @Test
+    fun getOrPutIfNonNullDoesNotCallDefaultWhenKeyExists() {
+        val map = mutableMapOf("a" to 1)
+        var called = false
+        map.getOrPutIfNonNull("a") {
+            called = true
+            99
+        }
+        assertEquals(false, called)
+    }
+}