support for fixed size ints (all), but only BE

src/commonTest/kotlin/bipack/BipackEncoderTest.kt

@@ -58,7 +58,7 @@ class BipackEncoderTest {
 
     @Test
     fun encodeSimple() {
-        val a = Foobar1N(1,2)//, "bum")
+        val a = Foobar1N(1, 2)//, "bum")
         println(BipackEncoder.encode(a).toDump())
         assertEquals(2, BipackEncoder.encode(a).size)
         val b = BipackDecoder.decode<Foobar1N>(BipackEncoder.encode(a))
@@ -153,11 +153,11 @@ class BipackEncoderTest {
     @Serializable
     data class Types1(
         val i: Int = 7,
-        val f: Float = 1f/3f,
-        val d: Double = 1.0/3.0,
+        val f: Float = 1f / 3f,
+        val d: Double = 1.0 / 3.0,
         val b: Boolean = true,
         val s: String = "жёпа",
-        val ba: ByteArray = byteArrayOf(1,2,3),
+        val ba: ByteArray = byteArrayOf(1, 2, 3),
         val ch: Char = 'Ы',
     ) {
         override fun equals(other: Any?): Boolean {
@@ -209,7 +209,7 @@ class BipackEncoderTest {
         // less significant part (it actually uses native JS number which is longer than Float)
         // So for the test purposes we need exact values (that packs into float exacly, like nitegers
         // and some decimals with finite and short binary representation):
-        val t1 = Types1(f=0.5f)
+        val t1 = Types1(f = 0.5f)
         val d = BipackEncoder.encode(t1)
         println(d.toDump())
         val t2: Types1 = d.decodeFromBipack()
@@ -223,14 +223,14 @@ class BipackEncoderTest {
     @Serializable
     data class Fixa(
         @FixedSize(5)
-        val x: ByteArray
+        val x: ByteArray,
     )
 
     @Test
     fun textFixed() {
-        val x = byteArrayOf(1,2,3,4,5)
+        val x = byteArrayOf(1, 2, 3, 4, 5)
         //@Fixed(32)
-        val y = Fixa(byteArrayOf(1,2,3,4,5))
+        val y = Fixa(byteArrayOf(1, 2, 3, 4, 5))
         val d1 = BipackEncoder.encode(x)
         println(d1.toDump())
         assertEquals(6, d1.size)
@@ -241,14 +241,14 @@ class BipackEncoderTest {
         assertContentEquals(x, BipackDecoder.decode<Fixa>(d2).x)
     }
 
-//    @Test
+    //    @Test
     @Test
     fun testMaps() {
         val t1 = mapOf("foo bar" to "f1", "bar" to "b1", "bazz" to "b3")//f=17f/7f)
         val d = BipackEncoder.encode(t1)
         println(d.toDump())
         println(t1)
-        println(BipackDecoder.decode<Map<String,String>>(d))
+        println(BipackDecoder.decode<Map<String, String>>(d))
 //        println(d.decodeFromBipack<Map<String,String>>())
 //        assertEquals(t1, d.decodeFromBipack())
     }
@@ -260,7 +260,7 @@ class BipackEncoderTest {
         val d = BipackEncoder.encode(t1)
         println(d.toDump())
         println(t1)
-        println(BipackDecoder.decode<Map<String,Foobar1N>>(d))
+        println(BipackDecoder.decode<Map<String, Foobar1N>>(d))
 //        println(d.decodeFromBipack<Map<String,String>>())
 //        assertEquals(t1, d.decodeFromBipack())
     }
@@ -274,7 +274,7 @@ class BipackEncoderTest {
         val d = BipackEncoder.encode(t1)
         println(d.toDump())
         println(t1)
-        println(BipackDecoder.decode<Map<String,Foobar1>>(d))
+        println(BipackDecoder.decode<Map<String, Foobar1>>(d))
 //        println(d.decodeFromBipack<Map<String,String>>())
 //        assertEquals(t1, d.decodeFromBipack())
     }
@@ -288,7 +288,7 @@ class BipackEncoderTest {
     @Serializable
 //    @Framed
     @CrcProtected
-    data class Outer(val i1: Inner,val i2: Inner)
+    data class Outer(val i1: Inner, val i2: Inner)
 
     @Test
     fun testNestedInOuterProtected() {
@@ -307,19 +307,38 @@ class BipackEncoderTest {
     @Serializable
     data class FI16(@Fixed val i: Short)
 
+    @Serializable
+    data class FI64(@Fixed val i: Long)
+
     @Serializable
     data class FU16(@Fixed val i: UShort)
+    @Serializable
+    class Foo(
+        @Fixed
+        val eightBytesLongInt: Long,
+    )
 
     @Test
     fun testFixedInt() {
-        val a= FI32(127)
+        val a = FI32(127)
         println(BipackEncoder.encode(a).toDump())
-        assertContentEquals(byteArrayOf(0,0,0,0x7f), BipackEncoder.encode(a))
+        assertContentEquals(byteArrayOf(0, 0, 0, 0x7f), BipackEncoder.encode(a))
         assertEquals("FF FF FF FF", BipackEncoder.encode(FI32(-1)).encodeToHex())
         assertEquals(-1, BipackEncoder.encode(FI32(-1)).decodeFromBipack<FI32>().i)
         assertEquals("FF FF FF FF", BipackEncoder.encode(FU32(0xFFFFFFFFu)).encodeToHex())
         assertEquals("FF 01 02 03", BipackEncoder.encode(FU32(0xFF010203u)).encodeToHex())
+
         assertEquals("FF 03", BipackEncoder.encode(FU16(0xFF03u)).encodeToHex())
         assertEquals(0x7ffeu, BipackEncoder.encode(FU16(0x7ffeu)).decodeFromBipack<FU16>().i)
+        assertEquals(-1, BipackEncoder.encode(FI16(-1)).decodeFromBipack<FI16>().i)
+        assertEquals(0x7ffe, BipackEncoder.encode(FI16(0x7ffe)).decodeFromBipack<FI16>().i)
+
+        assertEquals("00 00 00 01 00 00 00 02", BipackEncoder.encode(FI64(0x100000002)).encodeToHex())
+        assertEquals(0x100000002, BipackEncoder.encode(FI64(0x100000002)).decodeFromBipack<FI64>().i)
+
+
+        // so:
+        assertEquals("00 00 00 01 00 00 00 02", BipackEncoder.encode(Foo(0x100000002)).encodeToHex())
+
     }
 }