@fireproof/vendor 0.0.0-smoke → 1.0.0

package/src/cborg/cborg/test/test-5map.js

@@ -1,284 +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
-
-// TODO: reject duplicate keys from encoded form
-
-const fixtures = [
-  { data: 'a0', expected: {}, type: 'map empty' },
-  { data: 'a0', expected: new Map(), type: 'map empty (useMaps)', useMaps: true },
-  { data: 'a1616101', expected: { a: 1 }, type: 'map 1 pair' },
-  { data: 'a161316161', expected: { 1: 'a' }, type: 'map 1 pair (rev)' },
-  {
-    data: 'a1016161',
-    expected: toMap([[1, 'a']]),
-    type: 'map 1 pair (int key as Map w/ useMaps)',
-    useMaps: true
-  },
-  {
-    data: 'a243010203633132334302030463323334',
-    expected: toMap([[Uint8Array.from([1, 2, 3]), '123'], [Uint8Array.from([2, 3, 4]), '234']]),
-    type: 'map 2 pair (bytes keys Map w/ useMaps)',
-    useMaps: true
-  },
-  {
-    data: 'a1666f626a656374a16477697468a26134666e6573746564676f626a65637473a161216121',
-    expected: { object: { with: { 4: 'nested', objects: { '!': '!' } } } },
-    type: 'map nested'
-  },
-  { // same as previous but as a Map and an int key
-    data: 'a1666f626a656374a16477697468a204666e6573746564676f626a65637473a161216121',
-    expected: toMap([['object', toMap([['with', toMap([[4, 'nested'], ['objects', toMap([['!', '!']])]])]])]]),
-    type: 'map nested w/ useMaps',
-    useMaps: true
-  },
-  {
-    data: 'ae636f6e651b0016db6db6db6db763736978206374656e3b0016db6db6db6db76374776f1a0001000064666976650064666f757202646e696e653aa5f702b365656967687438ff65736576656e226574687265651901f466656c6576656e426131667477656c76656fc48c6175657320c39f76c49b74652168666f75727465656ea4616664666f7572616f016174026274680368746869727465656e840203046466697665',
-    encode: {
-      one: Number.MAX_SAFE_INTEGER / 1.4,
-      two: 65536,
-      three: 500,
-      four: 2,
-      five: 0,
-      six: -1,
-      seven: -3,
-      eight: -256,
-      nine: -2784428724,
-      ten: Number.MIN_SAFE_INTEGER / 1.4 - 1,
-      eleven: new TextEncoder().encode('a1'),
-      twelve: 'Čaues ßvěte!',
-      thirteen: [2, 3, 4, 'five'],
-      fourteen: { o: 1, t: 2, th: 3, f: 'four' }
-    },
-    expected: {
-      one: Number.MAX_SAFE_INTEGER / 1.4,
-      six: -1,
-      ten: Number.MIN_SAFE_INTEGER / 1.4 - 1,
-      two: 65536,
-      five: 0,
-      four: 2,
-      nine: -2784428724,
-      eight: -256,
-      seven: -3,
-      three: 500,
-      eleven: new TextEncoder().encode('a1'),
-      twelve: 'Čaues ßvěte!',
-      fourteen: { f: 'four', o: 1, t: 2, th: 3 },
-      thirteen: [2, 3, 4, 'five']
-    },
-    type: 'map with complex entries',
-    label: '{}'
-  },
-  {
-    data: 'ad01636f6e65026374776f1901f46c666976652068756e647265641902586b7369782068756e647265641a00010000636269671b0016db6db6db6db76662696767657220696d696e7573206f6e6521696d696e75732074776f38ff781f6d696e75732074776f2068756e6472656420616e64206669667479207369783901f4781a6d696e757820666976652068756e6472656420616e64206f6e653901f5781a6d696e757820666976652068756e6472656420616e642074776f3aa5f702b367626967206e65673b0016db6db6db6db76a626967676572206e6567',
-    encode: toMap([
-      [2, 'two'],
-      [1, 'one'],
-      [-2, 'minus two'],
-      [-1, 'minus one'],
-      [600, 'six hundred'],
-      [500, 'five hundred'],
-      [-256, 'minus two hundred and fifty six'],
-      [-502, 'minux five hundred and two'],
-      [-501, 'minux five hundred and one'],
-      [65536, 'big'],
-      [-2784428724, 'big neg'],
-      [6433713753386423, 'bigger'],
-      [-6433713753386424, 'bigger neg']
-    ]),
-    expected: toMap([
-      [1, 'one'],
-      [2, 'two'],
-      [500, 'five hundred'],
-      [600, 'six hundred'],
-      [65536, 'big'],
-      [6433713753386423, 'bigger'],
-      [-1, 'minus one'],
-      [-2, 'minus two'],
-      [-256, 'minus two hundred and fifty six'],
-      [-501, 'minux five hundred and one'],
-      [-502, 'minux five hundred and two'],
-      [-2784428724, 'big neg'],
-      [-6433713753386424, 'bigger neg']
-    ]),
-    type: 'map with ints and negints',
-    useMaps: true
-  },
-  {
-    data: 'a44104636f6e65430102026374776f430102036574687265654301020464666f7572',
-    encode: toMap([
-      [Uint8Array.from([1, 2, 3]), 'three'],
-      [Uint8Array.from([4]), 'one'],
-      [Uint8Array.from([1, 2, 4]), 'four'],
-      [Uint8Array.from([1, 2, 2]), 'two']
-    ]),
-    expected: toMap([
-      [Uint8Array.from([4]), 'one'],
-      [Uint8Array.from([1, 2, 2]), 'two'],
-      [Uint8Array.from([1, 2, 3]), 'three'],
-      [Uint8Array.from([1, 2, 4]), 'four']
-    ]),
-    type: 'map with bytes keys',
-    useMaps: true
-  },
-  // testing lengths encoded as too-large ints
-  { data: 'b801616101', expected: { a: 1 }, type: 'map 1 pair, length8', strict: false },
-  { data: 'b90001616101', expected: { a: 1 }, type: 'map 1 pair, length16', strict: false },
-  { data: 'ba00000001616101', expected: { a: 1 }, type: 'map 1 pair, length32', strict: false },
-  { data: 'bb0000000000000001616101', expected: { a: 1 }, type: 'map 1 pair, length64', strict: false }
-]
-
-function toMap (arr) {
-  const m = new Map()
-  for (const [key, value] of arr) {
-    m.set(key, value)
-  }
-  return m
-}
-
-function entries (map) {
-  function nest (a) {
-    for (const e of a) {
-      e[0] = entries(e[0])
-      e[1] = entries(e[1])
-    }
-    return a
-  }
-
-  if (Object.getPrototypeOf(map) === Map.prototype) {
-    return nest([...map.entries()])
-  }
-  if (typeof map === 'object') {
-    return nest([...Object.entries(map)])
-  }
-  return map
-}
-
-describe('map', () => {
-  describe('decode', () => {
-    for (const fixture of fixtures) {
-      const data = fromHex(fixture.data)
-      it(`should decode ${fixture.type}=${fixture.label || JSON.stringify(fixture.expected)}`, () => {
-        let options = fixture.useMaps ? { useMaps: true } : undefined
-        const decoded = decode(data, options)
-
-        if (fixture.useMaps) {
-          assert.strictEqual(Object.getPrototypeOf(decoded), Map.prototype, 'is Map')
-        } else {
-          assert.isObject(decoded, 'is object')
-        }
-
-        assert.deepStrictEqual(entries(decoded), entries(fixture.expected), `decode ${fixture.type}`)
-
-        options = Object.assign({ strict: true }, options)
-        if (fixture.strict === false) {
-          assert.throws(() => decode(data, options), Error, 'CBOR decode error: integer encoded in more bytes than necessary (strict decode)')
-        } else {
-          assert.deepStrictEqual(
-            entries(decode(data, options)),
-            entries(fixture.expected),
-            `decode ${fixture.type}`)
-        }
-      })
-
-      it('should fail to decode very large length', () => {
-        assert.throws(
-          () => decode(fromHex('bba5f702b3a5f70201616101')),
-          /CBOR decode error: 64-bit integer map lengths not supported/)
-      })
-    }
-
-    it('errors', () => {
-      assert.throws(() => decode(fromHex('a1016161')), /non-string keys not supported \(got number\)/)
-    })
-  })
-
-  describe('encode', () => {
-    for (const fixture of fixtures) {
-      it(`should encode ${fixture.type}=${fixture.label || JSON.stringify(fixture.expected)}`, () => {
-        const toEncode = fixture.encode || fixture.expected
-        if (fixture.unsafe) {
-          assert.throws(encode.bind(null, toEncode), Error, /^CBOR encode error: number too large to encode \(\d+\)$/)
-        } else if (fixture.strict === false || fixture.roundtrip === false) {
-          assert.notDeepEqual(toHex(encode(toEncode)), fixture.data, `encode ${fixture.type} !strict`)
-        } else {
-          assert.strictEqual(toHex(encode(toEncode)), fixture.data, `encode ${fixture.type}`)
-        }
-      })
-    }
-  })
-
-  // mostly unnecessary, but feels good
-  describe('roundtrip', () => {
-    for (const fixture of fixtures) {
-      if (!fixture.unsafe && fixture.strict !== false && fixture.roundtrip !== false) {
-        it(`should roundtrip ${fixture.type}=${fixture.label || JSON.stringify(fixture.expected)}`, () => {
-          const toEncode = fixture.encode || fixture.expected
-          const options = fixture.useMaps ? { useMaps: true } : undefined
-          const rt = decode(encode(toEncode), options)
-
-          if (fixture.useMaps) {
-            assert.strictEqual(Object.getPrototypeOf(rt), Map.prototype, 'is Map')
-          } else {
-            assert.isObject(rt, 'is object')
-          }
-
-          assert.deepStrictEqual(entries(rt), entries(fixture.expected), `roundtrip ${fixture.type}`)
-        })
-      }
-    }
-  })
-
-  describe('specials', () => {
-    it('can decode indefinite length items', () => {
-      assert.deepStrictEqual(decode(fromHex('bf616f01617402ff')), { o: 1, t: 2 })
-    })
-
-    it('can switch off indefinite length support', () => {
-      assert.throws(() => decode(fromHex('bf616f01617402ff'), { allowIndefinite: false }), /indefinite/)
-    })
-  })
-
-  describe('sorting', () => {
-    it('sorts int map keys', () => {
-      assert.strictEqual(toHex(encode(new Map([[1, 1], [2, 2]]))), 'a201010202')
-      assert.strictEqual(toHex(encode(new Map([[2, 1], [1, 2]]))), 'a201020201')
-    })
-
-    it('sorts negint map keys', () => {
-      assert.strictEqual(toHex(encode(new Map([[-1, 1], [-2, 2]]))), 'a220012102')
-      assert.strictEqual(toHex(encode(new Map([[-2, 1], [-1, 2]]))), 'a220022101')
-    })
-
-    it('sorts bytes map keys', () => {
-      assert.strictEqual(toHex(encode(new Map([[Uint8Array.from([1, 2]), 1], [Uint8Array.from([2, 1]), 2]]))), 'a24201020142020102')
-      assert.strictEqual(toHex(encode(new Map([[Uint8Array.from([2, 1]), 1], [Uint8Array.from([1, 2]), 2]]))), 'a24201020242020101')
-      // shortest first
-      assert.strictEqual(toHex(encode(new Map([[Uint8Array.from([1, 2]), 1], [Uint8Array.from([2, 1]), 2], [Uint8Array.from([200]), 3]]))), 'a341c8034201020142020102')
-    })
-
-    it('sorts bytes map keys', () => {
-      assert.strictEqual(toHex(encode(new Map([[Uint8Array.from([1, 2]), 1], [Uint8Array.from([2, 1]), 2]]))), 'a24201020142020102')
-      assert.strictEqual(toHex(encode(new Map([[Uint8Array.from([2, 1]), 1], [Uint8Array.from([1, 2]), 2]]))), 'a24201020242020101')
-      // shortest first
-      assert.strictEqual(toHex(encode(new Map([[Uint8Array.from([1, 2]), 1], [Uint8Array.from([2, 1]), 2], [Uint8Array.from([200]), 3]]))), 'a341c8034201020142020102')
-    })
-
-    it('sorts array map keys (length only)', () => {
-      assert.strictEqual(toHex(encode(new Map([[[1], 1], [[1, 1], 2]]))), 'a281010182010102')
-      assert.strictEqual(toHex(encode(new Map([[[1, 1], 1], [[1], 2]]))), 'a281010282010101')
-    })
-
-    it('sorts map map keys (length only)', () => {
-      assert.strictEqual(toHex(encode(new Map([[{ a: 1 }, 1], [{ a: 1, b: 1 }, 2]]))), 'a2a161610101a261610161620102')
-      assert.strictEqual(toHex(encode(new Map([[{ a: 1, b: 1 }, 1], [{ a: 1 }, 2]]))), 'a2a161610102a261610161620101')
-    })
-
-    // TODO: tag keys .. but why would you do this!?
-  })
-})

