@cloudpss/ubjson 0.3.0-alpha.21

package/test/decode.js

@@ -0,0 +1,423 @@
+/**
+ * Tests from https://bitbucket.org/shelacek/ubjson
+ */
+
+import test from 'tape';
+import * as ubjson from '../dist/index.js';
+
+function toBuffer(...args) {
+    return Uint8Array.from(args, (x) => (x === +x ? x : x.charCodeAt()));
+}
+
+test('decode unsupported type', (t) => {
+    t.throws(() => ubjson.decode(toBuffer('!')));
+    t.end();
+});
+
+test('decode undefined data', (t) => {
+    t.throws(() => ubjson.decode(undefined));
+    t.end();
+});
+
+test('decode undefined', (t) => {
+    t.equal(ubjson.decode(toBuffer('N')), undefined);
+    t.end();
+});
+
+test('decode undefined (multiple noop)', (t) => {
+    t.equal(ubjson.decode(toBuffer('N', 'N', 'N')), undefined);
+    t.end();
+});
+
+test('decode undefined (empty buffer)', (t) => {
+    t.equal(ubjson.decode(toBuffer()), undefined);
+    t.end();
+});
+
+test('decode null', (t) => {
+    t.equal(ubjson.decode(toBuffer('Z')), null);
+    t.end();
+});
+
+test('decode true', (t) => {
+    t.equal(ubjson.decode(toBuffer('T')), true);
+    t.end();
+});
+
+test('decode false', (t) => {
+    t.equal(ubjson.decode(toBuffer('F')), false);
+    t.end();
+});
+
+test('decode int8', (t) => {
+    t.equal(ubjson.decode(toBuffer('i', 100)), 100);
+    t.end();
+});
+
+test('decode uint8', (t) => {
+    t.equal(ubjson.decode(toBuffer('U', 200)), 200);
+    t.end();
+});
+
+test('decode int16', (t) => {
+    t.equal(ubjson.decode(toBuffer('I', 0x12, 0x34)), 0x1234);
+    t.end();
+});
+
+test('decode int32', (t) => {
+    t.equal(ubjson.decode(toBuffer('l', 0x12, 0x34, 0x56, 0x78)), 0x12345678);
+    t.end();
+});
+
+test('decode int64 [error]', (t) => {
+    t.throws(() => ubjson.decode(toBuffer('L', 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0)));
+    t.end();
+});
+
+test('decode float32', (t) => {
+    t.equal(ubjson.decode(toBuffer('d', 0x3f, 0x80, 0x80, 0x00)), 1.00390625);
+    t.end();
+});
+
+test('decode float64', (t) => {
+    t.equal(ubjson.decode(toBuffer('D', 0x40, 0xf8, 0x6a, 0x00, 0x10, 0x00, 0x00, 0x00)), 100000.00390625);
+    t.end();
+});
+
+test('decode high-precision number [error]', (t) => {
+    t.throws(() => ubjson.decode(toBuffer('H', 'i', 3, '1', '.', '1')));
+    t.end();
+});
+
+test('decode char', (t) => {
+    t.equal(ubjson.decode(toBuffer('C', 'a')), 'a');
+    t.end();
+});
+
+test('decode string', (t) => {
+    t.equal(ubjson.decode(toBuffer('S', 'i', 6, 'u', 'b', 'j', 's', 'o', 'n')), 'ubjson');
+    t.end();
+});
+
+test('decode array', (t) => {
+    t.deepEqual(ubjson.decode(toBuffer('[', 'i', 1, 'i', 2, 'i', 3, ']')), [1, 2, 3]);
+    t.end();
+});
+
+test('decode array (with no-op)', (t) => {
+    t.deepEqual(ubjson.decode(toBuffer('[', 'i', 1, 'N', 'i', 2, 'i', 3, 'N', ']')), [1, 2, 3]);
+    t.end();
+});
+
+test('decode array (empty, optimized)', (t) => {
+    t.deepEqual(ubjson.decode(toBuffer('[', '#', 'i', 0)), []);
+    t.end();
+});
+
+test('decode array (mixed, optimized)', (t) => {
+    t.deepEqual(ubjson.decode(toBuffer('[', '#', 'i', 3, 'i', 1, 'C', 'a', 'T')), [1, 'a', true]);
+    t.end();
+});
+
+test('decode array (strongly typed, optimized)', (t) => {
+    t.deepEqual(ubjson.decode(toBuffer('[', '$', 'i', '#', 'i', 3, 1, 2, 3)), new Int8Array([1, 2, 3]));
+    t.end();
+});
+
+test('decode array (strongly typed, empty, optimized)', (t) => {
+    t.deepEqual(ubjson.decode(toBuffer('[', '$', 'i', '#', 'i', 0)), new Int8Array([]));
+    t.end();
+});
+
+test('decode N-D array (strongly typed, optimized)', (t) => {
+    t.deepEqual(
+        ubjson.decode(
+            toBuffer('[', '$', '[', '#', 'i', 2, '$', 'i', '#', 'i', 3, 1, 2, 3, '$', 'i', '#', 'i', 3, 4, 5, 6),
+        ),
+        [new Int8Array([1, 2, 3]), new Int8Array([4, 5, 6])],
+    );
+    t.end();
+});
+
+test('decode array of objects (optimized)', (t) => {
+    t.deepEqual(
+        ubjson.decode(
+            toBuffer(
+                '[',
+                '$',
+                '{',
+                '#',
+                'i',
+                2,
+                '$',
+                'i',
+                '#',
+                'i',
+                3,
+                'i',
+                1,
+                'a',
+                1,
+                'i',
+                1,
+                'b',
+                2,
+                'i',
+                1,
+                'c',
+                3,
+                '$',
+                'i',
+                '#',
+                'i',
+                3,
+                'i',
+                1,
+                'd',
+                4,
+                'i',
+                1,
+                'e',
+                5,
+                'i',
+                1,
+                'f',
+                6,
+            ),
+        ),
+        [
+            { a: 1, b: 2, c: 3 },
+            { d: 4, e: 5, f: 6 },
+        ],
+    );
+    t.end();
+});
+
+test('decode array of objects of arrays (optimized)', (t) => {
+    t.deepEqual(
+        ubjson.decode(
+            toBuffer(
+                '[',
+                '$',
+                '{',
+                '#',
+                'i',
+                2,
+                '$',
+                '[',
+                '#',
+                'i',
+                2,
+                'i',
+                1,
+                'a',
+                '$',
+                'i',
+                '#',
+                'i',
+                2,
+                1,
+                2,
+                'i',
+                1,
+                'b',
+                '$',
+                'i',
+                '#',
+                'i',
+                2,
+                3,
+                4,
+                '$',
+                '[',
+                '#',
+                'i',
+                2,
+                'i',
+                1,
+                'c',
+                '$',
+                'i',
+                '#',
+                'i',
+                2,
+                5,
+                6,
+                'i',
+                1,
+                'd',
+                '$',
+                'i',
+                '#',
+                'i',
+                2,
+                7,
+                8,
+            ),
+        ),
+        [
+            { a: new Int8Array([1, 2]), b: new Int8Array([3, 4]) },
+            { c: new Int8Array([5, 6]), d: new Int8Array([7, 8]) },
+        ],
+    );
+    t.end();
+});
+
+test('decode array (strongly typed, unexpected eof, optimized)', (t) => {
+    t.throws(() => ubjson.decode(toBuffer('[', '$', 'i', '#', 'i', 3, 1, 2)));
+    t.end();
+});
+
+test('decode array (strongly typed, invalid length value, optimized)', (t) => {
+    t.throws(() => ubjson.decode(toBuffer('[', '$', 'i', '#', 'i', -1)));
+    t.end();
+});
+
+test('decode array (strongly typed, invalid length type, optimized)', (t) => {
+    t.throws(() => ubjson.decode(toBuffer('[', '$', 'i', '#', 'C', '0')));
+    t.end();
+});
+
+test('decode array (strongly typed, malformed, optimized)', (t) => {
+    t.throws(() => ubjson.decode(toBuffer('[', '$', 'i', 1, 2, 3, ']')));
+    t.end();
+});
+
+test('decode array (only null values, optimized)', (t) => {
+    t.deepEqual(ubjson.decode(toBuffer('[', '$', 'Z', '#', 'i', 3)), [null, null, null]);
+    t.end();
+});
+
+test('decode array (only true values, optimized)', (t) => {
+    t.deepEqual(ubjson.decode(toBuffer('[', '$', 'T', '#', 'i', 3)), [true, true, true]);
+    t.end();
+});
+
+test('decode array (only false values, optimized)', (t) => {
+    t.deepEqual(ubjson.decode(toBuffer('[', '$', 'F', '#', 'i', 3)), [false, false, false]);
+    t.end();
+});
+
+test('decode array (int8, strongly typed, optimized) [use typed array]', (t) => {
+    const actual = ubjson.decode(toBuffer('[', '$', 'i', '#', 'i', 2, 0x12, 0xfe), { useTypedArrays: true });
+    t.assert(actual.constructor.name === 'Int8Array');
+    t.deepEqual(actual, Int8Array.from([18, -2]));
+    t.end();
+});
+
+test('decode array (uint8, strongly typed, optimized) [use typed array]', (t) => {
+    const actual = ubjson.decode(toBuffer('[', '$', 'U', '#', 'i', 2, 0x12, 0xfe), { useTypedArrays: true });
+    t.assert(actual.constructor.name === 'Uint8Array');
+    t.deepEqual(actual, Uint8Array.from([18, 254]));
+    t.end();
+});
+
+test('decode array (int16, strongly typed, optimized) [use typed array]', (t) => {
+    const actual = ubjson.decode(toBuffer('[', '$', 'I', '#', 'i', 2, 0x12, 0x34, 0xfe, 0xdc), {
+        useTypedArrays: true,
+    });
+    t.assert(actual.constructor.name === 'Int16Array');
+    t.deepEqual(actual, Int16Array.from([4660, -292]));
+    t.end();
+});
+
+test('decode array (int32, strongly typed, optimized) [use typed array]', (t) => {
+    const actual = ubjson.decode(toBuffer('[', '$', 'l', '#', 'i', 2, 0x12, 0x34, 0x56, 0x78, 0xfe, 0xdc, 0xba, 0x98), {
+        useTypedArrays: true,
+    });
+    t.assert(actual.constructor.name === 'Int32Array');
+    t.deepEqual(actual, Int32Array.from([305419896, -19088744]));
+    t.end();
+});
+
+test('decode array (float32, strongly typed, optimized) [use typed array]', (t) => {
+    const actual = ubjson.decode(toBuffer('[', '$', 'd', '#', 'i', 2, 0x3e, 0x80, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00), {
+        useTypedArrays: true,
+    });
+    t.assert(actual.constructor.name === 'Float32Array');
+    t.deepEqual(actual, Float32Array.from([0.25, 0.125]));
+    t.end();
+});
+
+test('decode array (float64, strongly typed, optimized) [use typed array]', (t) => {
+    const actual = ubjson.decode(
+        toBuffer(
+            '[',
+            '$',
+            'D',
+            '#',
+            'i',
+            2,
+            0x3f,
+            0xd0,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x3f,
+            0xc0,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+        ),
+        { useTypedArrays: true },
+    );
+    t.assert(actual.constructor.name === 'Float64Array');
+    t.deepEqual(actual, Float64Array.from([0.25, 0.125]));
+    t.end();
+});
+
+test('decode object', (t) => {
+    t.deepEqual(ubjson.decode(toBuffer('{', 'i', 1, 'a', 'i', 1, 'i', 1, 'b', 'i', 2, 'i', 1, 'c', 'i', 3, '}')), {
+        a: 1,
+        b: 2,
+        c: 3,
+    });
+    t.end();
+});
+
+test('decode object (with no-op)', (t) => {
+    t.deepEqual(
+        ubjson.decode(
+            toBuffer('N', '{', 'N', 'i', 1, 'a', 'i', 1, 'i', 1, 'b', 'N', 'i', 2, 'i', 1, 'c', 'i', 3, 'N', '}', 'N'),
+        ),
+        { a: 1, b: 2, c: 3 },
+    );
+    t.end();
+});
+
+test('decode array (empty, optimized)', (t) => {
+    t.deepEqual(ubjson.decode(toBuffer('{', '#', 'i', 0)), {});
+    t.end();
+});
+
+test('decode object (mixed, optimized)', (t) => {
+    t.deepEqual(
+        ubjson.decode(toBuffer('{', '#', 'i', 3, 'i', 1, 'a', 'i', 1, 'i', 1, 'b', 'C', 'a', 'i', 1, 'c', 'T')),
+        { a: 1, b: 'a', c: true },
+    );
+    t.end();
+});
+
+test('decode object (strongly typed, optimized)', (t) => {
+    t.deepEqual(ubjson.decode(toBuffer('{', '$', 'i', '#', 'i', 3, 'i', 1, 'a', 1, 'i', 1, 'b', 2, 'i', 1, 'c', 3)), {
+        a: 1,
+        b: 2,
+        c: 3,
+    });
+    t.end();
+});
+
+test('decode object (only null values, optimized)', (t) => {
+    t.deepEqual(ubjson.decode(toBuffer('{', '$', 'Z', '#', 'i', 3, 'i', 1, 'a', 'i', 1, 'b', 'i', 1, 'c')), {
+        a: null,
+        b: null,
+        c: null,
+    });
+    t.end();
+});

