@fireproof/vendor 1.1.0 → 1.2.0

package/src/cborg/test/test-2bytes.js

@@ -0,0 +1,198 @@
+/* eslint-env mocha */
+
+import * as chai from 'chai'
+
+import { decode, encode } from "@fireproof/vendor/cborg"
+import { useBuffer, fromHex, toHex } from "@fireproof/vendor/cborg/utils"
+
+const { assert } = chai
+
+// some from https://github.com/PJK/libcbor
+
+const fixtures = [
+  { data: '40', expected: '', type: 'bytes' },
+  { data: '41a1', expected: 'a1', type: 'bytes' },
+  { data: '5801a1', expected: 'a1', type: 'bytes', strict: false },
+  {
+    data: '58ff000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe',
+    expected: '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe',
+    type: 'bytes',
+    label: 'long bytes, 8-bit length'
+  },
+  {
+    data: '5900ff000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe',
+    expected: '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe',
+    type: 'bytes',
+    label: 'long bytes, 16-bit length',
+    strict: false
+  },
+  {
+    data: '5a000000ff000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe',
+    expected: '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe',
+    type: 'bytes',
+    label: 'long bytes, 32-bit length',
+    strict: false
+  },
+  {
+    data: '5b00000000000000ff000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe',
+    expected: '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe',
+    type: 'bytes',
+    label: 'long bytes, 64-bit length',
+    strict: false
+  }
+]
+
+// fill up byte arrays we can validate in strict mode, the minimal size for each
+// excluding 64-bit because 4G is just too big
+;(() => {
+  function rnd (length) {
+    return new Uint8Array(Array.from({ length }, () => Math.floor(Math.random() * 255)))
+  }
+
+  const expected16 = rnd(256)
+  fixtures.push({
+    data: new Uint8Array([...fromHex('590100'), ...expected16]),
+    expected: expected16,
+    type: 'bytes',
+    label: 'long bytes, 16-bit length strict-compat'
+  })
+
+  const expected32 = rnd(65536)
+  fixtures.push({
+    data: new Uint8Array([...fromHex('5a00010000'), ...expected32]),
+    expected: expected32,
+    type: 'bytes',
+    label: 'long bytes, 32-bit length strict-compat'
+  })
+})()
+
+describe('bytes', () => {
+  describe('decode', () => {
+    for (const fixture of fixtures) {
+      const data = fromHex(fixture.data)
+      it(`should decode ${fixture.type}=${fixture.label || fixture.expected}`, () => {
+        let actual = decode(data)
+        assert.strictEqual(
+          toHex(actual),
+          toHex(fromHex(fixture.expected)),
+          `decode ${fixture.type}`)
+
+        if (fixture.strict === false) {
+          assert.throws(() => decode(data, { strict: true }), Error, 'CBOR decode error: integer encoded in more bytes than necessary (strict decode)')
+        } else {
+          actual = decode(data, { strict: true })
+          assert.strictEqual(
+            toHex(actual),
+            toHex(fromHex(fixture.expected)),
+            `decode ${fixture.type} strict`)
+        }
+      })
+
+      it('should fail to decode very large length', () => {
+        assert.throws(
+          () => decode(fromHex('5ba5f702b3a5f702b3000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe')),
+          /CBOR decode error: 64-bit integer bytes lengths not supported/)
+      })
+    }
+  })
+
+  describe('encode', () => {
+    for (const fixture of fixtures) {
+      if (fixture.data.length >= 100000000) {
+        it.skip(`(TODO) skipping encode of very large bytes ${fixture.type}=${fixture.label || fixture.expected}`, () => {})
+        continue
+      }
+
+      const data = fromHex(fixture.expected)
+      const expectedHex = toHex(fixture.data)
+
+      it(`should encode ${fixture.type}=${fixture.label || fixture.expected}`, () => {
+        if (fixture.unsafe) {
+          assert.throws(() => encode(data), Error, /^CBOR encode error: number too large to encode \(-\d+\)$/)
+        } else if (fixture.strict === false) {
+          assert.notStrictEqual(toHex(encode(data)), expectedHex, `encode ${fixture.type} !strict`)
+        } else {
+          assert.strictEqual(toHex(encode(data)), expectedHex, `encode ${fixture.type}`)
+        }
+      })
+    }
+  })
+
+  describe('typedarrays', () => {
+    const cases = [
+      {
+        obj: Uint8Array.from([1, 2, 3]),
+        hex: '43010203'
+      },
+      {
+        obj: Uint8ClampedArray.from([1, 2, 3]),
+        hex: '43010203'
+      },
+      {
+        obj: Uint16Array.from([1, 2, 3]),
+        hex: '46010002000300'
+      },
+      {
+        obj: Uint32Array.from([1, 2, 3]),
+        hex: '4c010000000200000003000000'
+      },
+      {
+        obj: Int8Array.from([1, 2, -3]),
+        hex: '430102fd'
+      },
+      {
+        obj: Int16Array.from([1, 2, -3]),
+        hex: '4601000200fdff'
+      },
+      {
+        obj: Int32Array.from([1, 2, -3]),
+        hex: '4c0100000002000000fdffffff'
+      },
+      {
+        obj: Float32Array.from([1, 2, -3]),
+        hex: '4c0000803f00000040000040c0'
+      },
+      {
+        obj: Float64Array.from([1, 2, -3]),
+        hex: '5818000000000000f03f000000000000004000000000000008c0'
+      },
+      {
+        obj: BigUint64Array.from([BigInt(1), BigInt(2), BigInt(3)]),
+        hex: '5818010000000000000002000000000000000300000000000000'
+      },
+      {
+        obj: BigInt64Array.from([BigInt(1), BigInt(2), BigInt(-3)]),
+        hex: '581801000000000000000200000000000000fdffffffffffffff'
+      },
+      {
+        obj: new DataView(Uint8Array.from([1, 2, 3]).buffer),
+        hex: '43010203'
+      },
+      {
+        obj: Uint8Array.from([1, 2, 3]).buffer,
+        hex: '43010203'
+      }
+    ]
+
+    for (const testCase of cases) {
+      it(testCase.obj.constructor.name, () => {
+        assert.equal(toHex(encode(testCase.obj)), testCase.hex)
+        const decoded = decode(fromHex(testCase.hex))
+        assert.instanceOf(decoded, Uint8Array)
+        assert.equal(toHex(decoded), toHex(testCase.obj))
+      })
+    }
+  })
+
+  if (useBuffer) {
+    describe('buffer', () => {
+      it('can encode Node.js Buffers', () => {
+        const obj = global.Buffer.from([1, 2, 3])
+        assert.equal(toHex(encode(obj)), '43010203')
+        const decoded = decode(fromHex('43010203'))
+        assert.instanceOf(decoded, Uint8Array)
+        assert.equal(toHex(decoded), toHex(obj))
+      })
+    })
+  }
+})

