@cloudpss/ubjson 0.3.5 → 0.3.8

package/tests/decode.js

@@ -0,0 +1,433 @@
+/**
+ * Tests from https://bitbucket.org/shelacek/ubjson
+ */
+
+import { decode } from '../dist/index.js';
+
+/**
+ * @param  {...string | number} args
+ * @returns {Uint8Array}
+ */
+function toBuffer(...args) {
+    return Uint8Array.from(args, (x) => (typeof x == 'number' ? x : x.charCodeAt(0)));
+}
+
+test('decode unsupported type', () => {
+    expect(() => decode(toBuffer('!'))).toThrow();
+});
+
+test('decode undefined data', () => {
+    // @ts-expect-error
+    expect(() => decode(undefined)).toThrow();
+});
+
+test('decode undefined', () => {
+    expect(decode(toBuffer('N'))).toBeUndefined();
+});
+
+test('decode undefined (multiple noop)', () => {
+    expect(decode(toBuffer('N', 'N', 'N'))).toBeUndefined();
+});
+
+test('decode undefined (empty buffer)', () => {
+    expect(decode(toBuffer())).toBeUndefined();
+});
+
+test('decode null', () => {
+    expect(decode(toBuffer('Z'))).toBeNull();
+});
+
+test('decode true', () => {
+    expect(decode(toBuffer('T'))).toBe(true);
+});
+
+test('decode false', () => {
+    expect(decode(toBuffer('F'))).toBe(false);
+});
+
+test('decode int8', () => {
+    expect(decode(toBuffer('i', 100))).toBe(100);
+});
+
+test('decode uint8', () => {
+    expect(decode(toBuffer('U', 200))).toBe(200);
+});
+
+test('decode int16', () => {
+    expect(decode(toBuffer('I', 0x12, 0x34))).toBe(0x1234);
+});
+
+test('decode int32', () => {
+    expect(decode(toBuffer('l', 0x12, 0x34, 0x56, 0x78))).toBe(0x12345678);
+});
+
+test('decode int64 [error]', () => {
+    expect(() => decode(toBuffer('L', 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0))).toThrow();
+});
+
+test('decode float32', () => {
+    expect(decode(toBuffer('d', 0x3f, 0x80, 0x80, 0x00))).toBe(1.00390625);
+});
+
+test('decode float64', () => {
+    expect(decode(toBuffer('D', 0x40, 0xf8, 0x6a, 0x00, 0x10, 0x00, 0x00, 0x00))).toBe(100000.00390625);
+});
+
+test('decode high-precision number [error]', () => {
+    expect(() => decode(toBuffer('H', 'i', 3, '1', '.', '1'))).toThrow();
+});
+
+test('decode char', () => {
+    expect(decode(toBuffer('C', 'a'))).toBe('a');
+});
+
+test('decode string', () => {
+    expect(decode(toBuffer('S', 'i', 6, 'u', 'b', 'j', 's', 'o', 'n'))).toBe('ubjson');
+});
+
+test('decode empty string', () => {
+    expect(decode(toBuffer('S', 'i', 0))).toBe('');
+});
+
+test('decode string (bad size) [error]', () => {
+    expect(() => decode(toBuffer('S', 'i', 0xff, 'x'))).toThrow(/Invalid length/);
+});
+
+test('decode string (unexpected eof) [error]', () => {
+    expect(() => decode(toBuffer('S', 'i', 2, 'x'))).toThrow(/Unexpected EOF/);
+});
+
+test('decode ascii string', () => {
+    const header = toBuffer('S', 'I', 0x3f, 0xff);
+    const payload = new Uint8Array(0x3fff + header.byteLength).fill('a'.charCodeAt(0));
+    payload.set(header);
+    expect(decode(payload)).toBe('a'.repeat(0x3fff));
+});
+
+test('decode ascii string [huge]', () => {
+    const header = toBuffer('S', 'I', 0x7f, 0xff);
+    const payload = new Uint8Array(0x7fff + header.byteLength).fill('a'.charCodeAt(0));
+    payload.set(header);
+    expect(decode(payload)).toBe('a'.repeat(0x7fff));
+});
+
+test('decode huge string', () => {
+    expect(decode(toBuffer('S', 'l', 0x00, 0x00, 0x00, 6, 'u', 'b', 'j', 's', 'o', 'n'))).toBe('ubjson');
+});
+
+test('decode huge string [error]', () => {
+    expect(() => decode(toBuffer('S', 'L', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 'x'))).toThrow(
+        /Unsupported type int64/,
+    );
+});
+
+test('decode array', () => {
+    expect(decode(toBuffer('[', 'i', 1, 'i', 2, 'i', 3, ']'))).toEqual([1, 2, 3]);
+});
+
+test('decode array (with no-op)', () => {
+    expect(decode(toBuffer('[', 'i', 1, 'N', 'i', 2, 'i', 3, 'N', ']'))).toEqual([1, 2, 3]);
+});
+
+test('decode array (empty)', () => {
+    expect(decode(toBuffer('[', ']'))).toEqual([]);
+});
+
+test('decode array (empty, optimized)', () => {
+    expect(decode(toBuffer('[', '#', 'i', 0))).toEqual([]);
+});
+
+test('decode array (empty, strongly typed, optimized)', () => {
+    expect(decode(toBuffer('[', '$', 'i', '#', 'i', 0))).toEqual(new Int8Array(0));
+});
+
+test('decode array (mixed, optimized)', () => {
+    expect(decode(toBuffer('[', '#', 'i', 3, 'i', 1, 'C', 'a', 'T'))).toEqual([1, 'a', true]);
+});
+
+test('decode array (strongly typed, optimized)', () => {
+    expect(decode(toBuffer('[', '$', 'i', '#', 'i', 3, 1, 2, 3))).toEqual(new Int8Array([1, 2, 3]));
+});
+
+test('decode array (strongly typed, empty, optimized)', () => {
+    expect(decode(toBuffer('[', '$', 'i', '#', 'i', 0))).toEqual(new Int8Array([]));
+});
+
+test('decode N-D array (strongly typed, optimized)', () => {
+    expect(
+        decode(toBuffer('[', '$', '[', '#', 'i', 2, '$', 'i', '#', 'i', 3, 1, 2, 3, '$', 'i', '#', 'i', 3, 4, 5, 6)),
+    ).toEqual([new Int8Array([1, 2, 3]), new Int8Array([4, 5, 6])]);
+});
+
+test('decode array of objects (optimized)', () => {
+    expect(
+        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,
+            ),
+        ),
+    ).toEqual([
+        { a: 1, b: 2, c: 3 },
+        { d: 4, e: 5, f: 6 },
+    ]);
+});
+
+test('decode array of objects of arrays (optimized)', () => {
+    expect(
+        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,
+            ),
+        ),
+    ).toEqual([
+        { a: new Int8Array([1, 2]), b: new Int8Array([3, 4]) },
+        { c: new Int8Array([5, 6]), d: new Int8Array([7, 8]) },
+    ]);
+});
+
+test('decode array (strongly typed, unexpected eof, optimized)', () => {
+    expect(() => decode(toBuffer('[', '$', 'i', '#', 'i', 3, 1, 2))).toThrow();
+});
+
+test('decode array (strongly typed, invalid length value, optimized)', () => {
+    expect(() => decode(toBuffer('[', '$', 'i', '#', 'i', -1))).toThrow();
+});
+
+test('decode array (strongly typed, invalid length type, optimized)', () => {
+    expect(() => decode(toBuffer('[', '$', 'i', '#', 'C', '0'))).toThrow();
+});
+
+test('decode array (strongly typed, malformed, optimized)', () => {
+    expect(() => decode(toBuffer('[', '$', 'i', 1, 2, 3, ']'))).toThrow();
+});
+
+test('decode array (only null values, optimized)', () => {
+    expect(decode(toBuffer('[', '$', 'Z', '#', 'i', 3))).toEqual([null, null, null]);
+});
+
+test('decode array (only true values, optimized)', () => {
+    expect(decode(toBuffer('[', '$', 'T', '#', 'i', 3))).toEqual([true, true, true]);
+});
+
+test('decode array (only false values, optimized)', () => {
+    expect(decode(toBuffer('[', '$', 'F', '#', 'i', 3))).toEqual([false, false, false]);
+});
+
+test('decode array (int8, strongly typed, optimized) [use typed array]', () => {
+    const actual = decode(toBuffer('[', '$', 'i', '#', 'i', 2, 0x12, 0xfe));
+    expect(actual).toBeInstanceOf(Int8Array);
+    expect(actual).toEqual(Int8Array.from([18, -2]));
+});
+
+test('decode array (uint8, strongly typed, optimized) [use typed array]', () => {
+    const actual = decode(toBuffer('[', '$', 'U', '#', 'i', 2, 0x12, 0xfe));
+    expect(actual).toBeInstanceOf(Uint8Array);
+    expect(actual).toEqual(Uint8Array.from([18, 254]));
+});
+
+test('decode array (int16, strongly typed, optimized) [use typed array]', () => {
+    const actual = decode(toBuffer('[', '$', 'I', '#', 'i', 2, 0x12, 0x34, 0xfe, 0xdc));
+    expect(actual).toBeInstanceOf(Int16Array);
+    expect(actual).toEqual(Int16Array.from([4660, -292]));
+});
+
+test('decode array (int32, strongly typed, optimized) [use typed array]', () => {
+    const actual = decode(toBuffer('[', '$', 'l', '#', 'i', 2, 0x12, 0x34, 0x56, 0x78, 0xfe, 0xdc, 0xba, 0x98));
+    expect(actual).toBeInstanceOf(Int32Array);
+    expect(actual).toEqual(Int32Array.from([305419896, -19088744]));
+});
+
+test('decode array (int64, strongly typed, optimized) [use typed array]', () => {
+    expect(() =>
+        decode(toBuffer('[', '$', 'L', '#', 'i', 1, 0x12, 0x34, 0x56, 0x78, 0xfe, 0xdc, 0xba, 0x98)),
+    ).toThrow();
+});
+
+test('decode array (float32, strongly typed, optimized) [use typed array]', () => {
+    const actual = decode(toBuffer('[', '$', 'd', '#', 'i', 2, 0x3e, 0x80, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00));
+    expect(actual).toBeInstanceOf(Float32Array);
+    expect(actual).toEqual(Float32Array.from([0.25, 0.125]));
+});
+
+test('decode array (float64, strongly typed, optimized) [use typed array]', () => {
+    const actual = decode(
+        toBuffer(
+            '[',
+            '$',
+            'D',
+            '#',
+            'i',
+            2,
+            0x3f,
+            0xd0,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x3f,
+            0xc0,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+        ),
+    );
+    expect(actual).toBeInstanceOf(Float64Array);
+    expect(actual).toEqual(Float64Array.from([0.25, 0.125]));
+});
+
+test('decode object', () => {
+    expect(decode(toBuffer('{', 'i', 1, 'a', 'i', 1, 'i', 1, 'b', 'i', 2, 'i', 1, 'c', 'i', 3, '}'))).toEqual({
+        a: 1,
+        b: 2,
+        c: 3,
+    });
+});
+
+test('decode object (with no-op)', () => {
+    expect(
+        decode(
+            toBuffer('N', '{', 'N', 'i', 1, 'a', 'i', 1, 'i', 1, 'b', 'N', 'i', 2, 'i', 1, 'c', 'i', 3, 'N', '}', 'N'),
+        ),
+    ).toEqual({ a: 1, b: 2, c: 3 });
+});
+
+test('decode array (empty, optimized)', () => {
+    expect(decode(toBuffer('{', '#', 'i', 0))).toEqual({});
+});
+
+test('decode object (mixed, optimized)', () => {
+    expect(decode(toBuffer('{', '#', 'i', 3, 'i', 1, 'a', 'i', 1, 'i', 1, 'b', 'C', 'a', 'i', 1, 'c', 'T'))).toEqual({
+        a: 1,
+        b: 'a',
+        c: true,
+    });
+});
+
+test('decode object (strongly typed, optimized)', () => {
+    expect(decode(toBuffer('{', '$', 'i', '#', 'i', 3, 'i', 1, 'a', 1, 'i', 1, 'b', 2, 'i', 1, 'c', 3))).toEqual({
+        a: 1,
+        b: 2,
+        c: 3,
+    });
+});
+
+test('decode object (only null values, optimized)', () => {
+    expect(decode(toBuffer('{', '$', 'Z', '#', 'i', 3, 'i', 1, 'a', 'i', 1, 'b', 'i', 1, 'c'))).toEqual({
+        a: null,
+        b: null,
+        c: null,
+    });
+});
+
+test('decode object (empty key)', () => {
+    expect(decode(toBuffer('{', 'i', 0, 'T', '}'))).toEqual({
+        '': true,
+    });
+});
+
+test('decode object (empty key, optimized)', () => {
+    expect(decode(toBuffer('{', '$', 'Z', '#', 'i', 3, 'i', 0, 'i', 1, 'a', 'i', 1, 'b'))).toEqual({
+        '': null,
+        a: null,
+        b: null,
+    });
+});

