@ipld/car 4.1.6 → 5.0.1

package/cjs/node-test/node-test-updateroots.js

@@ -1,78 +0,0 @@
-'use strict';
-
-var path = require('path');
-var url = require('url');
-var fs = require('fs');
-var util = require('util');
-var cid = require('multiformats/cid');
-var reader = require('../lib/reader.js');
-var writer = require('../lib/writer.js');
-var verifyStoreReader = require('./verify-store-reader.js');
-var common = require('./common.js');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
-
-const fsopen = util.promisify(fs__default["default"].open);
-const fsclose = util.promisify(fs__default["default"].close);
-const __filename$1 = url.fileURLToPath((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('node-test/node-test-updateroots.js', document.baseURI).href)));
-const __dirname$1 = path__default["default"].dirname(__filename$1);
-const goCarPath = path__default["default"].join(__dirname$1, 'go.car');
-const tmpCarPath = path__default["default"].join(__dirname$1, 'tmp.car');
-const newRoots = [
-  cid.CID.parse('bafkreidbxzk2ryxwwtqxem4l3xyyjvw35yu4tcct4cqeqxwo47zhxgxqwq'),
-  cid.CID.parse('bafkreiebzrnroamgos2adnbpgw5apo3z4iishhbdx77gldnbk57d4zdio4')
-];
-async function verify() {
-  const reader$1 = await reader.CarReader.fromIterable(fs__default["default"].createReadStream(tmpCarPath));
-  await common.assert.isRejected(verifyStoreReader.verifyRoots(reader$1));
-  common.assert.deepEqual(await reader$1.getRoots(), newRoots);
-  await verifyStoreReader.verifyHas(reader$1);
-  await verifyStoreReader.verifyGet(reader$1);
-  await verifyStoreReader.verifyBlocks(reader$1.blocks(), true);
-  await verifyStoreReader.verifyCids(reader$1.cids(), true);
-}
-describe('Node CarWriter.updateHeader()', () => {
-  before(async () => {
-    try {
-      await fs__default["default"].promises.unlink(tmpCarPath);
-    } catch (e) {
-    }
-  });
-  beforeEach(async () => {
-    await fs__default["default"].promises.copyFile(goCarPath, tmpCarPath);
-  });
-  afterEach(async () => {
-    await fs__default["default"].promises.unlink(tmpCarPath);
-  });
-  it('update roots (fd)', async () => {
-    const fd = await fsopen(tmpCarPath, 'r+');
-    await writer.CarWriter.updateRootsInFile(fd, newRoots);
-    await fsclose(fd);
-    await verify();
-  });
-  it('update roots (FileHandle)', async () => {
-    const fd = await fs__default["default"].promises.open(tmpCarPath, 'r+');
-    await writer.CarWriter.updateRootsInFile(fd, newRoots);
-    await fd.close();
-    await verify();
-  });
-  it('error: bad fd', async () => {
-    await common.assert.isRejected(writer.CarWriter.updateRootsInFile(true, newRoots), {
-      name: 'TypeError',
-      message: 'Bad fd'
-    });
-  });
-  it('error: wrong header size', async () => {
-    const fd = await fs__default["default"].promises.open(tmpCarPath, 'r+');
-    await common.assert.isRejected(writer.CarWriter.updateRootsInFile(fd, [
-      ...newRoots,
-      newRoots[0]
-    ]), /can only overwrite a header of the same length/);
-    await common.assert.isRejected(writer.CarWriter.updateRootsInFile(fd, [newRoots[0]]), /can only overwrite a header of the same length/);
-    await common.assert.isRejected(writer.CarWriter.updateRootsInFile(fd, []), /can only overwrite a header of the same length/);
-    await fd.close();
-  });
-});

package/cjs/node-test/test-buffer-writer.js