package/src/cborg/test/test-3string.js

@@ -0,0 +1,136 @@
+/* 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: '60', expected: '', type: 'string' },
+  { data: '6161', expected: 'a', type: 'string' },
+  { data: '780161', expected: 'a', type: 'string', strict: false },
+  {
+    data: '6c48656c6c6f20776f726c6421',
+    expected: 'Hello world!',
+    type: 'string'
+  },
+  {
+    data: '6fc48c6175657320c39f76c49b746521',
+    expected: 'Čaues ßvěte!',
+    type: 'string'
+  },
+  {
+    data: '78964c6f72656d20697073756d20646f6c6f722073697420616d65742c20636f6e73656374657475722061646970697363696e6720656c69742e20446f6e6563206d692074656c6c75732c20696163756c6973206e656320766573746962756c756d20717569732c206665726d656e74756d206e6f6e2066656c69732e204d616563656e6173207574206a7573746f20706f73756572652e',
+    expected: 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec mi tellus, iaculis nec vestibulum quis, fermentum non felis. Maecenas ut justo posuere.',
+    type: 'string',
+    label: 'long string, 8-bit length'
+  },
+  {
+    data: '7900964c6f72656d20697073756d20646f6c6f722073697420616d65742c20636f6e73656374657475722061646970697363696e6720656c69742e20446f6e6563206d692074656c6c75732c20696163756c6973206e656320766573746962756c756d20717569732c206665726d656e74756d206e6f6e2066656c69732e204d616563656e6173207574206a7573746f20706f73756572652e',
+    expected: 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec mi tellus, iaculis nec vestibulum quis, fermentum non felis. Maecenas ut justo posuere.',
+    type: 'string',
+    label: 'long string, 16-bit length',
+    strict: false
+  },
+  {
+    data: '7a000000964c6f72656d20697073756d20646f6c6f722073697420616d65742c20636f6e73656374657475722061646970697363696e6720656c69742e20446f6e6563206d692074656c6c75732c20696163756c6973206e656320766573746962756c756d20717569732c206665726d656e74756d206e6f6e2066656c69732e204d616563656e6173207574206a7573746f20706f73756572652e',
+    expected: 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec mi tellus, iaculis nec vestibulum quis, fermentum non felis. Maecenas ut justo posuere.',
+    type: 'string',
+    label: 'long string, 32-bit length',
+    strict: false
+  },
+  {
+    data: '7b00000000000000964c6f72656d20697073756d20646f6c6f722073697420616d65742c20636f6e73656374657475722061646970697363696e6720656c69742e20446f6e6563206d692074656c6c75732c20696163756c6973206e656320766573746962756c756d20717569732c206665726d656e74756d206e6f6e2066656c69732e204d616563656e6173207574206a7573746f20706f73756572652e',
+    expected: 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec mi tellus, iaculis nec vestibulum quis, fermentum non felis. Maecenas ut justo posuere.',
+    type: 'string',
+    label: 'long string, 64-bit length',
+    strict: false
+  }
+]
+
+// fill up byte arrays converted to strings so we can validate in strict mode,
+// the minimal size for each excluding 64-bit because 4G is just too big
+;(() => {
+  function rnd (length) {
+    const sa = []
+    let l = 0
+    while (l < length) {
+      // some unicode character, unless we're near the end and want to fill up exactly so
+      // we need to pad with ascii
+      const ascii = (length - l) < 3
+      const base = ascii ? 32 : 0x1f000
+      const max = ascii ? 126 : 0x1ff00
+      const cc = Math.floor(Math.random() * (max - base)) + base
+      const s = String.fromCharCode(cc)
+      l += (new TextEncoder().encode(s)).length
+      sa.push(s)
+    }
+    return sa.join('')
+  }
+
+  const expected16 = rnd(256)
+  fixtures.push({
+    data: new Uint8Array([...fromHex('790100'), ...(new TextEncoder().encode(expected16))]),
+    expected: expected16,
+    type: 'string',
+    label: 'long string, 16-bit length strict-compat'
+  })
+
+  const expected32 = rnd(65536)
+  fixtures.push({
+    data: new Uint8Array([...fromHex('7a00010000'), ...(new TextEncoder().encode(expected32))]),
+    expected: expected32,
+    type: 'string',
+    label: 'long string, 32-bit length strict-compat'
+  })
+})()
+
+describe('string', () => {
+  describe('decode', () => {
+    for (const fixture of fixtures) {
+      const data = fromHex(fixture.data)
+      it(`should decode ${fixture.type}=${fixture.label || fixture.expected}`, () => {
+        let actual = decode(data)
+        assert.strictEqual(actual, fixture.expected, `decode ${fixture.type}`)
+        if (fixture.strict === false) {
+          assert.throws(() => decode(data, { strict: true }), Error, 'CBOR decode error: integer encoded in more bytes than necessary (strict decode)')
+        } else {
+          actual = decode(data, { strict: true })
+          assert.strictEqual(actual, fixture.expected, `decode ${fixture.type} strict`)
+        }
+      })
+
+      it('should fail to decode very large length', () => {
+        assert.throws(
+          () => decode(fromHex('7ba5f702b3a5f702b34c6f72656d20697073756d20646f6c6f722073697420616d65742c20636f6e73656374657475722061646970697363696e6720656c69742e20446f6e6563206d692074656c6c75732c20696163756c6973206e656320766573746962756c756d20717569732c206665726d656e74756d206e6f6e2066656c69732e204d616563656e6173207574206a7573746f20706f73756572652e')),
+          /CBOR decode error: 64-bit integer string lengths not supported/)
+      })
+    }
+  })
+
+  describe('encode', () => {
+    for (const fixture of fixtures) {
+      if (fixture.data.length >= 100000000) {
+        it.skip(`(TODO) skipping encode of very large string ${fixture.type}=${fixture.label || fixture.expected}`, () => {})
+        continue
+      }
+
+      const data = fixture.expected
+      const expectedHex = toHex(fixture.data)
+
+      it(`should encode ${fixture.type}=${fixture.label || fixture.expected}`, () => {
+        if (fixture.unsafe) {
+          assert.throws(() => encode(data), Error, /^CBOR encode error: number too large to encode \(-\d+\)$/)
+        } else if (fixture.strict === false) {
+          assert.notStrictEqual(toHex(encode(data)), expectedHex, `encode ${fixture.type} !strict`)
+        } else {
+          assert.strictEqual(toHex(encode(data)), expectedHex, `encode ${fixture.type}`)
+        }
+      })
+    }
+  })
+})

package/src/cborg/test/test-4array.js

@@ -0,0 +1,93 @@
+/* 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
+
+const fixtures = [
+  { data: '80', expected: [], type: 'array empty' },
+  { data: '8102', expected: [2], type: 'array 1 compact uint' },
+  { data: '8118ff', expected: [255], type: 'array 1 uint8' },
+  { data: '811901f4', expected: [500], type: 'array 1 uint16' },
+  { data: '811a00010000', expected: [65536], type: 'array 1 uint32' },
+  { data: '811b00000000000000ff', expected: [255], type: 'array 1 uint64', strict: false },
+  { data: '811b0016db6db6db6db7', expected: [Number.MAX_SAFE_INTEGER / 1.4], type: 'array 1 uint64' },
+  { data: '811b001fffffffffffff', expected: [Number.MAX_SAFE_INTEGER], type: 'array 1 uint64' },
+  { data: '8403040506', expected: [3, 4, 5, 6], type: 'array 4 ints' },
+  {
+    data: '8c1b0016db6db6db6db71a000100001901f40200202238ff3aa5f702b33b0016db6db6db6db74261316fc48c6175657320c39f76c49b746521',
+    expected: [Number.MAX_SAFE_INTEGER / 1.4, 65536, 500, 2, 0, -1, -3, -256, -2784428724, Number.MIN_SAFE_INTEGER / 1.4 - 1, new TextEncoder().encode('a1'), 'Čaues ßvěte!'],
+    type: 'array mixed terminals',
+    label: '[]'
+  },
+  {
+    data: '8265617272617982626f66820582666e657374656482666172726179736121',
+    expected: ['array', ['of', [5, ['nested', ['arrays', '!']]]]],
+    type: 'array nested'
+  },
+  // testing lengths encoded as too-large ints
+  { data: '980403040506', expected: [3, 4, 5, 6], type: 'array 4 ints, length8', strict: false },
+  { data: '99000403040506', expected: [3, 4, 5, 6], type: 'array 4 ints, length16', strict: false },
+  { data: '9a0000000403040506', expected: [3, 4, 5, 6], type: 'array 4 ints, length32', strict: false },
+  { data: '9b000000000000000403040506', expected: [3, 4, 5, 6], type: 'array 4 ints, length64', strict: false }
+]
+
+describe('array', () => {
+  describe('decode', () => {
+    for (const fixture of fixtures) {
+      const data = fromHex(fixture.data)
+      it(`should decode ${fixture.type}=${fixture.label || fixture.expected}`, () => {
+        assert.deepStrictEqual(decode(data), fixture.expected, `decode ${fixture.type}`)
+        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.deepStrictEqual(decode(data, { strict: true }), fixture.expected, `decode ${fixture.type}`)
+        }
+      })
+
+      it('should fail to decode very large length', () => {
+        assert.throws(
+          () => decode(fromHex('9ba5f702b3a5f7020403040506')),
+          /CBOR decode error: 64-bit integer array lengths not supported/)
+      })
+    }
+  })
+
+  describe('encode', () => {
+    for (const fixture of fixtures) {
+      it(`should encode ${fixture.type}=${fixture.label || fixture.expected}`, () => {
+        if (fixture.unsafe) {
+          assert.throws(encode.bind(null, fixture.expected), Error, /^CBOR encode error: number too large to encode \(\d+\)$/)
+        } else if (fixture.strict === false) {
+          assert.notDeepEqual(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.unsafe && fixture.strict !== false) {
+        it(`should roundtrip ${fixture.type}=${fixture.label || fixture.expected}`, () => {
+          assert.deepStrictEqual(decode(encode(fixture.expected)), fixture.expected, `roundtrip ${fixture.type}`)
+        })
+      }
+    }
+  })
+
+  describe('specials', () => {
+    it('can decode indefinite length items', () => {
+      assert.deepStrictEqual(decode(fromHex('9f616f6174ff')), ['o', 't'])
+    })
+
+    it('can switch off indefinite length support', () => {
+      assert.throws(() => decode(fromHex('9f616f6174ff'), { allowIndefinite: false }), /indefinite/)
+    })
+  })
+})