package/src/cborg/cborg/test/test-6tag.js

@@ -1,85 +0,0 @@
-/* eslint-env mocha */
-
-import * as chai from 'chai'
-
-import { Token, Type } from '../lib/token.js'
-import { decode, encode } from '../cborg.js'
-import { fromHex, toHex } from '../lib/byte-utils.js'
-import { dateDecoder, dateEncoder } from './common.js'
-
-const { assert } = chai
-
-function Uint16ArrayDecoder (obj) {
-  if (typeof obj !== 'string') {
-    throw new Error('expected string for tag 23')
-  }
-  const u8a = fromHex(obj)
-  return new Uint16Array(u8a.buffer, u8a.byteOffset, u8a.length / 2)
-}
-
-function Uint16ArrayEncoder (obj) {
-  if (!(obj instanceof Uint16Array)) {
-    throw new Error('expected Uint16Array for "Uint16Array" encoder')
-  }
-  return [
-    new Token(Type.tag, 23),
-    new Token(Type.string, toHex(obj))
-  ]
-}
-
-describe('tag', () => {
-  it('date', () => {
-    assert.throws(() => encode({ d: new Date() }), /unsupported type: Date/)
-
-    assert.equal(
-      toHex(encode(new Date('2013-03-21T20:04:00Z'), { typeEncoders: { Date: dateEncoder } })),
-      'c074323031332d30332d32315432303a30343a30305a' // from appendix_a
-    )
-
-    const decodedDate = decode(fromHex('c074323031332d30332d32315432303a30343a30305a'), { tags: { 0: dateDecoder } })
-    assert.instanceOf(decodedDate, Date)
-    assert.equal(decodedDate.toISOString(), new Date('2013-03-21T20:04:00Z').toISOString())
-  })
-
-  it('Uint16Array as hex/23 (overide existing type)', () => {
-    assert.equal(
-      toHex(encode(Uint16Array.from([1, 2, 3]), { typeEncoders: { Uint16Array: Uint16ArrayEncoder } })),
-      'd76c303130303032303030333030' // tag(23) + string('010002000300')
-    )
-
-    const decoded = decode(fromHex('d76c303130303032303030333030'), { tags: { 23: Uint16ArrayDecoder } })
-    assert.instanceOf(decoded, Uint16Array)
-    assert.equal(toHex(decoded), toHex(Uint16Array.from([1, 2, 3])))
-  })
-
-  it('tag int too large', () => {
-    const verify = (hex, strict) => {
-      if (!strict) {
-        assert.throws(
-          () => decode(fromHex(hex), { tags: { 8: dateDecoder }, strict: true }),
-          /integer encoded in more bytes than necessary/)
-      }
-      const decodedDate = decode(fromHex(hex), { tags: { 8: dateDecoder }, strict })
-      assert.instanceOf(decodedDate, Date)
-      assert.equal(decodedDate.toISOString(), new Date('2013-03-21T20:04:00Z').toISOString())
-    }
-    // compact
-    verify('c874323031332d30332d32315432303a30343a30305a', true)
-    // int8
-    verify('d80874323031332d30332d32315432303a30343a30305a', false)
-    // int16
-    verify('d9000874323031332d30332d32315432303a30343a30305a', false)
-    // int32
-    verify('da0000000874323031332d30332d32315432303a30343a30305a', false)
-    // int64
-    verify('db000000000000000874323031332d30332d32315432303a30343a30305a', false)
-  })
-
-  /*
-  describe('taglib', () => {
-    it('bigint', () => {
-      const v = BigInt(2) ** BigInt(80)
-    })
-  })
-  */
-})

