@fireproof/vendor 0.0.0-smoke → 0.22.0-dev-preview

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

@@ -1,198 +0,0 @@
-/* eslint-env mocha */
-
-import * as chai from 'chai'
-
-import { decode, encode } from '../cborg.js'
-import { useBuffer, fromHex, toHex } from '../lib/byte-utils.js'
-
-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/cborg/test/test-3string.js

@@ -1,136 +0,0 @@
-/* eslint-env mocha */
-
-import * as chai from 'chai'
-
-import { decode, encode } from '../cborg.js'
-import { fromHex, toHex } from '../lib/byte-utils.js'
-
-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/cborg/test/test-4array.js

@@ -1,93 +0,0 @@
-/* eslint-env mocha */
-
-import * as chai from 'chai'
-
-import { decode, encode } from '../cborg.js'
-import { fromHex, toHex } from '../lib/byte-utils.js'
-
-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/)
-    })
-  })
-})