@@ -1,330 +0,0 @@
-'use strict';
-
-var bufferWriter = require('../lib/buffer-writer.js');
-var reader = require('../lib/reader.js');
-var encoder = require('../lib/encoder.js');
-var common = require('./common.js');
-var multiformats = require('multiformats');
-var CBOR = require('@ipld/dag-cbor');
-var sha2 = require('multiformats/hashes/sha2');
-var identity = require('multiformats/hashes/identity');
-var raw = require('multiformats/codecs/raw');
-var Block = require('multiformats/block');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
-var CBOR__namespace = /*#__PURE__*/_interopNamespace(CBOR);
-var raw__namespace = /*#__PURE__*/_interopNamespace(raw);
-var Block__namespace = /*#__PURE__*/_interopNamespace(Block);
-
-describe('CarBufferWriter', () => {
-  const cid = multiformats.CID.parse('bafkreifuosuzujyf4i6psbneqtwg2fhplc2wxptc5euspa2gn3bwhnihfu');
-  describe('calculateHeaderLength', async () => {
-    for (const count of [
-        0,
-        1,
-        10,
-        18,
-        24,
-        48,
-        124,
-        255,
-        258,
-        65536 - 1,
-        65536
-      ]) {
-      it(`calculateHeaderLength(new Array(${ count }).fill(36))`, () => {
-        const roots = new Array(count).fill(cid);
-        const sizes = new Array(count).fill(cid.bytes.byteLength);
-        common.assert.deepEqual(bufferWriter.calculateHeaderLength(sizes), encoder.createHeader(roots).byteLength);
-      });
-      it(`calculateHeaderLength(new Array(${ count }).fill(36))`, () => {
-        const roots = new Array(count).fill(cid);
-        const rootLengths = roots.map(c => c.bytes.byteLength);
-        common.assert.deepEqual(bufferWriter.calculateHeaderLength(rootLengths), encoder.createHeader(roots).byteLength);
-      });
-    }
-    it('estimate on large CIDs', () => {
-      const largeCID = multiformats.CID.parse(`bafkqbbac${ 'a'.repeat(416) }`);
-      common.assert.equal(bufferWriter.calculateHeaderLength([
-        cid.bytes.byteLength,
-        largeCID.bytes.byteLength
-      ]), encoder.createHeader([
-        cid,
-        largeCID
-      ]).byteLength);
-    });
-    it('estimate on large CIDs 2', () => {
-      const largeCID = multiformats.CID.createV1(raw__namespace.code, identity.identity.digest(new Uint8Array(512).fill(1)));
-      common.assert.equal(bufferWriter.calculateHeaderLength([
-        cid.bytes.byteLength,
-        largeCID.bytes.byteLength
-      ]), encoder.createHeader([
-        cid,
-        largeCID
-      ]).byteLength);
-    });
-  });
-  describe('writer', () => {
-    it('estimate header and write blocks', async () => {
-      const headerSize = bufferWriter.estimateHeaderLength(1);
-      const dataSize = 256;
-      const buffer = new ArrayBuffer(headerSize + dataSize);
-      const writer = bufferWriter.createWriter(buffer, { headerSize });
-      const b1 = await Block__namespace.encode({
-        value: { hello: 'world' },
-        codec: CBOR__namespace,
-        hasher: sha2.sha256
-      });
-      writer.write(b1);
-      const b2 = await Block__namespace.encode({
-        value: { bye: 'world' },
-        codec: CBOR__namespace,
-        hasher: sha2.sha256
-      });
-      writer.write(b2);
-      writer.addRoot(b1.cid);
-      const bytes = writer.close();
-      const reader$1 = await reader.CarReader.fromBytes(bytes);
-      common.assert.deepEqual(await reader$1.getRoots(), [b1.cid]);
-      common.assert.deepEqual(reader$1._blocks, [
-        {
-          cid: b1.cid,
-          bytes: b1.bytes
-        },
-        {
-          cid: b2.cid,
-          bytes: b2.bytes
-        }
-      ]);
-    });
-    it('overestimate header', async () => {
-      const headerSize = bufferWriter.estimateHeaderLength(2);
-      const dataSize = 256;
-      const buffer = new ArrayBuffer(headerSize + dataSize);
-      const writer = bufferWriter.createWriter(buffer, { headerSize });
-      const b1 = await Block__namespace.encode({
-        value: { hello: 'world' },
-        codec: CBOR__namespace,
-        hasher: sha2.sha256
-      });
-      writer.write(b1);
-      const b2 = await Block__namespace.encode({
-        value: { bye: 'world' },
-        codec: CBOR__namespace,
-        hasher: sha2.sha256
-      });
-      writer.write(b2);
-      writer.addRoot(b1.cid);
-      common.assert.throws(() => writer.close(), /Header size was overestimate/);
-      const bytes = writer.close({ resize: true });
-      const reader$1 = await reader.CarReader.fromBytes(bytes);
-      common.assert.deepEqual(await reader$1.getRoots(), [b1.cid]);
-      common.assert.deepEqual(reader$1._blocks, [
-        {
-          cid: b1.cid,
-          bytes: b1.bytes
-        },
-        {
-          cid: b2.cid,
-          bytes: b2.bytes
-        }
-      ]);
-    });
-    it('underestimate header', async () => {
-      const headerSize = bufferWriter.estimateHeaderLength(2);
-      const dataSize = 300;
-      const buffer = new ArrayBuffer(headerSize + dataSize);
-      const writer = bufferWriter.createWriter(buffer, { headerSize });
-      const b1 = await Block__namespace.encode({
-        value: { hello: 'world' },
-        codec: CBOR__namespace,
-        hasher: sha2.sha256
-      });
-      writer.write(b1);
-      writer.addRoot(b1.cid);
-      const b2 = await Block__namespace.encode({
-        value: { bye: 'world' },
-        codec: CBOR__namespace,
-        hasher: sha2.sha512
-      });
-      writer.write(b2);
-      common.assert.throws(() => writer.addRoot(b2.cid), /has no capacity/);
-      writer.addRoot(b2.cid, { resize: true });
-      const bytes = writer.close();
-      const reader$1 = await reader.CarReader.fromBytes(bytes);
-      common.assert.deepEqual(await reader$1.getRoots(), [
-        b1.cid,
-        b2.cid
-      ]);
-      common.assert.deepEqual(reader$1._blocks, [
-        {
-          cid: b1.cid,
-          bytes: b1.bytes
-        },
-        {
-          cid: b2.cid,
-          bytes: b2.bytes
-        }
-      ]);
-    });
-  });
-  it('has no space for the root', async () => {
-    const headerSize = bufferWriter.estimateHeaderLength(1);
-    const dataSize = 100;
-    const buffer = new ArrayBuffer(headerSize + dataSize);
-    const writer = bufferWriter.createWriter(buffer, { headerSize });
-    const b1 = await Block__namespace.encode({
-      value: { hello: 'world' },
-      codec: CBOR__namespace,
-      hasher: sha2.sha256
-    });
-    writer.write(b1);
-    writer.addRoot(b1.cid);
-    const b2 = await Block__namespace.encode({
-      value: { bye: 'world' },
-      codec: CBOR__namespace,
-      hasher: sha2.sha256
-    });
-    writer.write(b2);
-    common.assert.throws(() => writer.addRoot(b2.cid), /Buffer has no capacity for a new root/);
-    common.assert.throws(() => writer.addRoot(b2.cid, { resize: true }), /Buffer has no capacity for a new root/);
-    const bytes = writer.close();
-    const reader$1 = await reader.CarReader.fromBytes(bytes);
-    common.assert.deepEqual(await reader$1.getRoots(), [b1.cid]);
-    common.assert.deepEqual(reader$1._blocks, [
-      {
-        cid: b1.cid,
-        bytes: b1.bytes
-      },
-      {
-        cid: b2.cid,
-        bytes: b2.bytes
-      }
-    ]);
-  });
-  it('has no space for the block', async () => {
-    const headerSize = bufferWriter.estimateHeaderLength(1);
-    const dataSize = 58;
-    const buffer = new ArrayBuffer(headerSize + dataSize);
-    const writer = bufferWriter.createWriter(buffer, { headerSize });
-    const b1 = await Block__namespace.encode({
-      value: { hello: 'world' },
-      codec: CBOR__namespace,
-      hasher: sha2.sha256
-    });
-    writer.write(b1);
-    writer.addRoot(b1.cid);
-    const b2 = await Block__namespace.encode({
-      value: { bye: 'world' },
-      codec: CBOR__namespace,
-      hasher: sha2.sha256
-    });
-    common.assert.throws(() => writer.write(b2), /Buffer has no capacity for this block/);
-    const bytes = writer.close();
-    const reader$1 = await reader.CarReader.fromBytes(bytes);
-    common.assert.deepEqual(await reader$1.getRoots(), [b1.cid]);
-    common.assert.deepEqual(reader$1._blocks, [{
-        cid: b1.cid,
-        bytes: b1.bytes
-      }]);
-  });
-  it('provide roots', async () => {
-    const b1 = await Block__namespace.encode({
-      value: { hello: 'world' },
-      codec: CBOR__namespace,
-      hasher: sha2.sha256
-    });
-    const b2 = await Block__namespace.encode({
-      value: { bye: 'world' },
-      codec: CBOR__namespace,
-      hasher: sha2.sha512
-    });
-    const buffer = new ArrayBuffer(300);
-    const writer = bufferWriter.createWriter(buffer, {
-      roots: [
-        b1.cid,
-        b2.cid
-      ]
-    });
-    writer.write(b1);
-    writer.write(b2);
-    const bytes = writer.close();
-    const reader$1 = await reader.CarReader.fromBytes(bytes);
-    common.assert.deepEqual(await reader$1.getRoots(), [
-      b1.cid,
-      b2.cid
-    ]);
-    common.assert.deepEqual(reader$1._blocks, [
-      {
-        cid: b1.cid,
-        bytes: b1.bytes
-      },
-      {
-        cid: b2.cid,
-        bytes: b2.bytes
-      }
-    ]);
-  });
-  it('provide large CID root', async () => {
-    const bytes = new Uint8Array(512).fill(1);
-    const b1 = await Block__namespace.encode({
-      value: { hello: 'world' },
-      codec: CBOR__namespace,
-      hasher: sha2.sha256
-    });
-    const b2 = {
-      cid: multiformats.CID.createV1(raw__namespace.code, identity.identity.digest(bytes)),
-      bytes
-    };
-    const headerSize = CBOR__namespace.encode({
-      version: 1,
-      roots: [
-        b1.cid,
-        b2.cid
-      ]
-    }).byteLength;
-    const bodySize = bufferWriter.blockLength(b1) + bufferWriter.blockLength(b2);
-    const varintSize = multiformats.varint.encodingLength(headerSize);
-    const writer = bufferWriter.createWriter(new ArrayBuffer(varintSize + headerSize + bodySize), {
-      roots: [
-        b1.cid,
-        b2.cid
-      ]
-    });
-    writer.write(b1);
-    writer.write(b2);
-    const car = writer.close();
-    const reader$1 = await reader.CarReader.fromBytes(car);
-    common.assert.deepEqual(await reader$1.getRoots(), [
-      b1.cid,
-      b2.cid
-    ]);
-    common.assert.deepEqual(reader$1._blocks, [
-      {
-        cid: b1.cid,
-        bytes: b1.bytes
-      },
-      {
-        cid: b2.cid,
-        bytes: b2.bytes
-      }
-    ]);
-  });
-});