package/src/cborg/cborg/test/test-7float.js

@@ -1,131 +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: '8601f5f4f6f720', expected: [1, true, false, null, undefined, -1], type: 'array of float specials' },
-  { data: 'f93800', expected: 0.5, type: 'float16' },
-  { data: 'f9b800', expected: -0.5, type: 'float16' },
-  { data: 'fa33c00000', expected: 8.940696716308594e-08, type: 'float32' },
-  { data: 'fab3c00000', expected: -8.940696716308594e-08, type: 'float32' },
-  { data: 'fb3ff199999999999a', expected: 1.1, type: 'float64' },
-  { data: 'fbbff199999999999a', expected: -1.1, type: 'float64' },
-  { data: 'fb3ff1c71c71c71c72', expected: 1.11111111111111111111111111111, type: 'float64' }, // eslint-disable-line
-  { data: 'fb0000000000000002', expected: 1e-323, type: 'float64' },
-  { data: 'fb8000000000000002', expected: -1e-323, type: 'float64' },
-  { data: 'fb3fefffffffffffff', expected: 0.9999999999999999, type: 'float64' },
-  { data: 'fbbfefffffffffffff', expected: -0.9999999999999999, type: 'float64' },
-  { data: 'f97c00', expected: Infinity, type: 'Infinity' }, // special CBOR token for -Infinity
-  { data: 'fb7ff0000000000000', expected: Infinity, type: 'Infinity', strict: false }, // an IEEE 754 representation of Infinity
-  { data: 'f9fc00', expected: -Infinity, type: '-Infinity' }, // special CBOR token for -Infinity
-  { data: 'fbfff0000000000000', expected: -Infinity, type: '-Infinity', strict: false }, // an IEEE 754 representation of Infinity
-  { data: 'f97e00', expected: NaN, type: 'NaN' }, // special CBOR token for NaN
-  { data: 'f97ff8', expected: NaN, type: 'NaN', strict: false }, // one of the many IEEE 754 representations of NaN
-  { data: 'fa7ff80000', expected: NaN, type: 'NaN', strict: false },
-  { data: 'fb7ff8000000000000', expected: NaN, type: 'NaN', strict: false },
-  { data: 'fb7ff8cafedeadbeef', expected: NaN, type: 'NaN', strict: false }, // yep, that's NaN too
-  { data: 'fb40f4241a31a5a515', expected: 82497.63712086187, type: 'float64' }
-]
-
-describe('float', () => {
-  describe('decode', () => {
-    for (const fixture of fixtures) {
-      const data = fromHex(fixture.data)
-      it(`should decode ${fixture.type}=${fixture.expected}`, () => {
-        assert.deepStrictEqual(decode(data), fixture.expected, `decode ${fixture.type}`)
-        assert.deepStrictEqual(decode(data, { strict: true }), fixture.expected, `decode ${fixture.type}`)
-      })
-    }
-  })
-
-  it('error', () => {
-    // minor number 28, too high for uint
-    assert.throws(() => decode(fromHex('f80000')), Error, 'simple values are not supported')
-    assert.throws(() => decode(fromHex('f900')), Error, 'not enough data for float16')
-    assert.throws(() => decode(fromHex('fa0000')), Error, 'not enough data for float32')
-    assert.throws(() => decode(fromHex('fb00000000')), Error, 'not enough data for float64')
-  })
-
-  describe('encode', () => {
-    for (const fixture of fixtures) {
-      if (fixture.strict !== false) {
-        it(`should encode ${fixture.type}=${fixture.expected}`, () => {
-          assert.strictEqual(toHex(encode(fixture.expected)), fixture.data, `encode ${fixture.type}`)
-        })
-      }
-    }
-  })
-
-  describe('encode float64', () => {
-    for (const fixture of fixtures) {
-      if (fixture.type.startsWith('float')) {
-        it(`should encode ${fixture.type}=${fixture.expected}`, () => {
-          const encoded = encode(fixture.expected, { float64: true })
-          assert.strictEqual(encoded.length, 9) // always encode as 9 bytes, regardless of size
-          assert.strictEqual(encoded[0], 0xfb)
-          assert.strictEqual(decode(encoded), fixture.expected, `encode float64 ${fixture.type}`)
-        })
-      }
-    }
-  })
-
-  describe('roundtrip', () => {
-    for (const fixture of fixtures) {
-      if (!fixture.unsafe && fixture.strict !== false) {
-        it(`should roundtrip ${fixture.type}=${fixture.expected}`, () => {
-          assert.deepStrictEqual(decode(encode(fixture.expected)), fixture.expected, `roundtrip ${fixture.type}`)
-        })
-      }
-    }
-  })
-
-  describe('specials', () => {
-    // This is a bit of a hack, the CBOR is invalid because it's a standard fixed-length array
-    // followed by a BREAK, which should normally error ("too many terminals"), but we want to
-    // exercise the allowIndefinite switch in the major-7 decode and it should error before it
-    // even gets to looking at terminals and whether the tokens make sense.
-    it('indefinite length switch fails on BREAK', () => {
-      // sanity check, BREAK doesn't belong there
-      assert.throws(() => decode(Uint8Array.from([131, 1, 2, 0xff])), /unexpected break to lengthed array/)
-      // throw earlier because we're disallowing BREAK entirely
-      assert.throws(() => decode(Uint8Array.from([131, 1, 2, 0xff]), { allowIndefinite: false }), /indefinite/)
-    })
-
-    it('can switch off undefined support', () => {
-      assert.deepStrictEqual(decode(fromHex('f7')), undefined)
-      assert.throws(() => decode(fromHex('f7'), { allowUndefined: false }), /undefined/)
-      assert.deepStrictEqual(decode(fromHex('830102f7')), [1, 2, undefined])
-      assert.throws(() => decode(fromHex('830102f7'), { allowUndefined: false }), /undefined/)
-    })
-
-    it('can coerce undefined to null', () => {
-      assert.deepStrictEqual(decode(fromHex('f7'), { coerceUndefinedToNull: false }), undefined)
-      assert.deepStrictEqual(decode(fromHex('f7'), { coerceUndefinedToNull: true }), null)
-      assert.deepStrictEqual(decode(fromHex('830102f7'), { coerceUndefinedToNull: false }), [1, 2, undefined])
-      assert.deepStrictEqual(decode(fromHex('830102f7'), { coerceUndefinedToNull: true }), [1, 2, null])
-    })
-
-    it('can switch off Infinity support', () => {
-      assert.deepStrictEqual(decode(fromHex('830102f97c00')), [1, 2, Infinity])
-      assert.deepStrictEqual(decode(fromHex('830102f9fc00')), [1, 2, -Infinity])
-      assert.throws(() => decode(fromHex('830102f97c00'), { allowInfinity: false }), /Infinity/)
-      assert.throws(() => decode(fromHex('830102f9fc00'), { allowInfinity: false }), /Infinity/)
-      for (const fixture of fixtures.filter((f) => f.type.endsWith('Infinity'))) {
-        assert.throws(() => decode(fromHex(fixture.data), { allowInfinity: false }), /Infinity/)
-      }
-    })
-
-    it('can switch off NaN support', () => {
-      assert.deepStrictEqual(decode(fromHex('830102f97e00')), [1, 2, NaN])
-      assert.throws(() => decode(fromHex('830102f97e00'), { allowNaN: false }), /NaN/)
-      for (const fixture of fixtures.filter((f) => f.type === 'NaN')) {
-        assert.throws(() => decode(fromHex(fixture.data), { allowNaN: false }), /NaN/)
-      }
-    })
-  })
-})

