cborg 2.0.4 → 3.0.0-alpha.1

package/esm/node-test/node-test-bin.js

@@ -1,339 +0,0 @@
-import chai from 'chai';
-import { exec } from 'child_process';
-import process from 'process';
-import path from 'path';
-import { platform } from 'os';
-import { fileURLToPath } from 'url';
-const {assert} = chai;
-const fixture1JsonString = '{"a":1,"b":[2,3],"smile":"\uD83D\uDE00"}';
-const fixture1JsonPrettyString = `{
-  "a": 1,
-  "b": [
-    2,
-    3
-  ],
-  "smile": "😀"
-}
-`;
-const fixture1HexString = 'a3616101616282020365736d696c6564f09f9880';
-const fixture1Bin = fromHex(fixture1HexString);
-const fixture1BinString = new TextDecoder().decode(fixture1Bin);
-const fixture1DiagnosticString = `a3                                                # map(3)
-  61                                              #   string(1)
-    61                                            #     "a"
-  01                                              #   uint(1)
-  61                                              #   string(1)
-    62                                            #     "b"
-  82                                              #   array(2)
-    02                                            #     uint(2)
-    03                                            #     uint(3)
-  65                                              #   string(5)
-    736d696c65                                    #     "smile"
-  64                                              #   string(2)
-    f09f9880                                      #     "😀"
-`;
-const fixture2HexString = 'a4616101616282020363627566440102036165736d696c6564f09f9880';
-const fixture2DiagnosticString = `a4                                                # map(4)
-  61                                              #   string(1)
-    61                                            #     "a"
-  01                                              #   uint(1)
-  61                                              #   string(1)
-    62                                            #     "b"
-  82                                              #   array(2)
-    02                                            #     uint(2)
-    03                                            #     uint(3)
-  63                                              #   string(3)
-    627566                                        #     "buf"
-  44                                              #   bytes(4)
-    01020361                                      #     "\\x01\\x02\\x03a"
-  65                                              #   string(5)
-    736d696c65                                    #     "smile"
-  64                                              #   string(2)
-    f09f9880                                      #     "😀"
-`;
-const binPath = path.join(path.dirname(fileURLToPath(import.meta.url)), '../lib/bin.js');
-function fromHex(hex) {
-  return new Uint8Array(hex.split('').map((c, i, d) => i % 2 === 0 ? `0x${ c }${ d[i + 1] }` : '').filter(Boolean).map(e => parseInt(e, 16)));
-}
-async function execBin(cmd, stdin) {
-  return new Promise((resolve, reject) => {
-    const cp = exec(`"${ process.execPath }" "${ binPath }" ${ cmd }`, (err, stdout, stderr) => {
-      if (err) {
-        err.stdout = stdout;
-        err.stderr = stderr;
-        return reject(err);
-      }
-      resolve({
-        stdout,
-        stderr
-      });
-    });
-    if (stdin != null) {
-      cp.on('spawn', () => {
-        cp.stdin.write(stdin);
-        cp.stdin.end();
-      });
-    }
-  });
-}
-describe('Bin', () => {
-  it('usage', async () => {
-    try {
-      await execBin('');
-      assert.fail('should have errored');
-    } catch (e) {
-      assert.strictEqual(e.stdout, '');
-      assert.strictEqual(e.stderr, `Usage: cborg <command> <args>
-Valid commands:
-\tbin2diag [binary input]
-\tbin2hex [binary input]
-\tbin2json [--pretty] [binary input]
-\tdiag2bin [diagnostic input]
-\tdiag2hex [diagnostic input]
-\tdiag2json [--pretty] [diagnostic input]
-\thex2bin [hex input]
-\thex2diag [hex input]
-\thex2json [--pretty] [hex input]
-\tjson2bin '[json input]'
-\tjson2diag '[json input]'
-\tjson2hex '[json input]'
-Input may either be supplied as an argument or piped via stdin
-`);
-    }
-  });
-  it('bad cmd', async () => {
-    try {
-      await execBin('blip');
-      assert.fail('should have errored');
-    } catch (e) {
-      assert.strictEqual(e.stdout, '');
-      assert.strictEqual(e.stderr, `Unknown command: 'blip'
-Usage: cborg <command> <args>
-Valid commands:
-\tbin2diag [binary input]
-\tbin2hex [binary input]
-\tbin2json [--pretty] [binary input]
-\tdiag2bin [diagnostic input]
-\tdiag2hex [diagnostic input]
-\tdiag2json [--pretty] [diagnostic input]
-\thex2bin [hex input]
-\thex2diag [hex input]
-\thex2json [--pretty] [hex input]
-\tjson2bin '[json input]'
-\tjson2diag '[json input]'
-\tjson2hex '[json input]'
-Input may either be supplied as an argument or piped via stdin
-`);
-    }
-  });
-  it('help', async () => {
-    const {stdout, stderr} = await execBin('help');
-    assert.strictEqual(stdout, '');
-    assert.strictEqual(stderr, `Usage: cborg <command> <args>
-Valid commands:
-\tbin2diag [binary input]
-\tbin2hex [binary input]
-\tbin2json [--pretty] [binary input]
-\tdiag2bin [diagnostic input]
-\tdiag2hex [diagnostic input]
-\tdiag2json [--pretty] [diagnostic input]
-\thex2bin [hex input]
-\thex2diag [hex input]
-\thex2json [--pretty] [hex input]
-\tjson2bin '[json input]'
-\tjson2diag '[json input]'
-\tjson2hex '[json input]'
-Input may either be supplied as an argument or piped via stdin
-`);
-  });
-  it('bin2diag (stdin)', async () => {
-    const {stdout, stderr} = await execBin('bin2diag', fixture1Bin);
-    assert.strictEqual(stderr, '');
-    assert.strictEqual(stdout, fixture1DiagnosticString);
-  });
-  it('bin2hex (stdin)', async () => {
-    const {stdout, stderr} = await execBin('bin2hex', fixture1Bin);
-    assert.strictEqual(stderr, '');
-    assert.strictEqual(stdout, `${ fixture1HexString }\n`);
-  });
-  it('bin2json (stdin)', async () => {
-    const {stdout, stderr} = await execBin('bin2json', fixture1Bin);
-    assert.strictEqual(stderr, '');
-    assert.strictEqual(stdout, `${ fixture1JsonString }\n`);
-  });
-  it('bin2json pretty (stdin)', async () => {
-    const {stdout, stderr} = await execBin('bin2json --pretty', fixture1Bin);
-    assert.strictEqual(stderr, '');
-    assert.strictEqual(stdout, fixture1JsonPrettyString);
-  });
-  for (const stdin of [
-      true,
-      false
-    ]) {
-    if (platform() !== 'win32' || stdin) {
-      it(`diag2bin${ stdin ? ' (stdin)' : '' }`, async () => {
-        const {stdout, stderr} = !stdin ? await execBin(`diag2bin '${ fixture1DiagnosticString }'`) : await execBin('diag2bin', fixture1DiagnosticString);
-        assert.strictEqual(stderr, '');
-        assert.strictEqual(stdout, fixture1BinString);
-      });
-      it(`diag2hex${ stdin ? ' (stdin)' : '' }`, async () => {
-        const {stdout, stderr} = !stdin ? await execBin(`diag2hex '${ fixture1DiagnosticString }'`) : await execBin('diag2hex', fixture1DiagnosticString);
-        assert.strictEqual(stderr, '');
-        assert.strictEqual(stdout, `${ fixture1HexString }\n`);
-      });
-      it(`diag2json${ stdin ? ' (stdin)' : '' }`, async () => {
-        const {stdout, stderr} = !stdin ? await execBin(`diag2json '${ fixture1DiagnosticString }'`) : await execBin('diag2json', fixture1DiagnosticString);
-        assert.strictEqual(stderr, '');
-        assert.strictEqual(stdout, `${ fixture1JsonString }\n`);
-      });
-      it(`diag2json pretty${ stdin ? ' (stdin)' : '' }`, async () => {
-        const {stdout, stderr} = !stdin ? await execBin(`diag2json --pretty '${ fixture1DiagnosticString }'`) : await execBin('diag2json --pretty', fixture1DiagnosticString);
-        assert.strictEqual(stderr, '');
-        assert.strictEqual(stdout, fixture1JsonPrettyString);
-      });
-    }
-    it(`hex2bin${ stdin ? ' (stdin)' : '' }`, async () => {
-      const {stdout, stderr} = !stdin ? await execBin(`hex2bin ${ fixture1HexString }`) : await execBin('hex2bin', fixture1HexString);
-      assert.strictEqual(stderr, '');
-      assert.strictEqual(stdout, fixture1BinString);
-    });
-    it(`hex2diag${ stdin ? ' (stdin)' : '' }`, async () => {
-      const {stdout, stderr} = !stdin ? await execBin(`hex2diag ${ fixture2HexString }`) : await execBin('hex2diag', fixture2HexString);
-      assert.strictEqual(stderr, '');
-      assert.strictEqual(stdout, fixture2DiagnosticString);
-    });
-    it(`hex2json${ stdin ? ' (stdin)' : '' }`, async () => {
-      const {stdout, stderr} = !stdin ? await execBin(`hex2json ${ fixture1HexString }`) : await execBin('hex2json', fixture1HexString);
-      assert.strictEqual(stderr, '');
-      assert.strictEqual(stdout, `${ fixture1JsonString }\n`);
-    });
-    it(`hex2json pretty${ stdin ? ' (stdin)' : '' }`, async () => {
-      const {stdout, stderr} = !stdin ? await execBin(`hex2json --pretty ${ fixture1HexString }`) : await execBin('hex2json --pretty', fixture1HexString);
-      assert.strictEqual(stderr, '');
-      assert.strictEqual(stdout, fixture1JsonPrettyString);
-    });
-    it(`json2bin${ stdin ? ' (stdin)' : '' }`, async () => {
-      const {stdout, stderr} = !stdin ? await execBin('json2bin "{\\"a\\":1,\\"b\\":[2,3],\\"smile\\":\\"\uD83D\uDE00\\"}"') : await execBin('json2bin', fixture1JsonString);
-      assert.strictEqual(stderr, '');
-      assert.strictEqual(stdout, fixture1BinString);
-    });
-    it(`json2diag${ stdin ? ' (stdin)' : '' }`, async () => {
-      const {stdout, stderr} = !stdin ? await execBin('json2diag "{\\"a\\":1,\\"b\\":[2,3],\\"smile\\":\\"\uD83D\uDE00\\"}"') : await execBin('json2diag', fixture1JsonString);
-      assert.strictEqual(stderr, '');
-      assert.strictEqual(stdout, fixture1DiagnosticString);
-    });
-    it(`json2hex${ stdin ? ' (stdin)' : '' }`, async () => {
-      const {stdout, stderr} = !stdin ? await execBin(`json2hex "${ fixture1JsonString.replace(/"/g, '\\"') }"`) : await execBin('json2hex', fixture1JsonString);
-      assert.strictEqual(stderr, '');
-      assert.strictEqual(stdout, `${ fixture1HexString }\n`);
-    });
-  }
-  it('diag indenting', async () => {
-    const {stdout, stderr} = await execBin('json2diag', '{"a":[],"b":{},"c":{"a":1,"b":{"a":{"a":{}}}},"d":{"a":{"a":{"a":1},"b":2,"c":[]}},"e":[[[[{"a":{}}]]]],"f":1}');
-    assert.strictEqual(stderr, '');
-    assert.strictEqual(stdout, `a6                                                # map(6)
-  61                                              #   string(1)
-    61                                            #     "a"
-  80                                              #   array(0)
-  61                                              #   string(1)
-    62                                            #     "b"
-  a0                                              #   map(0)
-  61                                              #   string(1)
-    63                                            #     "c"
-  a2                                              #   map(2)
-    61                                            #     string(1)
-      61                                          #       "a"
-    01                                            #     uint(1)
-    61                                            #     string(1)
-      62                                          #       "b"
-    a1                                            #     map(1)
-      61                                          #       string(1)
-        61                                        #         "a"
-      a1                                          #       map(1)
-        61                                        #         string(1)
-          61                                      #           "a"
-        a0                                        #         map(0)
-  61                                              #   string(1)
-    64                                            #     "d"
-  a1                                              #   map(1)
-    61                                            #     string(1)
-      61                                          #       "a"
-    a3                                            #     map(3)
-      61                                          #       string(1)
-        61                                        #         "a"
-      a1                                          #       map(1)
-        61                                        #         string(1)
-          61                                      #           "a"
-        01                                        #         uint(1)
-      61                                          #       string(1)
-        62                                        #         "b"
-      02                                          #       uint(2)
-      61                                          #       string(1)
-        63                                        #         "c"
-      80                                          #       array(0)
-  61                                              #   string(1)
-    65                                            #     "e"
-  81                                              #   array(1)
-    81                                            #     array(1)
-      81                                          #       array(1)
-        81                                        #         array(1)
-          a1                                      #           map(1)
-            61                                    #             string(1)
-              61                                  #               "a"
-            a0                                    #             map(0)
-  61                                              #   string(1)
-    66                                            #     "f"
-  01                                              #   uint(1)
-`);
-  });
-  describe('diag length bytes', () => {
-    it('compact', async () => {
-      const {stdout, stderr} = await execBin('json2diag', '"aaaaaaaaaaaaaaaaaaaaaaa"');
-      assert.strictEqual(stderr, '');
-      assert.strictEqual(stdout, `77                                                # string(23)
-  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
-`);
-    });
-    it('1-byte', async () => {
-      const {stdout, stderr} = await execBin('json2diag', '"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"');
-      assert.strictEqual(stderr, '');
-      assert.strictEqual(stdout, `78 23                                             # string(35)
-  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
-  616161616161616161616161                        #   "aaaaaaaaaaaa"
-`);
-    });
-    it('2-byte', async () => {
-      const {stdout, stderr} = await execBin('json2diag', '"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"');
-      assert.strictEqual(stderr, '');
-      assert.strictEqual(stdout, `79 0100                                           # string(256)
-  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
-  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
-  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
-  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
-  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
-  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
-  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
-  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
-  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
-  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
-  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
-  616161                                          #   "aaa"
-`);
-    });
-  });
-  it('diag non-utf8 and non-printable ascii', async () => {
-    const input = '7864f55ff8f12508b63ef2bfeca7557ae90df6311a5ec1631b4a1fa843310bd9c3a710eaace5a1bdd72ad0bfe049771c11e756338bd93865e645f1adec9b9c99ef407fbd4fc6859e7904c5ad7dc9bd10a5cc16973d5b28ec1a6dd43d9f82f9f18c3d03418e35';
-    let {stdout, stderr} = await execBin(`hex2diag ${ input }`);
-    assert.strictEqual(stderr, '');
-    assert.strictEqual(stdout, `78 64                                             # string(86)
-  f55ff8f12508b63ef2bfeca7557ae90df6311a5ec1631b  #   "õ_øñ%\\x08¶>ò¿ì§Uzé\\x0dö1\\x1a^Ác\\x1b"
-  4a1fa843310bd9c3a710eaace5a1bdd72ad0bfe049771c  #   "J\\x1f¨C1\\x0bÙç\\x10ê¬å¡½×*пàIw\\x1c"
-  11e756338bd93865e645f1adec9b9c99ef407fbd4fc685  #   "\\x11çV3\\x8bÙ8eæEñ\\xadì\\x9b\\x9c\\x99ï@\\x7f½OÆ\\x85"
-  9e7904c5ad7dc9bd10a5cc16973d5b28ec1a6dd43d9f82  #   "\\x9ey\\x04Å\\xad}ɽ\\x10¥Ì\\x16\\x97=[(ì\\x1amÔ=\\x9f\\x82"
-  f9f18c3d03418e35                                #   "ùñ\\x8c=\\x03A\\x8e5"
-`);
-    ({stdout, stderr} = await execBin('diag2hex', stdout));
-    assert.strictEqual(stderr, '');
-    assert.strictEqual(stdout, `${ input }\n`);
-  });
-});