package/cjs/node-test/test-errors.js

@@ -1,90 +0,0 @@
-'use strict';
-
-var multiformats = require('multiformats');
-var CBOR = require('@ipld/dag-cbor');
-var varint = require('varint');
-var reader = require('../lib/reader.js');
-var common = require('./common.js');
-
-function makeHeader(block) {
-  const u = CBOR.encode(block);
-  const l = varint.encode(u.length);
-  const u2 = new Uint8Array(u.length + l.length);
-  u2.set(l, 0);
-  u2.set(u, l.length);
-  return u2;
-}
-describe('Misc errors', () => {
-  const buf = common.carBytes.slice();
-  it('decode errors', async () => {
-    const buf2 = new Uint8Array(buf.length);
-    buf2.set(buf, 0);
-    buf2[101] = 0;
-    await common.assert.isRejected(reader.CarReader.fromBytes(buf2), {
-      name: 'Error',
-      message: 'Unexpected CID version (0)'
-    });
-  });
-  it('bad version', async () => {
-    const buf2 = multiformats.bytes.fromHex('0aa16776657273696f6e03');
-    common.assert.strictEqual(multiformats.bytes.toHex(makeHeader({ version: 3 })), '0aa16776657273696f6e03');
-    await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR version: 3');
-  });
-  describe('bad header', async () => {
-    it('sanity check', async () => {
-      const buf2 = makeHeader({
-        version: 1,
-        roots: []
-      });
-      await common.assert.isFulfilled(reader.CarReader.fromBytes(buf2));
-    });
-    it('no \'version\' array', async () => {
-      const buf2 = makeHeader({ roots: [] });
-      await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
-    });
-    it('bad \'version\' type', async () => {
-      const buf2 = makeHeader({
-        version: '1',
-        roots: []
-      });
-      await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
-    });
-    it('no \'roots\' array', async () => {
-      const buf2 = makeHeader({ version: 1 });
-      await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
-    });
-    it('bad \'roots\' type', async () => {
-      const buf2 = makeHeader({
-        version: 1,
-        roots: {}
-      });
-      await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
-    });
-    it('extraneous properties', async () => {
-      const buf2 = makeHeader({
-        version: 1,
-        roots: [],
-        blip: true
-      });
-      await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
-    });
-    it('not an object', async () => {
-      const buf2 = makeHeader([
-        1,
-        []
-      ]);
-      await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
-    });
-    it('not an object', async () => {
-      const buf2 = makeHeader(null);
-      await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR header format');
-    });
-    it('recursive v2 header', async () => {
-      const v2Header = common.goCarV2Bytes.slice(0, 51);
-      const buf2 = new Uint8Array(51 * 2);
-      buf2.set(v2Header, 0);
-      buf2.set(v2Header, 51);
-      await common.assert.isRejected(reader.CarReader.fromBytes(buf2), Error, 'Invalid CAR version: 2 (expected 1)');
-    });
-  });
-});