package/src/cborg/cborg/test/test-bl.js

@@ -1,37 +0,0 @@
-/* eslint-env mocha */
-
-import * as chai from 'chai'
-import { Bl } from '../lib/bl.js'
-
-const { assert } = chai
-
-describe('Internal bytes list', () => {
-  describe('push', () => {
-    it('push bits', () => {
-      const bl = new Bl(10)
-      const expected = []
-      for (let i = 0; i < 25; i++) {
-        bl.push([i + 1])
-        expected.push(i + 1)
-      }
-      assert.deepEqual([...bl.toBytes()], expected)
-    })
-
-    for (let i = 4; i < 21; i++) {
-      it(`push Bl(${i})`, () => {
-        const bl = new Bl(i)
-        const expected = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 110, 120, 11, 12, 130, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23]
-        for (let i = 0; i < 5; i++) {
-          bl.push([i + 1])
-        }
-        bl.push(Uint8Array.from([6, 7, 8, 9, 10]))
-        bl.push([100])
-        bl.push(Uint8Array.from([110, 120]))
-        bl.push(Uint8Array.from([11, 12]))
-        bl.push([130])
-        bl.push(Uint8Array.from([13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23]))
-        assert.deepEqual([...bl.toBytes()], expected)
-      })
-    }
-  })
-})