package/test/e2e.js

@@ -0,0 +1,134 @@
+/**
+ * Tests from https://bitbucket.org/shelacek/ubjson
+ */
+
+import test from 'tape';
+import * as ubjson from '../dist/index.js';
+
+test('encode/decode complex object', (t) => {
+    const expected = {
+        hello: 'world',
+        from: ['UBJSON'],
+        colors: [[255, 255, 255], [0, 0, 0], [64, 64, 96], new Uint8Array([255, 0, 1, 2, 3, 127])],
+        domains: {
+            com: 'commercial',
+            org: 'organization',
+            net: 'network',
+        },
+        entires: [
+            {
+                id: 1,
+                name: 'test',
+                content: null,
+                timestamp: 1532432408.008,
+                published: false,
+            },
+            {
+                id: 2,
+                name: 'lorem',
+                content: 'Lorem ipsum...',
+                timestamp: 1532432416.346,
+                published: true,
+            },
+        ],
+        plots: {
+            traces: [
+                {
+                    name: 'test',
+                    x: new Float64Array([1, 2, 3, -Infinity, Infinity, NaN, Number.MAX_VALUE, Number.MIN_VALUE]),
+                    y: new Int8Array([0, 4, 5, 6, -128, -1, 127]),
+                },
+                {
+                    name: 'test2',
+                    x: new Float32Array([1, 2, 3, -Infinity, Infinity, NaN, Number.MAX_VALUE, Number.MIN_VALUE]),
+                    y: new Int16Array([4, 5, 6, -32768, 32767]),
+                },
+                {
+                    name: 'test233',
+                    x: new Int32Array([1, 2, 3, 0, -1]),
+                    y: new Int32Array([4, 5, 6, -(2 ** 31), 2 ** 31 - 1]),
+                },
+            ],
+        },
+        description1: 'medium text'.repeat(100),
+        description2: 'medium text'.repeat(1000),
+        document1: 'long text'.repeat(10000),
+        document2: 'long text'.repeat(100000),
+    };
+    const encoded = ubjson.encode(expected);
+    const actual = ubjson.decode(encoded);
+    t.deepEqual(actual, expected);
+    t.end();
+});
+
+test('encode/decode complex object (no encodeInto)', (t) => {
+    const encodeInto = TextEncoder.prototype.encodeInto;
+    TextEncoder.prototype.encodeInto = undefined;
+    const expected = {
+        hello: 'world',
+        from: ['UBJSON'],
+        colors: [[255, 255, 255], [0, 0, 0], [64, 64, 96], new Uint8Array([255, 0, 1, 2, 3, 127])],
+        domains: {
+            com: 'commercial',
+            org: 'organization',
+            net: 'network',
+        },
+        entires: [
+            {
+                id: 1,
+                name: 'test',
+                content: null,
+                timestamp: 1532432408.008,
+                published: false,
+            },
+            {
+                id: 2,
+                name: 'lorem',
+                content: 'Lorem ipsum...',
+                timestamp: 1532432416.346,
+                published: true,
+            },
+        ],
+        plots: {
+            traces: [
+                {
+                    name: 'test',
+                    x: new Float64Array([1, 2, 3, -Infinity, Infinity, NaN, Number.MAX_VALUE, Number.MIN_VALUE]),
+                    y: new Int8Array([0, 4, 5, 6, -128, -1, 127]),
+                },
+                {
+                    name: 'test2',
+                    x: new Float32Array([1, 2, 3, -Infinity, Infinity, NaN, Number.MAX_VALUE, Number.MIN_VALUE]),
+                    y: new Int16Array([4, 5, 6, -32768, 32767]),
+                },
+                {
+                    name: 'test233',
+                    x: new Int32Array([1, 2, 3, 0, -1]),
+                    y: new Int32Array([4, 5, 6, -(2 ** 31), 2 ** 31 - 1]),
+                },
+            ],
+        },
+        description1: 'medium text'.repeat(100),
+        description2: 'medium text'.repeat(1000),
+        document1: 'long text'.repeat(10000),
+        document2: 'long text'.repeat(100000),
+    };
+    const encoded = ubjson.encode(expected);
+    const actual = ubjson.decode(encoded);
+    t.deepEqual(actual, expected);
+    t.end();
+    TextEncoder.prototype.encodeInto = encodeInto;
+});
+
+test('encode/decode large array', (t) => {
+    t.deepEqual(ubjson.decode(ubjson.encode(new Array(100000))), Array.from({ length: 100000 }).fill(null));
+    t.end();
+});
+
+test('encode/decode object with undefined values', (t) => {
+    t.deepEqual(ubjson.decode(ubjson.encode({ a: 1, b: undefined, c: { d: 2, e: undefined, f: null } })), {
+        a: 1,
+        c: { d: 2, f: null },
+    });
+    t.end();
+});