@fireproof/vendor 1.1.1 → 1.2.0

package/src/cborg/test/node-test-bin.js

@@ -0,0 +1,402 @@
+/* eslint-env mocha */
+
+import * as 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":"😀"}'
+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((/** @type {string} */ c, /** @type {number} */ i, /** @type {string[]} */ d) => i % 2 === 0 ? `0x${c}${d[i + 1]}` : '')
+    .filter(Boolean)
+    .map((/** @type {string} */ 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) { // multiline CLI input is hard (impossible?) on Windows
+      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\\":\\"😀\\"}"')
+        : 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\\":\\"😀\\"}"')
+        : 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`)
+    })
+  }
+
+  // complicated nesting to test indenting algorithm
+  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"
+`)
+
+    // round-trip
+    ;({ stdout, stderr } = await execBin('diag2hex', stdout))
+    assert.strictEqual(stderr, '')
+    assert.strictEqual(stdout, `${input}\n`)
+  })
+})

package/src/cborg/test/noop-bin-test.js

@@ -0,0 +1,3 @@
+// file included so ipjs will compile ../lib/bin.js
+// this test file is not intended to be run or loaded
+import bin from "@fireproof/vendor/cborg" // eslint-disable-line

package/src/cborg/test/test-0uint.js

@@ -0,0 +1,103 @@
+/* eslint-env mocha */
+
+import * as chai from 'chai'
+
+import { decode, encode } from "@fireproof/vendor/cborg"
+import { fromHex, toHex } from "@fireproof/vendor/cborg/utils"
+
+const { assert } = chai
+
+// some from https://github.com/PJK/libcbor
+
+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', () => {
+    // minor number 28, too high for uint
+    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}`)
+        }
+      })
+    }
+  })
+
+  // mostly unnecessary, but feels good
+  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', () => {
+      // boundary condition is right on 64-bit int
+      assert.doesNotThrow(() => encode(BigInt('18446744073709551615') /* BigInt(2) ** BigInt(64) - BigInt(1) */))
+      assert.throws(() => encode(BigInt('18446744073709551616') /* BigInt(2) ** BigInt(64) */), /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/src/cborg/test/test-1negint.js

@@ -0,0 +1,96 @@
+/* eslint-env mocha */
+
+import * as chai from 'chai'
+
+import { decode, encode } from "@fireproof/vendor/cborg"
+import { fromHex, toHex } from "@fireproof/vendor/cborg/utils"
+
+const { assert } = chai
+
+// some from https://github.com/PJK/libcbor
+
+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' },
+  // kind of hard to assert on these (TODO: improve bignum handling)
+  { data: '3b001fffffffffffff', expected: BigInt('-9007199254740992') /* Number.MIN_SAFE_INTEGER - 1 */, type: 'negint64' },
+  { data: '3b0020000000000000', expected: BigInt('-9007199254740993') /* Number.MIN_SAFE_INTEGER - 2 */, 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}`)
+        }
+      })
+    }
+  })
+
+  // mostly unnecessary, but feels good
+  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', () => {
+      // boundary condition is right below 64-bit negint
+      assert.doesNotThrow(() => encode(BigInt('-18446744073709551616') /* BigInt(-1) * BigInt(2) ** BigInt(64) */))
+      assert.throws(() => encode(BigInt('-18446744073709551617') /* BigInt(-1) * BigInt(2) ** BigInt(64) - BigInt(1) */), /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}`)
+        })
+      }
+    }
+  })
+})