package/src/cborg/cborg/test/test-decode-errors.js

@@ -1,65 +0,0 @@
-/* eslint-env mocha */
-
-import * as chai from 'chai'
-
-import { decode } from '../cborg.js'
-import { fromHex } from '../lib/byte-utils.js'
-
-const { assert } = chai
-
-describe('decode errors', () => {
-  it('not Uint8Array', () => {
-    for (const arg of [true, false, null, undefined, 'string', { obj: 'ect' }, {}, ['array'], [], [1, 2, 3], 0, 100, 1.1, -1, Symbol.for('nope')]) {
-      assert.throws(() => decode(arg), /CBOR decode error.*must be a Uint8Array/)
-    }
-  })
-
-  it('no data', () => {
-    assert.throws(() => decode(new Uint8Array('')), /CBOR decode error.*content/)
-  })
-
-  it('break only', () => {
-    assert.throws(() => decode(new Uint8Array([255])), /CBOR decode error.*break/)
-  })
-
-  it('not enough map entries (value)', () => {
-    // last value missing
-    assert.throws(() => decode(fromHex('a2616f016174')), /map.*not enough entries.*value/)
-  })
-
-  it('not enough map entries (key)', () => {
-    // last key & value missing
-    assert.throws(() => decode(fromHex('a2616f01')), /map.*not enough entries.*key/)
-  })
-
-  it('break in lengthed map', () => {
-    // 0xff (break) in the middle
-    assert.throws(() => decode(fromHex('a2616f01ff740f')), /unexpected break to lengthed map/)
-  })
-
-  it('not enough array entries', () => {
-    // last value missing
-    assert.throws(() => decode(fromHex('82616f')), /array.*not enough entries/)
-  })
-
-  it('break in lengthed array', () => {
-    // last value missing
-    assert.throws(() => decode(fromHex('82ff')), /unexpected break to lengthed array/)
-  })
-
-  it('no such decoder', () => {
-    // last value missing
-    assert.throws(() => decode(fromHex('82ff')), /unexpected break to lengthed array/)
-  })
-
-  it('too many terminals', () => {
-    // two '1's
-    assert.throws(() => decode(fromHex('0101')), /too many terminals/)
-  })
-
-  it('rejectDuplicateMapKeys enabled on duplicate keys', () => {
-    assert.deepStrictEqual(decode(fromHex('a3636261720363666f6f0163666f6f02')), { foo: 2, bar: 3 })
-    assert.throws(() => decode(fromHex('a3636261720363666f6f0163666f6f02'), { rejectDuplicateMapKeys: true }), /CBOR decode error: found repeat map key "foo"/)
-    assert.throws(() => decode(fromHex('a3636261720363666f6f0163666f6f02'), { useMaps: true, rejectDuplicateMapKeys: true }), /CBOR decode error: found repeat map key "foo"/)
-  })
-})