package/{test → tests}/e2e.js

@@ -1,11 +1,9 @@
 /**
  * Tests from https://bitbucket.org/shelacek/ubjson
  */
+import { encode, decode } from '../dist/index.js';
 
-import test from 'tape';
-import * as ubjson from '../dist/index.js';
-
-test('encode/decode complex object', (t) => {
+test('encode/decode complex object', () => {
     const expected = {
         hello: 'world',
         from: ['UBJSON'],
@@ -56,13 +54,12 @@ test('encode/decode complex object', (t) => {
         document1: 'long text'.repeat(10000),
         document2: 'long text'.repeat(100000),
     };
-    const encoded = ubjson.encode(expected);
-    const actual = ubjson.decode(Buffer.from(encoded));
-    t.deepEqual(actual, expected);
-    t.end();
+    const encoded = encode(expected);
+    const actual = decode(Buffer.from(encoded));
+    expect(actual).toEqual(expected);
 });
 
-test('encode/decode model', (t) => {
+test('encode/decode model', () => {
     const expected = {
         rid: 'project/CloudPSS/_SubSysPort',
         name: '模块端口',
@@ -276,14 +273,14 @@ test('encode/decode model', (t) => {
             documentation: '@[docs](http://docs.cloudpss.net/components/comp_PSS/comp_PSSSystem/BasicComp/SystemPort)',
         },
     };
-    const encoded = ubjson.encode(expected);
-    const actual = ubjson.decode(encoded);
-    t.deepEqual(actual, expected);
-    t.end();
+    const encoded = encode(expected);
+    const actual = decode(encoded);
+    expect(actual).toEqual(expected);
 });
 
-test('encode/decode complex object (no encodeInto)', (t) => {
+test('encode/decode complex object (no encodeInto)', () => {
     const encodeInto = TextEncoder.prototype.encodeInto;
+    // @ts-ignore
     TextEncoder.prototype.encodeInto = undefined;
     const expected = {
         hello: 'world',
@@ -334,28 +331,23 @@ test('encode/decode complex object (no encodeInto)', (t) => {
         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();
+    const encoded = encode(expected);
+    const actual = decode(encoded);
+    expect(actual).toEqual(expected);
     TextEncoder.prototype.encodeInto = encodeInto;
 });
 
-test('encode/decode large array', (t) => {
+test('encode/decode large array', () => {
     const array = new Array(100000);
     array[12345] = 'item';
 
     const expected = Array.from({ length: 100000 }).fill(null);
     expected[12345] = 'item';
 
-    t.deepEqual(ubjson.decode(ubjson.encode(array)), expected);
-    t.end();
+    expect(decode(encode(array))).toEqual(expected);
 });
 
-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();
+test('encode/decode object with undefined values', () => {
+    const obj = { a: 1, b: undefined, c: { d: 2, e: undefined, f: null } };
+    expect(decode(encode(obj))).toEqual(obj);
 });