@marcuspuchalla/nachos 0.1.0

package/src/encoder/__tests__/cbor-integer-encoder.test.ts

@@ -0,0 +1,283 @@
+/**
+ * CBOR Integer Encoder Test Suite
+ * Tests for Major Type 0 (Unsigned) and Major Type 1 (Negative)
+ */
+
+import { describe, it, expect } from 'vitest'
+import { useCborIntegerEncoder } from '../composables/useCborIntegerEncoder'
+
+describe('CBOR Integer Encoder', () => {
+  describe('Unsigned Integers (Major Type 0)', () => {
+    describe('Direct encoding (0-23)', () => {
+      it('should encode 0', () => {
+        const { encodeUnsignedInt } = useCborIntegerEncoder()
+        const result = encodeUnsignedInt(0)
+
+        expect(result.bytes).toEqual(new Uint8Array([0x00]))
+        expect(result.hex).toBe('00')
+      })
+
+      it('should encode 1', () => {
+        const { encodeUnsignedInt } = useCborIntegerEncoder()
+        const result = encodeUnsignedInt(1)
+
+        expect(result.bytes).toEqual(new Uint8Array([0x01]))
+        expect(result.hex).toBe('01')
+      })
+
+      it('should encode 10', () => {
+        const { encodeUnsignedInt } = useCborIntegerEncoder()
+        const result = encodeUnsignedInt(10)
+
+        expect(result.bytes).toEqual(new Uint8Array([0x0a]))
+        expect(result.hex).toBe('0a')
+      })
+
+      it('should encode 23', () => {
+        const { encodeUnsignedInt } = useCborIntegerEncoder()
+        const result = encodeUnsignedInt(23)
+
+        expect(result.bytes).toEqual(new Uint8Array([0x17]))
+        expect(result.hex).toBe('17')
+      })
+    })
+
+    describe('1-byte encoding (24-255)', () => {
+      it('should encode 24', () => {
+        const { encodeUnsignedInt } = useCborIntegerEncoder()
+        const result = encodeUnsignedInt(24)
+
+        expect(result.bytes).toEqual(new Uint8Array([0x18, 0x18]))
+        expect(result.hex).toBe('1818')
+      })
+
+      it('should encode 25', () => {
+        const { encodeUnsignedInt } = useCborIntegerEncoder()
+        const result = encodeUnsignedInt(25)
+
+        expect(result.bytes).toEqual(new Uint8Array([0x18, 0x19]))
+        expect(result.hex).toBe('1819')
+      })
+
+      it('should encode 100', () => {
+        const { encodeUnsignedInt } = useCborIntegerEncoder()
+        const result = encodeUnsignedInt(100)
+
+        expect(result.bytes).toEqual(new Uint8Array([0x18, 0x64]))
+        expect(result.hex).toBe('1864')
+      })
+
+      it('should encode 255', () => {
+        const { encodeUnsignedInt } = useCborIntegerEncoder()
+        const result = encodeUnsignedInt(255)
+
+        expect(result.bytes).toEqual(new Uint8Array([0x18, 0xff]))
+        expect(result.hex).toBe('18ff')
+      })
+    })
+
+    describe('2-byte encoding (256-65535)', () => {
+      it('should encode 256', () => {
+        const { encodeUnsignedInt } = useCborIntegerEncoder()
+        const result = encodeUnsignedInt(256)
+
+        expect(result.bytes).toEqual(new Uint8Array([0x19, 0x01, 0x00]))
+        expect(result.hex).toBe('190100')
+      })
+
+      it('should encode 1000', () => {
+        const { encodeUnsignedInt } = useCborIntegerEncoder()
+        const result = encodeUnsignedInt(1000)
+
+        expect(result.bytes).toEqual(new Uint8Array([0x19, 0x03, 0xe8]))
+        expect(result.hex).toBe('1903e8')
+      })
+
+      it('should encode 65535', () => {
+        const { encodeUnsignedInt } = useCborIntegerEncoder()
+        const result = encodeUnsignedInt(65535)
+
+        expect(result.bytes).toEqual(new Uint8Array([0x19, 0xff, 0xff]))
+        expect(result.hex).toBe('19ffff')
+      })
+    })
+
+    describe('4-byte encoding (65536-4294967295)', () => {
+      it('should encode 65536', () => {
+        const { encodeUnsignedInt } = useCborIntegerEncoder()
+        const result = encodeUnsignedInt(65536)
+
+        expect(result.bytes).toEqual(new Uint8Array([0x1a, 0x00, 0x01, 0x00, 0x00]))
+        expect(result.hex).toBe('1a00010000')
+      })
+
+      it('should encode 1000000', () => {
+        const { encodeUnsignedInt } = useCborIntegerEncoder()
+        const result = encodeUnsignedInt(1000000)
+
+        expect(result.bytes).toEqual(new Uint8Array([0x1a, 0x00, 0x0f, 0x42, 0x40]))
+        expect(result.hex).toBe('1a000f4240')
+      })
+
+      it('should encode 4294967295', () => {
+        const { encodeUnsignedInt } = useCborIntegerEncoder()
+        const result = encodeUnsignedInt(4294967295)
+
+        expect(result.bytes).toEqual(new Uint8Array([0x1a, 0xff, 0xff, 0xff, 0xff]))
+        expect(result.hex).toBe('1affffffff')
+      })
+    })
+
+    describe('8-byte encoding (> 4294967295)', () => {
+      it('should encode 4294967296', () => {
+        const { encodeUnsignedInt } = useCborIntegerEncoder()
+        const result = encodeUnsignedInt(4294967296)
+
+        expect(result.bytes).toEqual(new Uint8Array([0x1b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00]))
+        expect(result.hex).toBe('1b0000000100000000')
+      })
+
+      it('should encode BigInt values', () => {
+        const { encodeUnsignedInt } = useCborIntegerEncoder()
+        const result = encodeUnsignedInt(18446744073709551615n)  // 2^64 - 1
+
+        expect(result.bytes).toEqual(new Uint8Array([0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]))
+        expect(result.hex).toBe('1bffffffffffffffff')
+      })
+    })
+
+    describe('Error cases', () => {
+      it('should reject negative values', () => {
+        const { encodeUnsignedInt } = useCborIntegerEncoder()
+
+        expect(() => encodeUnsignedInt(-1)).toThrow('Cannot encode negative value as unsigned integer')
+      })
+
+      it('should reject values >= 2^64', () => {
+        const { encodeUnsignedInt } = useCborIntegerEncoder()
+
+        expect(() => encodeUnsignedInt(18446744073709551616n)).toThrow('Value exceeds maximum unsigned integer (2^64-1)')
+      })
+    })
+  })
+
+  describe('Negative Integers (Major Type 1)', () => {
+    describe('Direct encoding (-1 to -24)', () => {
+      it('should encode -1', () => {
+        const { encodeNegativeInt } = useCborIntegerEncoder()
+        const result = encodeNegativeInt(-1)
+
+        expect(result.bytes).toEqual(new Uint8Array([0x20]))
+        expect(result.hex).toBe('20')
+      })
+
+      it('should encode -10', () => {
+        const { encodeNegativeInt } = useCborIntegerEncoder()
+        const result = encodeNegativeInt(-10)
+
+        expect(result.bytes).toEqual(new Uint8Array([0x29]))
+        expect(result.hex).toBe('29')
+      })
+
+      it('should encode -24', () => {
+        const { encodeNegativeInt } = useCborIntegerEncoder()
+        const result = encodeNegativeInt(-24)
+
+        expect(result.bytes).toEqual(new Uint8Array([0x37]))
+        expect(result.hex).toBe('37')
+      })
+    })
+
+    describe('1-byte encoding (-25 to -256)', () => {
+      it('should encode -25', () => {
+        const { encodeNegativeInt } = useCborIntegerEncoder()
+        const result = encodeNegativeInt(-25)
+
+        expect(result.bytes).toEqual(new Uint8Array([0x38, 0x18]))
+        expect(result.hex).toBe('3818')
+      })
+
+      it('should encode -100', () => {
+        const { encodeNegativeInt } = useCborIntegerEncoder()
+        const result = encodeNegativeInt(-100)
+
+        expect(result.bytes).toEqual(new Uint8Array([0x38, 0x63]))
+        expect(result.hex).toBe('3863')
+      })
+
+      it('should encode -256', () => {
+        const { encodeNegativeInt } = useCborIntegerEncoder()
+        const result = encodeNegativeInt(-256)
+
+        expect(result.bytes).toEqual(new Uint8Array([0x38, 0xff]))
+        expect(result.hex).toBe('38ff')
+      })
+    })
+
+    describe('2-byte encoding (-257 to -65536)', () => {
+      it('should encode -257', () => {
+        const { encodeNegativeInt } = useCborIntegerEncoder()
+        const result = encodeNegativeInt(-257)
+
+        expect(result.bytes).toEqual(new Uint8Array([0x39, 0x01, 0x00]))
+        expect(result.hex).toBe('390100')
+      })
+
+      it('should encode -1000', () => {
+        const { encodeNegativeInt } = useCborIntegerEncoder()
+        const result = encodeNegativeInt(-1000)
+
+        expect(result.bytes).toEqual(new Uint8Array([0x39, 0x03, 0xe7]))
+        expect(result.hex).toBe('3903e7')
+      })
+    })
+
+    describe('4-byte encoding', () => {
+      it('should encode -1000000', () => {
+        const { encodeNegativeInt } = useCborIntegerEncoder()
+        const result = encodeNegativeInt(-1000000)
+
+        expect(result.bytes).toEqual(new Uint8Array([0x3a, 0x00, 0x0f, 0x42, 0x3f]))
+        expect(result.hex).toBe('3a000f423f')
+      })
+    })
+
+    describe('Error cases', () => {
+      it('should reject positive values', () => {
+        const { encodeNegativeInt } = useCborIntegerEncoder()
+
+        expect(() => encodeNegativeInt(1)).toThrow('Cannot encode positive value as negative integer')
+      })
+
+      it('should reject zero', () => {
+        const { encodeNegativeInt } = useCborIntegerEncoder()
+
+        expect(() => encodeNegativeInt(0)).toThrow('Cannot encode positive value as negative integer')
+      })
+
+      it('should reject values < -2^64', () => {
+        const { encodeNegativeInt } = useCborIntegerEncoder()
+
+        expect(() => encodeNegativeInt(-18446744073709551617n)).toThrow('Value exceeds minimum negative integer (-2^64)')
+      })
+    })
+  })
+
+  describe('Auto-detect integer type', () => {
+    it('should encode positive integers', () => {
+      const { encodeInteger } = useCborIntegerEncoder()
+
+      expect(encodeInteger(0).hex).toBe('00')
+      expect(encodeInteger(100).hex).toBe('1864')
+      expect(encodeInteger(1000000).hex).toBe('1a000f4240')
+    })
+
+    it('should encode negative integers', () => {
+      const { encodeInteger } = useCborIntegerEncoder()
+
+      expect(encodeInteger(-1).hex).toBe('20')
+      expect(encodeInteger(-100).hex).toBe('3863')
+      expect(encodeInteger(-1000).hex).toBe('3903e7')
+    })
+  })
+})

