@cloudpss/ubjson 0.3.11 → 0.4.1

package/tests/rxjs/decode.js

@@ -0,0 +1,535 @@
+/**
+ * Tests from https://bitbucket.org/shelacek/ubjson
+ */
+import { jest } from '@jest/globals';
+import { firstValueFrom, of, Subject } from 'rxjs';
+import { decode as decodePipe } from '../../dist/rxjs/index.js';
+
+/**
+ * @param {Uint8Array} data
+ */
+async function decode(data) {
+    const readable = of(data);
+    return firstValueFrom(readable.pipe(decodePipe()), { defaultValue: undefined });
+}
+
+/**
+ * @param {import("rxjs").Observable<Uint8Array>} observable
+ * @param {(data: unknown) => void} onData
+ */
+function decodeStream(observable, onData) {
+    return /** @type {Promise<void>} */ (
+        new Promise((resolve, reject) => {
+            observable.pipe(decodePipe()).subscribe({
+                next: onData,
+                error: reject,
+                complete: resolve,
+            });
+        })
+    );
+}
+
+/**
+ * @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', async () => {
+    await expect(() => decode(toBuffer('!'))).rejects.toThrow();
+});
+
+test('decode undefined', async () => {
+    expect(await decode(toBuffer('N'))).toBeUndefined();
+});
+
+test('decode undefined (multiple noop)', async () => {
+    expect(await decode(toBuffer('N', 'N', 'N'))).toBeUndefined();
+});
+
+test('decode undefined (empty buffer)', async () => {
+    expect(await decode(toBuffer())).toBeUndefined();
+});
+
+test('decode null', async () => {
+    expect(await decode(toBuffer('Z'))).toBeNull();
+});
+
+test('decode true', async () => {
+    expect(await decode(toBuffer('T'))).toBe(true);
+});
+
+test('decode false', async () => {
+    expect(await decode(toBuffer('F'))).toBe(false);
+});
+
+test('decode int8', async () => {
+    expect(await decode(toBuffer('i', 100))).toBe(100);
+});
+
+test('decode uint8', async () => {
+    expect(await decode(toBuffer('U', 200))).toBe(200);
+});
+
+test('decode int16', async () => {
+    expect(await decode(toBuffer('I', 0x12, 0x34))).toBe(0x1234);
+});
+
+test('decode int32', async () => {
+    expect(await decode(toBuffer('l', 0x12, 0x34, 0x56, 0x78))).toBe(0x12345678);
+});
+
+test('decode int64 [error]', async () => {
+    await expect(() => decode(toBuffer('L', 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0))).rejects.toThrow();
+});
+
+test('decode float32', async () => {
+    expect(await decode(toBuffer('d', 0x3f, 0x80, 0x80, 0x00))).toBe(1.00390625);
+});
+
+test('decode float64', async () => {
+    expect(await decode(toBuffer('D', 0x40, 0xf8, 0x6a, 0x00, 0x10, 0x00, 0x00, 0x00))).toBe(100000.00390625);
+});
+
+test('decode high-precision number [error]', async () => {
+    await expect(() => decode(toBuffer('H', 'i', 3, '1', '.', '1'))).rejects.toThrow();
+});
+
+test('decode char', async () => {
+    expect(await decode(toBuffer('C', 'a'))).toBe('a');
+});
+
+test('decode string', async () => {
+    expect(await decode(toBuffer('S', 'i', 6, 'u', 'b', 'j', 's', 'o', 'n'))).toBe('ubjson');
+});
+
+test('decode empty string', async () => {
+    expect(await decode(toBuffer('S', 'i', 0))).toBe('');
+});
+
+test('decode string (bad size) [error]', async () => {
+    await expect(() => decode(toBuffer('S', 'i', 0xff, 'x'))).rejects.toThrow(/Invalid length/);
+});
+
+test('decode string (unexpected eof) [error]', async () => {
+    await expect(() => decode(toBuffer('S', 'i', 2, 'x'))).rejects.toThrow(/Unexpected EOF/);
+});
+
+test('decode ascii string', async () => {
+    const header = toBuffer('S', 'I', 0x3f, 0xff);
+    const payload = new Uint8Array(0x3fff + header.byteLength).fill('a'.charCodeAt(0));
+    payload.set(header);
+    expect(await decode(payload)).toBe('a'.repeat(0x3fff));
+});
+
+test('decode ascii string 32kiB [huge]', async () => {
+    const size = 0x7fff;
+    const header = toBuffer('S', 'I', 0x7f, 0xff);
+    const payload = new Uint8Array(size + header.byteLength).fill('a'.charCodeAt(0));
+    payload.set(header);
+    expect(await decode(payload)).toBe('a'.repeat(size));
+});
+
+test('decode ascii string 64MB [huge]', async () => {
+    const size = 0x03d09000;
+    const header = toBuffer('S', 'l', 0x03, 0xd0, 0x90, 0x00);
+    const payload = new Uint8Array(size + header.byteLength).fill('a'.charCodeAt(0));
+    payload.set(header);
+    expect(await decode(payload)).toBe('a'.repeat(size));
+});
+
+test('decode huge string', async () => {
+    expect(await decode(toBuffer('S', 'l', 0x00, 0x00, 0x00, 6, 'u', 'b', 'j', 's', 'o', 'n'))).toBe('ubjson');
+});
+
+test('decode huge string [error]', async () => {
+    await expect(() => decode(toBuffer('S', 'L', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 'x'))).rejects.toThrow(
+        /Unsupported type int64/,
+    );
+});
+
+test('decode array', async () => {
+    expect(await decode(toBuffer('[', 'i', 1, 'i', 2, 'i', 3, ']'))).toEqual([1, 2, 3]);
+});
+
+test('decode array (with no-op)', async () => {
+    expect(await decode(toBuffer('[', 'i', 1, 'N', 'i', 2, 'i', 3, 'N', ']'))).toEqual([1, 2, 3]);
+});
+
+test('decode array (empty)', async () => {
+    expect(await decode(toBuffer('[', ']'))).toEqual([]);
+});
+
+test('decode array (empty, optimized)', async () => {
+    expect(await decode(toBuffer('[', '#', 'i', 0))).toEqual([]);
+});
+
+test('decode array (empty, strongly typed, optimized)', async () => {
+    expect(await decode(toBuffer('[', '$', 'i', '#', 'i', 0))).toEqual(new Int8Array(0));
+});
+
+test('decode array (mixed, optimized)', async () => {
+    expect(await decode(toBuffer('[', '#', 'i', 3, 'i', 1, 'C', 'a', 'T'))).toEqual([1, 'a', true]);
+});
+
+test('decode array (strongly typed, optimized)', async () => {
+    expect(await decode(toBuffer('[', '$', 'i', '#', 'i', 3, 1, 2, 3))).toEqual(new Int8Array([1, 2, 3]));
+});
+
+test('decode array (strongly typed, empty, optimized)', async () => {
+    expect(await decode(toBuffer('[', '$', 'i', '#', 'i', 0))).toEqual(new Int8Array([]));
+});
+
+test('decode N-D array (strongly typed, optimized)', async () => {
+    expect(
+        await 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)', async () => {
+    expect(
+        await 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)', async () => {
+    expect(
+        await 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)', async () => {
+    await expect(() => decode(toBuffer('[', '$', 'i', '#', 'i', 3, 1, 2))).rejects.toThrow();
+});
+
+test('decode array (strongly typed, invalid length value, optimized)', async () => {
+    await expect(() => decode(toBuffer('[', '$', 'i', '#', 'i', -1))).rejects.toThrow();
+});
+
+test('decode array (strongly typed, invalid length type, optimized)', async () => {
+    await expect(() => decode(toBuffer('[', '$', 'i', '#', 'C', '0'))).rejects.toThrow();
+});
+
+test('decode array (strongly typed, malformed, optimized)', async () => {
+    await expect(() => decode(toBuffer('[', '$', 'i', 1, 2, 3, ']'))).rejects.toThrow();
+});
+
+test('decode array (only null values, optimized)', async () => {
+    expect(await decode(toBuffer('[', '$', 'Z', '#', 'i', 3))).toEqual([null, null, null]);
+});
+
+test('decode array (only true values, optimized)', async () => {
+    expect(await decode(toBuffer('[', '$', 'T', '#', 'i', 3))).toEqual([true, true, true]);
+});
+
+test('decode array (only false values, optimized)', async () => {
+    expect(await decode(toBuffer('[', '$', 'F', '#', 'i', 3))).toEqual([false, false, false]);
+});
+
+test('decode array (int8, strongly typed, optimized) [use typed array]', async () => {
+    const actual = await 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]', async () => {
+    const actual = await 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]', async () => {
+    const actual = await 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]', async () => {
+    const actual = await 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]', async () => {
+    await expect(() =>
+        decode(toBuffer('[', '$', 'L', '#', 'i', 1, 0x12, 0x34, 0x56, 0x78, 0xfe, 0xdc, 0xba, 0x98)),
+    ).rejects.toThrow();
+});
+
+test('decode array (float32, strongly typed, optimized) [use typed array]', async () => {
+    const actual = await 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]', async () => {
+    const actual = await 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', async () => {
+    expect(await 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)', async () => {
+    expect(
+        await 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)', async () => {
+    expect(await decode(toBuffer('{', '#', 'i', 0))).toEqual({});
+});
+
+test('decode object (mixed, optimized)', async () => {
+    expect(
+        await 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)', async () => {
+    expect(await 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)', async () => {
+    expect(await 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)', async () => {
+    expect(await decode(toBuffer('{', 'i', 0, 'T', '}'))).toEqual({
+        '': true,
+    });
+});
+
+test('decode object (empty key, optimized)', async () => {
+    expect(await decode(toBuffer('{', '$', 'Z', '#', 'i', 3, 'i', 0, 'i', 1, 'a', 'i', 1, 'b'))).toEqual({
+        '': null,
+        a: null,
+        b: null,
+    });
+});
+
+test('decode stream', async () => {
+    const stream = new Subject();
+    // while decoding streaming, N will be regarded as a no-op, rather than an undefined value
+    const onData = jest.fn();
+    const result = decodeStream(stream, onData);
+    stream.next(toBuffer('N', 'Z', 'N', 'N', 'T', 'N', 'N', 'F', 'N', 'N'));
+    stream.next(toBuffer('N', 'N'));
+    stream.next(toBuffer('I', 0x12));
+    stream.next(toBuffer(0x34, 'N', 'N', 'N'));
+    stream.complete();
+    expect(onData).toBeCalledTimes(4);
+    expect(onData).nthCalledWith(1, null);
+    expect(onData).nthCalledWith(2, true);
+    expect(onData).nthCalledWith(3, false);
+    expect(onData).nthCalledWith(4, 0x1234);
+    await expect(result).resolves.toBeUndefined();
+});
+
+test('decode bad stream [error]', async () => {
+    const stream = new Subject();
+    // while decoding streaming, N will be regarded as a no-op, rather than an undefined value
+    const onData = jest.fn();
+    const result = decodeStream(stream, onData);
+    stream.next(toBuffer('N', 'Z', 'N', 'N', 'T', 'N', 'N', 'F', 'N', 'N'));
+    stream.next(toBuffer('N', 'N'));
+    stream.next(toBuffer('I', 0x12));
+    stream.next(toBuffer(0x34, '!', 'N'));
+    stream.next(toBuffer('I', 0x12, 0x34, 'N'));
+    stream.complete();
+    expect(onData).toBeCalledTimes(4);
+    expect(onData).nthCalledWith(1, null);
+    expect(onData).nthCalledWith(2, true);
+    expect(onData).nthCalledWith(3, false);
+    expect(onData).nthCalledWith(4, 0x1234);
+    await expect(result).rejects.toThrow(/Unexpected marker/);
+});
+
+test('decode partial stream [error]', async () => {
+    const stream = new Subject();
+    // while decoding streaming, N will be regarded as a no-op, rather than an undefined value
+    const onData = jest.fn();
+    const result = decodeStream(stream, onData);
+    stream.next(toBuffer('N', 'Z', 'N', 'N', 'T', 'N', 'N', 'F', 'N', 'N'));
+    stream.next(toBuffer('N', 'N'));
+    stream.next(toBuffer('I', 0x12));
+    stream.complete();
+    expect(onData).toBeCalledTimes(3);
+    expect(onData).nthCalledWith(1, null);
+    expect(onData).nthCalledWith(2, true);
+    expect(onData).nthCalledWith(3, false);
+    await expect(result).rejects.toThrow(/Unexpected EOF/);
+});
+
+test('decode error stream [error]', async () => {
+    const stream = new Subject();
+    // while decoding streaming, N will be regarded as a no-op, rather than an undefined value
+    const onData = jest.fn();
+    const result = decodeStream(stream, onData);
+    stream.next(toBuffer('N', 'Z', 'N', 'N', 'T', 'N', 'N', 'F', 'N', 'N'));
+    stream.next(toBuffer('N', 'N'));
+    stream.next(toBuffer('I', 0x12));
+    stream.error(new Error('xyz'));
+    expect(onData).toBeCalledTimes(3);
+    expect(onData).nthCalledWith(1, null);
+    expect(onData).nthCalledWith(2, true);
+    expect(onData).nthCalledWith(3, false);
+    await expect(result).rejects.toThrow(/xyz/);
+});