package/cjs/node-test/test-indexer.js

@@ -1,80 +0,0 @@
-'use strict';
-
-var indexer = require('../lib/indexer.js');
-var common = require('./common.js');
-var verifyStoreReader = require('./verify-store-reader.js');
-
-describe('CarIndexer fromBytes()', () => {
-  it('complete', async () => {
-    const indexer$1 = await indexer.CarIndexer.fromBytes(common.goCarBytes);
-    await verifyStoreReader.verifyRoots(indexer$1);
-    common.assert.strictEqual(indexer$1.version, 1);
-    const indexData = [];
-    for await (const index of indexer$1) {
-      indexData.push(index);
-    }
-    common.assert.deepStrictEqual(indexData, common.goCarIndex);
-  });
-  it('v2 complete', async () => {
-    const indexer$1 = await indexer.CarIndexer.fromBytes(common.goCarV2Bytes);
-    const roots = await indexer$1.getRoots();
-    common.assert.strictEqual(roots.length, 1);
-    common.assert.ok(common.goCarV2Roots[0].equals(roots[0]));
-    common.assert.strictEqual(indexer$1.version, 2);
-    const indexData = [];
-    for await (const index of indexer$1) {
-      indexData.push(index);
-    }
-    common.assert.deepStrictEqual(indexData, common.goCarV2Index);
-  });
-  it('bad argument', async () => {
-    for (const arg of [
-        true,
-        false,
-        null,
-        undefined,
-        'string',
-        100,
-        { obj: 'nope' }
-      ]) {
-      await common.assert.isRejected(indexer.CarIndexer.fromBytes(arg));
-    }
-  });
-});
-describe('CarIndexer fromIterable()', () => {
-  async function verifyIndexer(indexer) {
-    await verifyStoreReader.verifyRoots(indexer);
-    common.assert.strictEqual(indexer.version, 1);
-    const indexData = [];
-    for await (const index of indexer) {
-      indexData.push(index);
-    }
-    common.assert.deepStrictEqual(indexData, common.goCarIndex);
-  }
-  it('complete (single chunk)', async () => {
-    const indexer$1 = await indexer.CarIndexer.fromIterable(common.makeIterable(common.goCarBytes, common.goCarBytes.length));
-    return verifyIndexer(indexer$1);
-  });
-  it('complete (101-byte chunks)', async () => {
-    const indexer$1 = await indexer.CarIndexer.fromIterable(common.makeIterable(common.goCarBytes, 101));
-    return verifyIndexer(indexer$1);
-  });
-  it('complete (32-byte chunks)', async () => {
-    const indexer$1 = await indexer.CarIndexer.fromIterable(common.makeIterable(common.goCarBytes, 32));
-    return verifyIndexer(indexer$1);
-  });
-  it('bad argument', async () => {
-    for (const arg of [
-        new Uint8Array(0),
-        true,
-        false,
-        null,
-        undefined,
-        'string',
-        100,
-        { obj: 'nope' }
-      ]) {
-      await common.assert.isRejected(indexer.CarIndexer.fromIterable(arg));
-    }
-  });
-});

