Byte Tests and Bug Fixes

Author: consuelita

Codex/src/main/java/org/operatorfoundation/codex/symbols/Byte.kt

@@ -6,23 +6,30 @@ import java.math.BigInteger
  * Byte symbol - encodes/decodes byte values (0-255).
  * Used for binary data encoding.
  */
-class Byte : Symbol {
+class Byte : Symbol
+{
     override fun size() = 256
     override fun toString() = "Byte"
 
-    override fun encode(numericValue: BigInteger): ByteArray {
-        if (numericValue < 0.toBigInteger() || numericValue > 255.toBigInteger()) {
-            throw Exception("Invalid value $numericValue for Byte (must be 0-255)")
+    override fun encode(numericValue: BigInteger): ByteArray
+    {
+        if (numericValue < BigInteger.ZERO || numericValue > BigInteger.valueOf(255))
+        {
+            throw IllegalArgumentException("Invalid value $numericValue for Byte (must be 0-255)")
         }
-        return numericValue.toInt().toChar().toString().toByteArray()
+
+        // A single raw byte
+        return byteArrayOf(numericValue.toInt().toByte())
     }
 
-    override fun decode(encodedValue: ByteArray): BigInteger {
+    override fun decode(encodedValue: ByteArray): BigInteger
+    {
         if (encodedValue.size != 1)
         {
-            throw Exception("Too many bytes")
+            throw IllegalArgumentException("Invalid encoded value length: ${encodedValue.size}  ")
         }
 
-        return encodedValue[0].toInt().toBigInteger()
+        // unsigned 0–255
+        return encodedValue[0].toUByte().toInt().toBigInteger()
     }
 }

Codex/src/test/java/org/operatorfoundation/codex/ByteTest.kt

@@ -0,0 +1,101 @@
+package org.operatorfoundation.codex
+
+import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.ValueSource
+import org.operatorfoundation.codex.symbols.Byte
+import java.math.BigInteger
+
+class ByteTest
+{
+
+    private val symbol = Byte()
+
+    @Test
+    fun `size should be 256`() {
+        assertEquals(256, symbol.size())
+    }
+
+    @Test
+    fun `toString should return Byte`() {
+        assertEquals("Byte", symbol.toString())
+    }
+
+    @ParameterizedTest(name = "roundtrip {0}")
+    @ValueSource(ints = [0, 1, 2, 127, 128, 200, 254, 255])
+    fun `encode and decode roundtrip for selected values`(input: Int) {
+        val value = BigInteger.valueOf(input.toLong())
+        val encoded = symbol.encode(value)
+        val decoded = symbol.decode(encoded)
+        assertEquals(value, decoded)
+        assertEquals(1, encoded.size)
+    }
+
+    @Test
+    fun `encode and decode roundtrip for all values`() {
+        for (i in 0..255) {
+            val value = BigInteger.valueOf(i.toLong())        // 1) make a BigInteger 0..255
+            val encoded = symbol.encode(value)       // 2) encode it to bytes
+            val decoded = symbol.decode(encoded)    // 3) decode back to BigInteger
+            assertEquals(value,
+                decoded,
+                "Failed for $i")                        // 4) verify roundtrip
+        }
+    }
+
+    @Test
+    fun `encode should throw for negative values`() {
+        assertThrows(IllegalArgumentException::class.java) {
+            symbol.encode(BigInteger.valueOf(-1))
+        }
+    }
+    
+    @Test
+    fun `encode should throw for values above 255`() {
+        assertThrows(IllegalArgumentException::class.java) {
+            symbol.encode(BigInteger.valueOf(256))
+        }
+    }
+
+    @Test
+    fun `decode should throw for arrays larger than 1 byte`() {
+        assertThrows(IllegalArgumentException::class.java) {
+            symbol.decode(byteArrayOf(1, 2))
+        }
+    }
+
+    @Test
+    fun `decode single byte 0 through 127`() {
+        for (i in 0..127) {
+            val input = byteArrayOf(i.toByte())
+            val decoded = symbol.decode(input)
+            assertEquals(BigInteger.valueOf(i.toLong()), decoded, "Failed for $i")
+        }
+    }
+
+    @Test
+    fun `decode single byte 128 through 255`() {
+        for (i in 128..255) {
+            val input = byteArrayOf(i.toByte()) // values above 127 wrap to negative Kotlin Bytes
+            val decoded = symbol.decode(input)
+            assertEquals(BigInteger.valueOf(i.toLong()), decoded, "Failed for $i")
+        }
+    }
+
+    @Test
+    fun `decode should throw when empty`() {
+        val ex = assertThrows(IllegalArgumentException::class.java) {
+            symbol.decode(byteArrayOf())
+        }
+        assertTrue(ex.message!!.contains("length"), "Expected message about length but got: ${ex.message}")
+    }
+
+    @Test
+    fun `decode should throw when more than 1 byte`() {
+        val ex = assertThrows(IllegalArgumentException::class.java) {
+            symbol.decode(byteArrayOf(1, 2, 3))
+        }
+        assertTrue(ex.message!!.contains("length"), "Expected message about length but got: ${ex.message}")
+    }
+}