SnowLuma v2.4.2 source snapshot

packages/proton/test/upstream/codegen/buffer.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it } from 'vitest';
+import { schemaCodecs } from '../schema';
+
+const bytesSchema = 'interface Msg { data: pb<1,bytes>; }';
+
+describe('encoded buffers', () => {
+    it('round-trips messages around allocation and slab boundaries', () => {
+        const codec = schemaCodecs<{ data: Uint8Array }>(bytesSchema);
+
+        for (const length of [
+            0, 1, 61, 62, 63, 64, 65, 125, 127, 128, 4092, 4093, 4094, 4095, 4096, 8192,
+        ]) {
+            const data = Uint8Array.from({ length }, (_, i) => (i * 13) & 255);
+            const encoded = codec.encode({ data });
+            expect(codec.decode(encoded)).toEqual({ data });
+
+            if (encoded.length <= 64 || encoded.length > 4096) {
+                expect(encoded.byteOffset).toBe(0);
+                expect(encoded.buffer.byteLength).toBe(encoded.length);
+            }
+        }
+    });
+
+    it('keeps retained results intact across slab rotation and subsequent mutations', () => {
+        const codec = schemaCodecs<{ data: Uint8Array }>(bytesSchema);
+        const retained = Array.from({ length: 200 }, (_, index) => {
+            const data = new Uint8Array([63, 128, 800, 1300][index % 4]).fill(index);
+            const encoded = codec.encode({ data });
+            return { data, encoded, snapshot: encoded.slice() };
+        });
+        expect(retained.some(({ encoded }) => encoded.byteOffset > 0)).toBe(true);
+
+        for (const { data, encoded, snapshot } of retained) {
+            expect(encoded).toEqual(snapshot);
+            expect(codec.decode(encoded)).toEqual({ data });
+        }
+
+        retained[0].encoded.fill(0);
+
+        for (const { encoded, snapshot } of retained.slice(1)) {
+            expect(encoded).toEqual(snapshot);
+        }
+    });
+
+    it('supports encoding from a getter without reusing the inner result', () => {
+        const codec = schemaCodecs<{ data: Uint8Array }>(bytesSchema);
+        const inner = new Uint8Array(128).fill(7);
+        const outer = new Uint8Array(256).fill(9);
+        let nested: Uint8Array | undefined;
+        const encoded = codec.encode({
+            get data() {
+                nested = codec.encode({ data: inner });
+                return outer;
+            },
+        });
+        expect(codec.decode(encoded)).toEqual({ data: outer });
+        expect(codec.decode(nested!)).toEqual({ data: inner });
+    });
+
+    it('replaces a slab whose backing buffer was transferred', () => {
+        const codec = schemaCodecs<{ data: Uint8Array }>(bytesSchema);
+        const data = new Uint8Array(128).fill(3);
+        const first = codec.encode({ data });
+        const transferred = structuredClone(first, { transfer: [first.buffer as ArrayBuffer] });
+        expect(first.byteLength).toBe(0);
+        expect(codec.decode(transferred)).toEqual({ data });
+        expect(codec.decode(codec.encode({ data }))).toEqual({ data });
+    });
+
+    it('decodes unaligned pooled messages containing strings, fixed values and nested data', () => {
+        const codec = schemaCodecs<{
+            text: string;
+            ratio: number;
+            inner: { value: bigint; data: Uint8Array };
+        }>(`
+      interface Inner {value:pb<1,fixed_64>;data:pb<2,bytes>;}
+      interface Msg {text:pb<1,string>;ratio:pb<2,double>;inner:pb<3,Inner>;}
+    `);
+        let unaligned = false;
+
+        for (let i = 0; i < 100; i++) {
+            const value = {
+                text: '中文🚀'.repeat(8) + i,
+                ratio: Math.PI + i,
+                inner: { value: (1n << 63n) + BigInt(i), data: new Uint8Array(17 + i).fill(i) },
+            };
+            const encoded = codec.encode(value);
+            unaligned ||= encoded.byteOffset % 8 !== 0;
+            expect(codec.decode(encoded)).toEqual(value);
+        }
+
+        expect(unaligned).toBe(true);
+    });
+});