package/cjs/node-test/test-interface.js

@@ -1,21 +0,0 @@
-'use strict';
-
-require('../car.js');
-var reader = require('../lib/reader.js');
-var indexer = require('../lib/indexer.js');
-var iterator = require('../lib/iterator.js');
-var writer = require('../lib/writer.js');
-var common = require('./common.js');
-
-describe('Interface', () => {
-  it('exports match', () => {
-    common.assert.strictEqual(reader.CarReader, reader.CarReader);
-    common.assert.strictEqual(indexer.CarIndexer, indexer.CarIndexer);
-    common.assert.strictEqual(iterator.CarBlockIterator, iterator.CarBlockIterator);
-    common.assert.strictEqual(iterator.CarCIDIterator, iterator.CarCIDIterator);
-    common.assert.strictEqual(writer.CarWriter, writer.CarWriter);
-  });
-  it('browser exports', () => {
-    common.assert.strictEqual(reader.__browser, globalThis.process === undefined);
-  });
-});

package/cjs/node-test/test-iterator.js

@@ -1,83 +0,0 @@
-'use strict';
-
-var iterator = require('../lib/iterator.js');
-var common = require('./common.js');
-var verifyStoreReader = require('./verify-store-reader.js');
-
-async function verifyBlockIterator(iter) {
-  await verifyStoreReader.verifyRoots(iter);
-  await verifyStoreReader.verifyBlocks(iter);
-  common.assert.strictEqual(iter.version, 1);
-  return iter;
-}
-async function verifyCIDIterator(iter) {
-  await verifyStoreReader.verifyRoots(iter);
-  await verifyStoreReader.verifyCids(iter);
-  common.assert.strictEqual(iter.version, 1);
-  return iter;
-}
-for (const type of [
-    'Block',
-    'CID'
-  ]) {
-  describe(`Car${ type }Iterator`, () => {
-    it('fromBytes()', async () => {
-      if (type === 'Block') {
-        await verifyBlockIterator(await iterator.CarBlockIterator.fromBytes(common.carBytes));
-      } else {
-        await verifyCIDIterator(await iterator.CarCIDIterator.fromBytes(common.carBytes));
-      }
-    });
-    it('fromBytes() bad double read', async () => {
-      if (type === 'Block') {
-        const iter = await verifyBlockIterator(await iterator.CarBlockIterator.fromBytes(common.carBytes));
-        await common.assert.isRejected(verifyStoreReader.verifyBlocks(iter), /more than once/i);
-      } else {
-        const iter = await verifyCIDIterator(await iterator.CarCIDIterator.fromBytes(common.carBytes));
-        await common.assert.isRejected(verifyStoreReader.verifyCids(iter), /more than once/i);
-      }
-    });
-    it('fromBytes() bad argument', async () => {
-      for (const arg of [
-          true,
-          false,
-          null,
-          undefined,
-          'string',
-          100,
-          { obj: 'nope' }
-        ]) {
-        await common.assert.isRejected((type === 'Block' ? iterator.CarBlockIterator : iterator.CarCIDIterator).fromBytes(arg));
-      }
-    });
-    it('fromIterable() bad argument', async () => {
-      for (const arg of [
-          new Uint8Array(0),
-          true,
-          false,
-          null,
-          undefined,
-          'string',
-          100,
-          { obj: 'nope' }
-        ]) {
-        await common.assert.isRejected((type === 'Block' ? iterator.CarBlockIterator : iterator.CarCIDIterator).fromIterable(arg));
-      }
-    });
-    for (const chunkSize of [
-        common.carBytes.length,
-        100,
-        64,
-        32
-      ]) {
-      const chunkDesc = chunkSize === common.carBytes.length ? 'single chunk' : `${ chunkSize }  bytes`;
-      it(`fromIterable() blocks (${ chunkDesc })`, async () => {
-        if (type === 'Block') {
-          await verifyBlockIterator(await iterator.CarBlockIterator.fromIterable(common.makeIterable(common.carBytes, chunkSize)));
-        } else {
-          await verifyCIDIterator(await iterator.CarCIDIterator.fromIterable(common.makeIterable(common.carBytes, chunkSize)));
-        }
-      });
-    }
-  });
-}