@cloudpss/ubjson 0.3.6 → 0.3.9

package/tests/encode.js

@@ -0,0 +1,354 @@
+/**
+ * Tests from https://bitbucket.org/shelacek/ubjson
+ */
+
+import { encode, decode } from '../dist/index.js';
+
+/**
+ *
+ * @param {[ArrayBuffer] | [Uint8Array] | (number | string)[]} args
+ * @returns {number[]}
+ */
+function toArray(...args) {
+    if (args[0] instanceof ArrayBuffer) {
+        return Array.from(new Uint8Array(args[0]));
+    }
+    if (args[0] instanceof Uint8Array) {
+        return Array.from(args[0]);
+    }
+    return args.map((x) => (typeof x == 'number' ? x : /** @type {string} */ (x).charCodeAt(0)));
+}
+
+test('encode function', () => {
+    expect(() => encode(function () {})).toThrow();
+});
+
+test('encode bigint', () => {
+    expect(() => encode(1n)).toThrow();
+});
+
+test('encode symbol', () => {
+    expect(() => encode(Symbol('sym'))).toThrow();
+});
+
+test('encode undefined', () => {
+    expect(toArray(encode(undefined))).toEqual(toArray('N'));
+});
+
+test('encode null', () => {
+    expect(toArray(encode(null))).toEqual(toArray('Z'));
+});
+
+test('encode true', () => {
+    expect(toArray(encode(true))).toEqual(toArray('T'));
+});
+
+test('encode false', () => {
+    expect(toArray(encode(false))).toEqual(toArray('F'));
+});
+
+test('encode int8', () => {
+    expect(toArray(encode(-1))).toEqual(toArray('i', 255));
+});
+
+test('encode uint8', () => {
+    expect(toArray(encode(200))).toEqual(toArray('U', 200));
+});
+
+test('encode int16', () => {
+    expect(toArray(encode(0x1234))).toEqual(toArray('I', 0x12, 0x34));
+});
+
+test('encode int32', () => {
+    expect(toArray(encode(0x12345678))).toEqual(toArray('l', 0x12, 0x34, 0x56, 0x78));
+});
+
+test('encode float32', () => {
+    expect(toArray(encode(1.00390625))).toEqual(toArray('d', 0x3f, 0x80, 0x80, 0x00));
+});
+
+test('encode float32 (too large integer)', () => {
+    expect(toArray(encode(2147483648))).toEqual(toArray('d', 0x4f, 0x00, 0x00, 0x00));
+});
+
+test('encode float64', () => {
+    expect(toArray(encode(100000.00390625))).toEqual(toArray('D', 0x40, 0xf8, 0x6a, 0x00, 0x10, 0x00, 0x00, 0x00));
+});
+
+test('encode char', () => {
+    expect(toArray(encode('a'))).toEqual(toArray('C', 'a'));
+});
+
+test('encode char 128', () => {
+    expect(toArray(encode('\xcc'))).toEqual(toArray('C', '\xcc'));
+});
+
+test('encode char 257', () => {
+    expect(toArray(encode('\u0123'))).toEqual(toArray('S', 'i', 2, 196, 163));
+});
+
+test('encode char emoji', () => {
+    expect(toArray(encode('💖'))).toEqual(toArray('S', 'i', 4, 240, 159, 146, 150));
+});
+
+test('encode string', () => {
+    expect(toArray(encode('ubjson'))).toEqual(toArray('S', 'i', 6, 'u', 'b', 'j', 's', 'o', 'n'));
+});
+
+test('encode string (no encodeInto)', () => {
+    const encodeInto = TextEncoder.prototype.encodeInto;
+    // @ts-ignore
+    TextEncoder.prototype.encodeInto = undefined;
+    expect(toArray(encode('ubjson'))).toEqual(toArray('S', 'i', 6, 'u', 'b', 'j', 's', 'o', 'n'));
+
+    TextEncoder.prototype.encodeInto = encodeInto;
+});
+
+test('encode array', () => {
+    expect(toArray(encode([1, 2, 3, -1]))).toEqual(toArray('[', 'U', 1, 'U', 2, 'U', 3, 'i', 255, ']'));
+});
+
+test('encode array (empty)', () => {
+    expect(toArray(encode([]))).toEqual(toArray('[', ']'));
+});
+
+test('encode array (undefined)', () => {
+    expect(toArray(encode([undefined]))).toEqual(toArray('[', 'Z', ']'));
+});
+
+test('encode array (spares)', () => {
+    const array = new Array(3);
+    array[1] = true;
+    expect(toArray(encode(array))).toEqual(toArray('[', 'Z', 'T', 'Z', ']'));
+});
+
+test('encode array (mixed)', () => {
+    expect(toArray(encode([1, 'a', true]))).toEqual(toArray('[', 'U', 1, 'C', 'a', 'T', ']'));
+});
+
+test('encode array (int8)', () => {
+    expect(toArray(encode([-1, 2, 3]))).toEqual(toArray('[', 'i', 255, 'U', 2, 'U', 3, ']'));
+});
+
+test('encode array (int16)', () => {
+    expect(toArray(encode([255, -1]))).toEqual(toArray('[', 'U', 0xff, 'i', 0xff, ']'));
+});
+
+test('encode array (only null values)', () => {
+    expect(toArray(encode([null, null, null]))).toEqual(toArray('[', 'Z', 'Z', 'Z', ']'));
+});
+
+test('encode N-D array', () => {
+    expect(
+        decode(
+            encode([
+                [1, 2, 3],
+                [4, 5, 6],
+            ]),
+        ),
+    ).toEqual([
+        [1, 2, 3],
+        [4, 5, 6],
+    ]);
+});
+
+test('encode array of objects', () => {
+    expect(
+        decode(
+            encode([
+                { a: 1, b: 2, c: 3 },
+                { d: 4, e: 5, f: 6 },
+            ]),
+        ),
+    ).toEqual([
+        { a: 1, b: 2, c: 3 },
+        { d: 4, e: 5, f: 6 },
+    ]);
+});
+
+test('encode array of objects of arrays', () => {
+    expect(
+        decode(
+            encode([
+                { a: [1, 2], b: [3, 4] },
+                { c: [5, 6], d: [7, 8] },
+            ]),
+        ),
+    ).toEqual([
+        { a: [1, 2], b: [3, 4] },
+        { c: [5, 6], d: [7, 8] },
+    ]);
+});
+
+test('encode array (int8 typed array)', () => {
+    expect(toArray(encode(Int8Array.from([18, -2])))).toEqual(toArray('[', '$', 'i', '#', 'i', 2, 0x12, 0xfe));
+});
+
+test('encode array (uint8 typed array)', () => {
+    expect(toArray(encode(Uint8Array.from([18, 254])))).toEqual(toArray('[', '$', 'U', '#', 'i', 2, 0x12, 0xfe));
+});
+
+test('encode array (int16 typed array)', () => {
+    expect(toArray(encode(Int16Array.from([4660, -292])))).toEqual(
+        toArray('[', '$', 'I', '#', 'i', 2, 0x12, 0x34, 0xfe, 0xdc),
+    );
+});
+
+test('encode array (int32 typed array)', () => {
+    expect(toArray(encode(Int32Array.from([305419896, -19088744])))).toEqual(
+        toArray('[', '$', 'l', '#', 'i', 2, 0x12, 0x34, 0x56, 0x78, 0xfe, 0xdc, 0xba, 0x98),
+    );
+});
+
+test('encode array (float32 typed array)', () => {
+    expect(toArray(encode(Float32Array.from([0.25, 0.125])))).toEqual(
+        toArray('[', '$', 'd', '#', 'i', 2, 0x3e, 0x80, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00),
+    );
+});
+
+test('encode array (float64 typed array)', () => {
+    expect(toArray(encode(Float64Array.from([0.25, 0.125])))).toEqual(
+        toArray(
+            '[',
+            '$',
+            'D',
+            '#',
+            'i',
+            2,
+            0x3f,
+            0xd0,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x3f,
+            0xc0,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+        ),
+    );
+});
+
+test('encode array (uint8clamped typed array)', () => {
+    expect(() => encode(new Uint8ClampedArray())).toThrow();
+});
+
+test('encode array (uint16 typed array)', () => {
+    expect(() => encode(new Uint16Array())).toThrow();
+});
+
+test('encode array (uint32 typed array)', () => {
+    expect(() => encode(new Uint32Array())).toThrow();
+});
+
+test('encode array (uint64 typed array)', () => {
+    expect(() => encode(new BigUint64Array())).toThrow();
+});
+
+test('encode array (int64 typed array)', () => {
+    expect(() => encode(new BigInt64Array())).toThrow();
+});
+
+test('encode object', () => {
+    expect(toArray(encode({ a: 1, b: 2, c: 3 }))).toEqual(
+        toArray('{', 'i', 1, 'a', 'U', 1, 'i', 1, 'b', 'U', 2, 'i', 1, 'c', 'U', 3, '}'),
+    );
+});
+
+test('encode object (empty)', () => {
+    expect(toArray(encode({}))).toEqual(toArray('{', '}'));
+});
+
+test('encode object (empty key)', () => {
+    expect(toArray(encode({ '': '' }))).toEqual(toArray('{', 'i', 0, 'S', 'i', 0, '}'));
+});
+
+test('encode object (mixed)', () => {
+    expect(toArray(encode({ a: 1, b: 'a', c: true }))).toEqual(
+        toArray('{', 'i', 1, 'a', 'U', 1, 'i', 1, 'b', 'C', 'a', 'i', 1, 'c', 'T', '}'),
+    );
+});
+
+test('encode object (only null values)', () => {
+    expect(toArray(encode({ a: null, b: null, c: null }))).toEqual(
+        toArray('{', 'i', 1, 'a', 'Z', 'i', 1, 'b', 'Z', 'i', 1, 'c', 'Z', '}'),
+    );
+});
+
+test('encode object (skip prototype)', () => {
+    const obj = Object.create({ a: 2, x: 'xx' });
+    obj.a = 1;
+    obj.b = 'a';
+    obj.c = true;
+    expect(toArray(encode(obj))).toEqual(
+        toArray('{', 'i', 1, 'a', 'U', 1, 'i', 1, 'b', 'C', 'a', 'i', 1, 'c', 'T', '}'),
+    );
+});
+
+test('encode object (skip symbol)', () => {
+    const obj = { [Symbol()]: true, a: 1 };
+    expect(toArray(encode(obj))).toEqual(toArray('{', 'i', 1, 'a', 'U', 1, '}'));
+});
+
+test('encode object (skip non-enumerable)', () => {
+    const obj = {};
+    Object.defineProperty(obj, 'a', { value: 1, configurable: true, writable: true });
+    expect(toArray(encode(obj))).toEqual(toArray('{', '}'));
+});
+
+test('encode object (include getter)', () => {
+    const obj = {};
+    Object.defineProperty(obj, 'a', { get: () => 1, enumerable: true });
+    expect(toArray(encode(obj))).toEqual(toArray('{', 'i', 1, 'a', 'U', 1, '}'));
+});
+
+test('encode object (skip undefined)', () => {
+    const obj = { a: undefined };
+    expect(toArray(encode(obj))).toEqual(toArray('{', '}'));
+});
+
+test('encode object (function) [error]', () => {
+    const obj = { a: () => {} };
+    expect(() => encode(obj)).toThrow(/Unsupported type \[object Function\]/);
+});
+
+test('encode object (include null)', () => {
+    const obj = { a: null };
+    expect(toArray(encode(obj))).toEqual(toArray('{', 'i', 1, 'a', 'Z', '}'));
+});
+
+test('encode huge typed array (16K)', () => {
+    const obj = new Uint8Array(16 * 1024);
+    expect(toArray(encode(obj).slice(0, 8))).toEqual(toArray('[', '$', 'U', '#', 'I', 0x40, 0x00, 0));
+});
+
+test('encode huge typed array (~128M)', () => {
+    const obj = new Uint8Array(128 * 1024 * 1024 - 10);
+    expect(toArray(encode(obj).slice(0, 10))).toEqual(toArray('[', '$', 'U', '#', 'l', 0x7, 0xff, 0xff, 0xf6, 0));
+});
+
+test('encode huge typed array (128M) [error]', () => {
+    const obj = new Uint8Array(128 * 1024 * 1024);
+    expect(() => encode(obj)).toThrow(/Buffer has exceed max size/);
+});
+
+test('encode huge typed array (3G) [error]', () => {
+    const obj = new Uint8Array(3 * 1024 * 1024 * 1024);
+    expect(() => encode(obj)).toThrow(/Buffer has exceed max size/);
+});
+
+test('encode huge data (~128M)', () => {
+    const obj = [new Uint8Array(128 * 1024 * 1024 - 20)];
+    expect(toArray(encode(obj).slice(0, 11))).toEqual(toArray('[', '[', '$', 'U', '#', 'l', 0x7, 0xff, 0xff, 0xec, 0));
+});
+
+test('encode huge data (128M) [error]', () => {
+    const obj = [new Uint8Array(128 * 1024 * 1024)];
+    expect(() => encode(obj)).toThrow(/Buffer has exceed max size/);
+});