package/esm/node-test/noop-bin-test.js

@@ -1 +0,0 @@
-import bin from '../lib/bin.js';

package/esm/node-test/test-0uint.js

@@ -1,155 +0,0 @@
-import chai from 'chai';
-import {
-  decode,
-  encode
-} from '../cborg.js';
-import {
-  fromHex,
-  toHex
-} from '../lib/byte-utils.js';
-const {assert} = chai;
-const fixtures = [
-  {
-    data: '00',
-    expected: 0,
-    type: 'uint8'
-  },
-  {
-    data: '02',
-    expected: 2,
-    type: 'uint8'
-  },
-  {
-    data: '18ff',
-    expected: 255,
-    type: 'uint8'
-  },
-  {
-    data: '1901f4',
-    expected: 500,
-    type: 'uint16'
-  },
-  {
-    data: '1900ff',
-    expected: 255,
-    type: 'uint16',
-    strict: false
-  },
-  {
-    data: '19ffff',
-    expected: 65535,
-    type: 'uint16'
-  },
-  {
-    data: '1a000000ff',
-    expected: 255,
-    type: 'uint32',
-    strict: false
-  },
-  {
-    data: '1a00010000',
-    expected: 65536,
-    type: 'uint32'
-  },
-  {
-    data: '1a000f4240',
-    expected: 1000000,
-    type: 'uint32'
-  },
-  {
-    data: '1aa5f702b3',
-    expected: 2784428723,
-    type: 'uint32'
-  },
-  {
-    data: '1b00000000000000ff',
-    expected: 255,
-    type: 'uint64',
-    strict: false
-  },
-  {
-    data: '1b0016db6db6db6db7',
-    expected: Number.MAX_SAFE_INTEGER / 1.4,
-    type: 'uint64'
-  },
-  {
-    data: '1b001fffffffffffff',
-    expected: Number.MAX_SAFE_INTEGER,
-    type: 'uint64'
-  },
-  {
-    data: '1ba5f702b3a5f702b3',
-    expected: BigInt('11959030306112471731'),
-    type: 'uint64'
-  },
-  {
-    data: '1bffffffffffffffff',
-    expected: BigInt('18446744073709551615'),
-    type: 'uint64'
-  }
-];
-describe('uint', () => {
-  describe('decode', () => {
-    for (const fixture of fixtures) {
-      const data = fromHex(fixture.data);
-      it(`should decode ${ fixture.type }=${ fixture.expected }`, () => {
-        assert.ok(decode(data) === fixture.expected, `decode ${ fixture.type } ${ decode(data) } != ${ fixture.expected }`);
-        if (fixture.strict === false) {
-          assert.throws(() => decode(data, { strict: true }), Error, 'CBOR decode error: integer encoded in more bytes than necessary (strict decode)');
-        } else {
-          assert.ok(decode(data, { strict: true }) === fixture.expected, `decode ${ fixture.type }`);
-        }
-      });
-    }
-  });
-  it('should throw error', () => {
-    assert.throws(() => decode(fromHex('1ca5f702b3a5f702b3')), Error, 'CBOR decode error: encountered invalid minor (28) for major 0');
-    assert.throws(() => decode(fromHex('1ba5f702b3a5f702')), Error, 'CBOR decode error: not enough data for type');
-  });
-  describe('encode', () => {
-    for (const fixture of fixtures) {
-      it(`should encode ${ fixture.type }=${ fixture.expected }`, () => {
-        if (fixture.strict === false) {
-          assert.notStrictEqual(toHex(encode(fixture.expected)), fixture.data, `encode ${ fixture.type } !strict`);
-        } else {
-          assert.strictEqual(toHex(encode(fixture.expected)), fixture.data, `encode ${ fixture.type }`);
-        }
-      });
-    }
-  });
-  describe('roundtrip', () => {
-    for (const fixture of fixtures) {
-      if (fixture.strict !== false) {
-        it(`should roundtrip ${ fixture.type }=${ fixture.expected }`, () => {
-          assert.ok(decode(encode(fixture.expected)) === fixture.expected, `roundtrip ${ fixture.type }`);
-        });
-      }
-    }
-  });
-  describe('toobig', () => {
-    it('bigger than 64-bit', () => {
-      assert.doesNotThrow(() => encode(BigInt('18446744073709551615')));
-      assert.throws(() => encode(BigInt('18446744073709551616')), /BigInt larger than allowable range/);
-    });
-    it('disallow BigInt', () => {
-      for (const fixture of fixtures) {
-        const data = fromHex(fixture.data);
-        if (!Number.isSafeInteger(fixture.expected)) {
-          assert.throws(() => decode(data, { allowBigInt: false }), /safe integer range/);
-        } else {
-          assert.ok(decode(data, { allowBigInt: false }) === fixture.expected, `decode ${ fixture.type }`);
-        }
-      }
-    });
-  });
-  describe('toosmall', () => {
-    for (const fixture of fixtures) {
-      if (fixture.strict !== false && typeof fixture.expected === 'number') {
-        const small = BigInt(fixture.expected);
-        it(`should encode ${ small }n`, () => {
-          assert.strictEqual(toHex(encode(BigInt(small))), fixture.data, `encode ${ small }`);
-        });
-      }
-    }
-  });
-});