package/src/cborg/cborg/test/test-fuzz.js

@@ -1,42 +0,0 @@
-/* eslint-env mocha */
-
-import { garbage } from 'ipld-garbage'
-import { decode, encode } from '../cborg.js'
-import * as chai from 'chai'
-
-const { assert } = chai
-
-describe('Fuzz round-trip', () => {
-  it('random objects', function () {
-    this.timeout(5000)
-    for (let i = 0; i < 1000; i++) {
-      const obj = garbage(300, { weights: { CID: 0 } })
-      const byts = encode(obj)
-      const decoded = decode(byts)
-      assert.deepEqual(decoded, obj)
-    }
-  })
-
-  it('circular references error', () => {
-    let obj = {}
-    obj.obj = obj
-    assert.throws(() => encode(obj), /circular references/)
-
-    obj = { blip: [1, 2, { blop: {} }] }
-    obj.blip[2].blop.boop = obj
-    assert.throws(() => encode(obj), /circular references/)
-
-    obj = { blip: [1, 2, { blop: {} }] }
-    obj.blip[2].blop.boop = obj.blip
-    assert.throws(() => encode(obj), /circular references/)
-
-    // not circular but a naive check might decide it is
-    obj = { blip: {}, bloop: {} }
-    obj.bloop = obj.blip
-    assert.doesNotThrow(() => encode(obj))
-
-    const arr = []
-    arr[0] = arr
-    assert.throws(() => encode(arr), /circular references/)
-  })
-})