package/src/encoder/__tests__/cbor-simple-encoder.test.ts

@@ -0,0 +1,224 @@
+/**
+ * CBOR Simple Values and Floats Encoder Test Suite
+ * Tests for Major Type 7 (Floats and Simple Values)
+ */
+
+import { describe, it, expect } from 'vitest'
+import { useCborSimpleEncoder } from '../composables/useCborSimpleEncoder'
+
+describe('CBOR Simple Values and Floats Encoder', () => {
+  describe('Simple Values', () => {
+    it('should encode false', () => {
+      const { encodeSimple } = useCborSimpleEncoder()
+      const result = encodeSimple(false)
+
+      expect(result.bytes).toEqual(new Uint8Array([0xf4]))
+      expect(result.hex).toBe('f4')
+    })
+
+    it('should encode true', () => {
+      const { encodeSimple } = useCborSimpleEncoder()
+      const result = encodeSimple(true)
+
+      expect(result.bytes).toEqual(new Uint8Array([0xf5]))
+      expect(result.hex).toBe('f5')
+    })
+
+    it('should encode null', () => {
+      const { encodeSimple } = useCborSimpleEncoder()
+      const result = encodeSimple(null)
+
+      expect(result.bytes).toEqual(new Uint8Array([0xf6]))
+      expect(result.hex).toBe('f6')
+    })
+
+    it('should encode undefined', () => {
+      const { encodeSimple } = useCborSimpleEncoder()
+      const result = encodeSimple(undefined)
+
+      expect(result.bytes).toEqual(new Uint8Array([0xf7]))
+      expect(result.hex).toBe('f7')
+    })
+  })
+
+  describe('Floating-Point Numbers', () => {
+    describe('Float16 (half precision)', () => {
+      it('should encode 0.0 as float16', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        const result = encodeFloat(0.0, 16)
+
+        // 0xf9 (float16) + 0x0000
+        expect(result.bytes).toEqual(new Uint8Array([0xf9, 0x00, 0x00]))
+        expect(result.hex).toBe('f90000')
+      })
+
+      it('should encode 1.0 as float16', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        const result = encodeFloat(1.0, 16)
+
+        // 0xf9 (float16) + 0x3c00
+        expect(result.bytes).toEqual(new Uint8Array([0xf9, 0x3c, 0x00]))
+        expect(result.hex).toBe('f93c00')
+      })
+
+      it('should encode -1.0 as float16', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        const result = encodeFloat(-1.0, 16)
+
+        // 0xf9 (float16) + 0xbc00
+        expect(result.bytes).toEqual(new Uint8Array([0xf9, 0xbc, 0x00]))
+        expect(result.hex).toBe('f9bc00')
+      })
+
+      it('should encode Infinity as float16', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        const result = encodeFloat(Infinity, 16)
+
+        // 0xf9 (float16) + 0x7c00
+        expect(result.bytes).toEqual(new Uint8Array([0xf9, 0x7c, 0x00]))
+        expect(result.hex).toBe('f97c00')
+      })
+
+      it('should encode -Infinity as float16', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        const result = encodeFloat(-Infinity, 16)
+
+        // 0xf9 (float16) + 0xfc00
+        expect(result.bytes).toEqual(new Uint8Array([0xf9, 0xfc, 0x00]))
+        expect(result.hex).toBe('f9fc00')
+      })
+
+      it('should encode NaN as float16', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        const result = encodeFloat(NaN, 16)
+
+        // 0xf9 (float16) + 0x7e00
+        expect(result.bytes).toEqual(new Uint8Array([0xf9, 0x7e, 0x00]))
+        expect(result.hex).toBe('f97e00')
+      })
+    })
+
+    describe('Float32 (single precision)', () => {
+      it('should encode 0.0 as float32', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        const result = encodeFloat(0.0, 32)
+
+        // 0xfa (float32) + 0x00000000
+        expect(result.bytes).toEqual(new Uint8Array([0xfa, 0x00, 0x00, 0x00, 0x00]))
+        expect(result.hex).toBe('fa00000000')
+      })
+
+      it('should encode 1.0 as float32', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        const result = encodeFloat(1.0, 32)
+
+        // 0xfa (float32) + 0x3f800000
+        expect(result.bytes).toEqual(new Uint8Array([0xfa, 0x3f, 0x80, 0x00, 0x00]))
+        expect(result.hex).toBe('fa3f800000')
+      })
+
+      it('should encode 3.4028234663852886e+38 (max float32)', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        const result = encodeFloat(3.4028234663852886e+38, 32)
+
+        // 0xfa (float32) + 0x7f7fffff
+        expect(result.bytes).toEqual(new Uint8Array([0xfa, 0x7f, 0x7f, 0xff, 0xff]))
+        expect(result.hex).toBe('fa7f7fffff')
+      })
+
+      it('should encode Infinity as float32', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        const result = encodeFloat(Infinity, 32)
+
+        // 0xfa (float32) + 0x7f800000
+        expect(result.bytes).toEqual(new Uint8Array([0xfa, 0x7f, 0x80, 0x00, 0x00]))
+        expect(result.hex).toBe('fa7f800000')
+      })
+    })
+
+    describe('Float64 (double precision)', () => {
+      it('should encode 0.0 as float64', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        const result = encodeFloat(0.0, 64)
+
+        // 0xfb (float64) + 0x0000000000000000
+        expect(result.bytes).toEqual(new Uint8Array([0xfb, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]))
+        expect(result.hex).toBe('fb0000000000000000')
+      })
+
+      it('should encode 1.1 as float64', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        const result = encodeFloat(1.1, 64)
+
+        // RFC 8949 Appendix A example
+        expect(result.bytes).toEqual(new Uint8Array([0xfb, 0x3f, 0xf1, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9a]))
+        expect(result.hex).toBe('fb3ff199999999999a')
+      })
+
+      it('should encode 1.0e+300 as float64', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        const result = encodeFloat(1.0e+300, 64)
+
+        // RFC 8949 Appendix A example
+        expect(result.bytes).toEqual(new Uint8Array([0xfb, 0x7e, 0x37, 0xe4, 0x3c, 0x88, 0x00, 0x75, 0x9c]))
+        expect(result.hex).toBe('fb7e37e43c8800759c')
+      })
+
+      it('should encode -4.1 as float64', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        const result = encodeFloat(-4.1, 64)
+
+        // RFC 8949 Appendix A example
+        expect(result.bytes).toEqual(new Uint8Array([0xfb, 0xc0, 0x10, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66]))
+        expect(result.hex).toBe('fbc010666666666666')
+      })
+
+      it('should encode Infinity as float64', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        const result = encodeFloat(Infinity, 64)
+
+        // 0xfb (float64) + 0x7ff0000000000000
+        expect(result.bytes).toEqual(new Uint8Array([0xfb, 0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]))
+        expect(result.hex).toBe('fb7ff0000000000000')
+      })
+
+      it('should encode NaN as float64', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        const result = encodeFloat(NaN, 64)
+
+        // 0xfb (float64) + NaN representation
+        expect(result.bytes[0]).toBe(0xfb)
+        expect(result.bytes.length).toBe(9)
+      })
+    })
+
+    describe('Auto-detect precision', () => {
+      it('should encode integer-like float as integer', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        const result = encodeFloat(100.0)
+
+        // Should use integer encoding if possible
+        // This is an optimization - float64 is also acceptable
+        expect(result.bytes[0]).toBe(0x18)  // Integer encoding
+        expect(result.bytes[1]).toBe(100)
+      })
+
+      it('should encode fractional number as smallest float', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        const result = encodeFloat(1.5)
+
+        // 1.5 can be represented in float16, float32, or float64
+        // Any of these are acceptable
+        expect([0xf9, 0xfa, 0xfb]).toContain(result.bytes[0])  // Float16, Float32, or Float64
+      })
+
+      it('should use float64 for high-precision numbers', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        const result = encodeFloat(1.1)
+
+        // 1.1 requires float64 for precision
+        expect(result.bytes[0]).toBe(0xfb)  // Float64
+      })
+    })
+  })
+})