package/esm/node-test/test-1negint.js

@@ -1,149 +0,0 @@
-import chai from 'chai';
-import {
-  decode,
-  encode
-} from '../cborg.js';
-import {
-  fromHex,
-  toHex
-} from '../lib/byte-utils.js';
-const {assert} = chai;
-const fixtures = [
-  {
-    data: '20',
-    expected: -1,
-    type: 'negint8'
-  },
-  {
-    data: '22',
-    expected: -3,
-    type: 'negint8'
-  },
-  {
-    data: '3863',
-    expected: -100,
-    type: 'negint8'
-  },
-  {
-    data: '38ff',
-    expected: -256,
-    type: 'negint8'
-  },
-  {
-    data: '3900ff',
-    expected: -256,
-    type: 'negint16',
-    strict: false
-  },
-  {
-    data: '3901f4',
-    expected: -501,
-    type: 'negint16'
-  },
-  {
-    data: '3a000000ff',
-    expected: -256,
-    type: 'negint32',
-    strict: false
-  },
-  {
-    data: '3aa5f702b3',
-    expected: -2784428724,
-    type: 'negint32'
-  },
-  {
-    data: '3b00000000000000ff',
-    expected: -256,
-    type: 'negint32',
-    strict: false
-  },
-  {
-    data: '3b0016db6db6db6db7',
-    expected: Number.MIN_SAFE_INTEGER / 1.4 - 1,
-    type: 'negint64'
-  },
-  {
-    data: '3b001ffffffffffffe',
-    expected: Number.MIN_SAFE_INTEGER,
-    type: 'negint64'
-  },
-  {
-    data: '3b001fffffffffffff',
-    expected: BigInt('-9007199254740992'),
-    type: 'negint64'
-  },
-  {
-    data: '3b0020000000000000',
-    expected: BigInt('-9007199254740993'),
-    type: 'negint64'
-  },
-  {
-    data: '3ba5f702b3a5f702b3',
-    expected: BigInt('-11959030306112471732'),
-    type: 'negint64'
-  },
-  {
-    data: '3bffffffffffffffff',
-    expected: BigInt('-18446744073709551616'),
-    type: 'negint64'
-  }
-];
-describe('negint', () => {
-  describe('decode', () => {
-    for (const fixture of fixtures) {
-      const data = fromHex(fixture.data);
-      it(`should decode ${ fixture.type }=${ fixture.expected }`, () => {
-        assert.ok(decode(data) === fixture.expected, `decode ${ fixture.type } (${ decode(data) } != ${ fixture.expected })`);
-        if (fixture.strict === false) {
-          assert.throws(() => decode(data, { strict: true }), Error, 'CBOR decode error: integer encoded in more bytes than necessary (strict decode)');
-        } else {
-          assert.strictEqual(decode(data, { strict: true }), fixture.expected, `decode ${ fixture.type }`);
-        }
-      });
-    }
-  });
-  describe('encode', () => {
-    for (const fixture of fixtures) {
-      it(`should encode ${ fixture.type }=${ fixture.expected }`, () => {
-        if (fixture.strict === false) {
-          assert.notStrictEqual(toHex(encode(fixture.expected)), fixture.data, `encode ${ fixture.type } !strict`);
-        } else {
-          assert.strictEqual(toHex(encode(fixture.expected)), fixture.data, `encode ${ fixture.type }`);
-        }
-      });
-    }
-  });
-  describe('roundtrip', () => {
-    for (const fixture of fixtures) {
-      it(`should roundtrip ${ fixture.type }=${ fixture.expected }`, () => {
-        assert.ok(decode(encode(fixture.expected)) === fixture.expected, `roundtrip ${ fixture.type }`);
-      });
-    }
-  });
-  describe('toobig', () => {
-    it('bigger than 64-bit', () => {
-      assert.doesNotThrow(() => encode(BigInt('-18446744073709551616')));
-      assert.throws(() => encode(BigInt('-18446744073709551617')), /BigInt larger than allowable range/);
-    });
-    it('disallow BigInt', () => {
-      for (const fixture of fixtures) {
-        const data = fromHex(fixture.data);
-        if (!Number.isSafeInteger(fixture.expected)) {
-          assert.throws(() => decode(data, { allowBigInt: false }), /safe integer range/);
-        } else {
-          assert.ok(decode(data, { allowBigInt: false }) === fixture.expected, `decode ${ fixture.type }`);
-        }
-      }
-    });
-  });
-  describe('toosmall', () => {
-    for (const fixture of fixtures) {
-      if (fixture.strict !== false && typeof fixture.expected === 'number') {
-        const small = BigInt(fixture.expected);
-        it(`should encode ${ small }n`, () => {
-          assert.strictEqual(toHex(encode(BigInt(small))), fixture.data, `encode ${ small }`);
-        });
-      }
-    }
-  });
-});