diff --git a/package-lock.json b/package-lock.json index 9242999c3..3c3272ea3 100644 --- a/package-lock.json +++ b/package-lock.json @@ -40,7 +40,6 @@ "hardhat-gas-reporter": "^1.0.9", "hardhat-ignore-warnings": "^0.2.0", "lodash.startcase": "^4.4.0", - "lodash.zip": "^4.2.0", "micromatch": "^4.0.2", "p-limit": "^3.1.0", "prettier": "^3.0.0", @@ -10546,12 +10545,6 @@ "integrity": "sha512-jttmRe7bRse52OsWIMDLaXxWqRAmtIUccAQ3garviCqJjafXOfNMO0yMfNpdD6zbGaTU0P5Nz7e7gAT6cKmJRw==", "dev": true }, - "node_modules/lodash.zip": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/lodash.zip/-/lodash.zip-4.2.0.tgz", - "integrity": "sha512-C7IOaBBK/0gMORRBd8OETNx3kmOkgIWIPvyDpZSCTwUrpYmgZwJkjZeOD8ww4xbOUOs4/attY+pciKvadNfFbg==", - "dev": true - }, "node_modules/log-symbols": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz", diff --git a/package.json b/package.json index c2c3a2675..50ba8f478 100644 --- a/package.json +++ b/package.json @@ -80,7 +80,6 @@ "hardhat-gas-reporter": "^1.0.9", "hardhat-ignore-warnings": "^0.2.0", "lodash.startcase": "^4.4.0", - "lodash.zip": "^4.2.0", "micromatch": "^4.0.2", "p-limit": "^3.1.0", "prettier": "^3.0.0", diff --git a/test/helpers/random.js b/test/helpers/random.js new file mode 100644 index 000000000..883667fa0 --- /dev/null +++ b/test/helpers/random.js @@ -0,0 +1,14 @@ +const { ethers } = require('hardhat'); + +const randomArray = (generator, arrayLength = 3) => Array(arrayLength).fill().map(generator); + +const generators = { + address: () => ethers.Wallet.createRandom().address, + bytes32: () => ethers.hexlify(ethers.randomBytes(32)), + uint256: () => ethers.toBigInt(ethers.randomBytes(32)), +}; + +module.exports = { + randomArray, + generators, +}; diff --git a/test/utils/structs/BitMap.test.js b/test/utils/structs/BitMap.test.js index 8a1470c5c..133f1f734 100644 --- a/test/utils/structs/BitMap.test.js +++ b/test/utils/structs/BitMap.test.js @@ -1,15 +1,19 @@ -const { BN } = require('@openzeppelin/test-helpers'); const { expect } = require('chai'); +const { ethers } = require('hardhat'); +const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers'); -const BitMap = artifacts.require('$BitMaps'); +async function fixture() { + const bitmap = await ethers.deployContract('$BitMaps'); + return { bitmap }; +} -contract('BitMap', function () { - const keyA = new BN('7891'); - const keyB = new BN('451'); - const keyC = new BN('9592328'); +describe('BitMap', function () { + const keyA = 7891n; + const keyB = 451n; + const keyC = 9592328n; beforeEach(async function () { - this.bitmap = await BitMap.new(); + Object.assign(this, await loadFixture(fixture)); }); it('starts empty', async function () { @@ -35,18 +39,18 @@ contract('BitMap', function () { }); it('set several consecutive keys', async function () { - await this.bitmap.$setTo(0, keyA.addn(0), true); - await this.bitmap.$setTo(0, keyA.addn(1), true); - await this.bitmap.$setTo(0, keyA.addn(2), true); - await this.bitmap.$setTo(0, keyA.addn(3), true); - await this.bitmap.$setTo(0, keyA.addn(4), true); - await this.bitmap.$setTo(0, keyA.addn(2), false); - await this.bitmap.$setTo(0, keyA.addn(4), false); - expect(await this.bitmap.$get(0, keyA.addn(0))).to.equal(true); - expect(await this.bitmap.$get(0, keyA.addn(1))).to.equal(true); - expect(await this.bitmap.$get(0, keyA.addn(2))).to.equal(false); - expect(await this.bitmap.$get(0, keyA.addn(3))).to.equal(true); - expect(await this.bitmap.$get(0, keyA.addn(4))).to.equal(false); + await this.bitmap.$setTo(0, keyA + 0n, true); + await this.bitmap.$setTo(0, keyA + 1n, true); + await this.bitmap.$setTo(0, keyA + 2n, true); + await this.bitmap.$setTo(0, keyA + 3n, true); + await this.bitmap.$setTo(0, keyA + 4n, true); + await this.bitmap.$setTo(0, keyA + 2n, false); + await this.bitmap.$setTo(0, keyA + 4n, false); + expect(await this.bitmap.$get(0, keyA + 0n)).to.equal(true); + expect(await this.bitmap.$get(0, keyA + 1n)).to.equal(true); + expect(await this.bitmap.$get(0, keyA + 2n)).to.equal(false); + expect(await this.bitmap.$get(0, keyA + 3n)).to.equal(true); + expect(await this.bitmap.$get(0, keyA + 4n)).to.equal(false); }); }); @@ -67,14 +71,14 @@ contract('BitMap', function () { }); it('adds several consecutive keys', async function () { - await this.bitmap.$set(0, keyA.addn(0)); - await this.bitmap.$set(0, keyA.addn(1)); - await this.bitmap.$set(0, keyA.addn(3)); - expect(await this.bitmap.$get(0, keyA.addn(0))).to.equal(true); - expect(await this.bitmap.$get(0, keyA.addn(1))).to.equal(true); - expect(await this.bitmap.$get(0, keyA.addn(2))).to.equal(false); - expect(await this.bitmap.$get(0, keyA.addn(3))).to.equal(true); - expect(await this.bitmap.$get(0, keyA.addn(4))).to.equal(false); + await this.bitmap.$set(0, keyA + 0n); + await this.bitmap.$set(0, keyA + 1n); + await this.bitmap.$set(0, keyA + 3n); + expect(await this.bitmap.$get(0, keyA + 0n)).to.equal(true); + expect(await this.bitmap.$get(0, keyA + 1n)).to.equal(true); + expect(await this.bitmap.$get(0, keyA + 2n)).to.equal(false); + expect(await this.bitmap.$get(0, keyA + 3n)).to.equal(true); + expect(await this.bitmap.$get(0, keyA + 4n)).to.equal(false); }); }); @@ -89,15 +93,15 @@ contract('BitMap', function () { }); it('removes consecutive added keys', async function () { - await this.bitmap.$set(0, keyA.addn(0)); - await this.bitmap.$set(0, keyA.addn(1)); - await this.bitmap.$set(0, keyA.addn(3)); - await this.bitmap.$unset(0, keyA.addn(1)); - expect(await this.bitmap.$get(0, keyA.addn(0))).to.equal(true); - expect(await this.bitmap.$get(0, keyA.addn(1))).to.equal(false); - expect(await this.bitmap.$get(0, keyA.addn(2))).to.equal(false); - expect(await this.bitmap.$get(0, keyA.addn(3))).to.equal(true); - expect(await this.bitmap.$get(0, keyA.addn(4))).to.equal(false); + await this.bitmap.$set(0, keyA + 0n); + await this.bitmap.$set(0, keyA + 1n); + await this.bitmap.$set(0, keyA + 3n); + await this.bitmap.$unset(0, keyA + 1n); + expect(await this.bitmap.$get(0, keyA + 0n)).to.equal(true); + expect(await this.bitmap.$get(0, keyA + 1n)).to.equal(false); + expect(await this.bitmap.$get(0, keyA + 2n)).to.equal(false); + expect(await this.bitmap.$get(0, keyA + 3n)).to.equal(true); + expect(await this.bitmap.$get(0, keyA + 4n)).to.equal(false); }); it('adds and removes multiple keys', async function () { diff --git a/test/utils/structs/Checkpoints.test.js b/test/utils/structs/Checkpoints.test.js index 936ac565a..c5b9e65a0 100644 --- a/test/utils/structs/Checkpoints.test.js +++ b/test/utils/structs/Checkpoints.test.js @@ -1,71 +1,65 @@ -require('@openzeppelin/test-helpers'); - const { expect } = require('chai'); +const { ethers } = require('hardhat'); +const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers'); const { VALUE_SIZES } = require('../../../scripts/generate/templates/Checkpoints.opts.js'); -const { expectRevertCustomError } = require('../../helpers/customError.js'); -const { expectRevert } = require('@openzeppelin/test-helpers'); -const $Checkpoints = artifacts.require('$Checkpoints'); - -// The library name may be 'Checkpoints' or 'CheckpointsUpgradeable' -const libraryName = $Checkpoints._json.contractName.replace(/^\$/, ''); - -const first = array => (array.length ? array[0] : undefined); const last = array => (array.length ? array[array.length - 1] : undefined); -contract('Checkpoints', function () { - beforeEach(async function () { - this.mock = await $Checkpoints.new(); - }); - +describe('Checkpoints', function () { for (const length of VALUE_SIZES) { describe(`Trace${length}`, function () { - beforeEach(async function () { - this.methods = { - at: (...args) => this.mock.methods[`$at_${libraryName}_Trace${length}(uint256,uint32)`](0, ...args), - latest: (...args) => this.mock.methods[`$latest_${libraryName}_Trace${length}(uint256)`](0, ...args), - latestCheckpoint: (...args) => - this.mock.methods[`$latestCheckpoint_${libraryName}_Trace${length}(uint256)`](0, ...args), - length: (...args) => this.mock.methods[`$length_${libraryName}_Trace${length}(uint256)`](0, ...args), - push: (...args) => this.mock.methods[`$push(uint256,uint${256 - length},uint${length})`](0, ...args), - lowerLookup: (...args) => this.mock.methods[`$lowerLookup(uint256,uint${256 - length})`](0, ...args), - upperLookup: (...args) => this.mock.methods[`$upperLookup(uint256,uint${256 - length})`](0, ...args), + const fixture = async () => { + const mock = await ethers.deployContract('$Checkpoints'); + const methods = { + at: (...args) => mock.getFunction(`$at_Checkpoints_Trace${length}`)(0, ...args), + latest: (...args) => mock.getFunction(`$latest_Checkpoints_Trace${length}`)(0, ...args), + latestCheckpoint: (...args) => mock.getFunction(`$latestCheckpoint_Checkpoints_Trace${length}`)(0, ...args), + length: (...args) => mock.getFunction(`$length_Checkpoints_Trace${length}`)(0, ...args), + push: (...args) => mock.getFunction(`$push(uint256,uint${256 - length},uint${length})`)(0, ...args), + lowerLookup: (...args) => mock.getFunction(`$lowerLookup(uint256,uint${256 - length})`)(0, ...args), + upperLookup: (...args) => mock.getFunction(`$upperLookup(uint256,uint${256 - length})`)(0, ...args), upperLookupRecent: (...args) => - this.mock.methods[`$upperLookupRecent(uint256,uint${256 - length})`](0, ...args), + mock.getFunction(`$upperLookupRecent(uint256,uint${256 - length})`)(0, ...args), }; + + return { mock, methods }; + }; + + beforeEach(async function () { + Object.assign(this, await loadFixture(fixture)); }); describe('without checkpoints', function () { it('at zero reverts', async function () { // Reverts with array out of bound access, which is unspecified - await expectRevert.unspecified(this.methods.at(0)); + await expect(this.methods.at(0)).to.be.reverted; }); it('returns zero as latest value', async function () { - expect(await this.methods.latest()).to.be.bignumber.equal('0'); + expect(await this.methods.latest()).to.equal(0n); const ckpt = await this.methods.latestCheckpoint(); - expect(ckpt[0]).to.be.equal(false); - expect(ckpt[1]).to.be.bignumber.equal('0'); - expect(ckpt[2]).to.be.bignumber.equal('0'); + expect(ckpt[0]).to.be.false; + expect(ckpt[1]).to.equal(0n); + expect(ckpt[2]).to.equal(0n); }); it('lookup returns 0', async function () { - expect(await this.methods.lowerLookup(0)).to.be.bignumber.equal('0'); - expect(await this.methods.upperLookup(0)).to.be.bignumber.equal('0'); - expect(await this.methods.upperLookupRecent(0)).to.be.bignumber.equal('0'); + expect(await this.methods.lowerLookup(0)).to.equal(0n); + expect(await this.methods.upperLookup(0)).to.equal(0n); + expect(await this.methods.upperLookupRecent(0)).to.equal(0n); }); }); describe('with checkpoints', function () { beforeEach('pushing checkpoints', async function () { this.checkpoints = [ - { key: '2', value: '17' }, - { key: '3', value: '42' }, - { key: '5', value: '101' }, - { key: '7', value: '23' }, - { key: '11', value: '99' }, + { key: 2n, value: 17n }, + { key: 3n, value: 42n }, + { key: 5n, value: 101n }, + { key: 7n, value: 23n }, + { key: 11n, value: 99n }, ]; for (const { key, value } of this.checkpoints) { await this.methods.push(key, value); @@ -75,70 +69,66 @@ contract('Checkpoints', function () { it('at keys', async function () { for (const [index, { key, value }] of this.checkpoints.entries()) { const at = await this.methods.at(index); - expect(at._value).to.be.bignumber.equal(value); - expect(at._key).to.be.bignumber.equal(key); + expect(at._value).to.equal(value); + expect(at._key).to.equal(key); } }); it('length', async function () { - expect(await this.methods.length()).to.be.bignumber.equal(this.checkpoints.length.toString()); + expect(await this.methods.length()).to.equal(this.checkpoints.length); }); it('returns latest value', async function () { - expect(await this.methods.latest()).to.be.bignumber.equal(last(this.checkpoints).value); - - const ckpt = await this.methods.latestCheckpoint(); - expect(ckpt[0]).to.be.equal(true); - expect(ckpt[1]).to.be.bignumber.equal(last(this.checkpoints).key); - expect(ckpt[2]).to.be.bignumber.equal(last(this.checkpoints).value); + const latest = this.checkpoints.at(-1); + expect(await this.methods.latest()).to.equal(latest.value); + expect(await this.methods.latestCheckpoint()).to.have.ordered.members([true, latest.key, latest.value]); }); it('cannot push values in the past', async function () { - await expectRevertCustomError( - this.methods.push(last(this.checkpoints).key - 1, '0'), + await expect(this.methods.push(this.checkpoints.at(-1).key - 1n, 0n)).to.be.revertedWithCustomError( + this.mock, 'CheckpointUnorderedInsertion', - [], ); }); it('can update last value', async function () { - const newValue = '42'; + const newValue = 42n; // check length before the update - expect(await this.methods.length()).to.be.bignumber.equal(this.checkpoints.length.toString()); + expect(await this.methods.length()).to.equal(this.checkpoints.length); // update last key - await this.methods.push(last(this.checkpoints).key, newValue); - expect(await this.methods.latest()).to.be.bignumber.equal(newValue); + await this.methods.push(this.checkpoints.at(-1).key, newValue); + expect(await this.methods.latest()).to.equal(newValue); // check that length did not change - expect(await this.methods.length()).to.be.bignumber.equal(this.checkpoints.length.toString()); + expect(await this.methods.length()).to.equal(this.checkpoints.length); }); it('lower lookup', async function () { for (let i = 0; i < 14; ++i) { - const value = first(this.checkpoints.filter(x => i <= x.key))?.value || '0'; + const value = this.checkpoints.find(x => i <= x.key)?.value || 0n; - expect(await this.methods.lowerLookup(i)).to.be.bignumber.equal(value); + expect(await this.methods.lowerLookup(i)).to.equal(value); } }); it('upper lookup & upperLookupRecent', async function () { for (let i = 0; i < 14; ++i) { - const value = last(this.checkpoints.filter(x => i >= x.key))?.value || '0'; + const value = last(this.checkpoints.filter(x => i >= x.key))?.value || 0n; - expect(await this.methods.upperLookup(i)).to.be.bignumber.equal(value); - expect(await this.methods.upperLookupRecent(i)).to.be.bignumber.equal(value); + expect(await this.methods.upperLookup(i)).to.equal(value); + expect(await this.methods.upperLookupRecent(i)).to.equal(value); } }); it('upperLookupRecent with more than 5 checkpoints', async function () { const moreCheckpoints = [ - { key: '12', value: '22' }, - { key: '13', value: '131' }, - { key: '17', value: '45' }, - { key: '19', value: '31452' }, - { key: '21', value: '0' }, + { key: 12n, value: 22n }, + { key: 13n, value: 131n }, + { key: 17n, value: 45n }, + { key: 19n, value: 31452n }, + { key: 21n, value: 0n }, ]; const allCheckpoints = [].concat(this.checkpoints, moreCheckpoints); @@ -147,9 +137,9 @@ contract('Checkpoints', function () { } for (let i = 0; i < 25; ++i) { - const value = last(allCheckpoints.filter(x => i >= x.key))?.value || '0'; - expect(await this.methods.upperLookup(i)).to.be.bignumber.equal(value); - expect(await this.methods.upperLookupRecent(i)).to.be.bignumber.equal(value); + const value = last(allCheckpoints.filter(x => i >= x.key))?.value || 0n; + expect(await this.methods.upperLookup(i)).to.equal(value); + expect(await this.methods.upperLookupRecent(i)).to.equal(value); } }); }); diff --git a/test/utils/structs/DoubleEndedQueue.test.js b/test/utils/structs/DoubleEndedQueue.test.js index cbf37d76b..92d9f530c 100644 --- a/test/utils/structs/DoubleEndedQueue.test.js +++ b/test/utils/structs/DoubleEndedQueue.test.js @@ -1,99 +1,105 @@ -const { expectEvent } = require('@openzeppelin/test-helpers'); -const { expectRevertCustomError } = require('../../helpers/customError'); +const { expect } = require('chai'); +const { ethers } = require('hardhat'); +const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers'); -const DoubleEndedQueue = artifacts.require('$DoubleEndedQueue'); +async function fixture() { + const mock = await ethers.deployContract('$DoubleEndedQueue'); -/** Rebuild the content of the deque as a JS array. */ -const getContent = deque => - deque.$length(0).then(bn => - Promise.all( - Array(bn.toNumber()) - .fill() - .map((_, i) => deque.$at(0, i)), - ), - ); + /** Rebuild the content of the deque as a JS array. */ + const getContent = () => + mock.$length(0).then(length => + Promise.all( + Array(Number(length)) + .fill() + .map((_, i) => mock.$at(0, i)), + ), + ); -contract('DoubleEndedQueue', function () { - const bytesA = '0xdeadbeef'.padEnd(66, '0'); - const bytesB = '0x0123456789'.padEnd(66, '0'); - const bytesC = '0x42424242'.padEnd(66, '0'); - const bytesD = '0x171717'.padEnd(66, '0'); + return { mock, getContent }; +} + +describe('DoubleEndedQueue', function () { + const coder = ethers.AbiCoder.defaultAbiCoder(); + const bytesA = coder.encode(['uint256'], [0xdeadbeef]); + const bytesB = coder.encode(['uint256'], [0x0123456789]); + const bytesC = coder.encode(['uint256'], [0x42424242]); + const bytesD = coder.encode(['uint256'], [0x171717]); beforeEach(async function () { - this.deque = await DoubleEndedQueue.new(); + Object.assign(this, await loadFixture(fixture)); }); describe('when empty', function () { it('getters', async function () { - expect(await this.deque.$empty(0)).to.be.equal(true); - expect(await getContent(this.deque)).to.have.ordered.members([]); + expect(await this.mock.$empty(0)).to.be.true; + expect(await this.getContent()).to.have.ordered.members([]); }); it('reverts on accesses', async function () { - await expectRevertCustomError(this.deque.$popBack(0), 'QueueEmpty', []); - await expectRevertCustomError(this.deque.$popFront(0), 'QueueEmpty', []); - await expectRevertCustomError(this.deque.$back(0), 'QueueEmpty', []); - await expectRevertCustomError(this.deque.$front(0), 'QueueEmpty', []); + await expect(this.mock.$popBack(0)).to.be.revertedWithCustomError(this.mock, 'QueueEmpty'); + await expect(this.mock.$popFront(0)).to.be.revertedWithCustomError(this.mock, 'QueueEmpty'); + await expect(this.mock.$back(0)).to.be.revertedWithCustomError(this.mock, 'QueueEmpty'); + await expect(this.mock.$front(0)).to.be.revertedWithCustomError(this.mock, 'QueueEmpty'); }); }); describe('when not empty', function () { beforeEach(async function () { - await this.deque.$pushBack(0, bytesB); - await this.deque.$pushFront(0, bytesA); - await this.deque.$pushBack(0, bytesC); + await this.mock.$pushBack(0, bytesB); + await this.mock.$pushFront(0, bytesA); + await this.mock.$pushBack(0, bytesC); this.content = [bytesA, bytesB, bytesC]; }); it('getters', async function () { - expect(await this.deque.$empty(0)).to.be.equal(false); - expect(await this.deque.$length(0)).to.be.bignumber.equal(this.content.length.toString()); - expect(await this.deque.$front(0)).to.be.equal(this.content[0]); - expect(await this.deque.$back(0)).to.be.equal(this.content[this.content.length - 1]); - expect(await getContent(this.deque)).to.have.ordered.members(this.content); + expect(await this.mock.$empty(0)).to.be.false; + expect(await this.mock.$length(0)).to.equal(this.content.length); + expect(await this.mock.$front(0)).to.equal(this.content[0]); + expect(await this.mock.$back(0)).to.equal(this.content[this.content.length - 1]); + expect(await this.getContent()).to.have.ordered.members(this.content); }); it('out of bounds access', async function () { - await expectRevertCustomError(this.deque.$at(0, this.content.length), 'QueueOutOfBounds', []); + await expect(this.mock.$at(0, this.content.length)).to.be.revertedWithCustomError(this.mock, 'QueueOutOfBounds'); }); describe('push', function () { it('front', async function () { - await this.deque.$pushFront(0, bytesD); + await this.mock.$pushFront(0, bytesD); this.content.unshift(bytesD); // add element at the beginning - expect(await getContent(this.deque)).to.have.ordered.members(this.content); + expect(await this.getContent()).to.have.ordered.members(this.content); }); it('back', async function () { - await this.deque.$pushBack(0, bytesD); + await this.mock.$pushBack(0, bytesD); this.content.push(bytesD); // add element at the end - expect(await getContent(this.deque)).to.have.ordered.members(this.content); + expect(await this.getContent()).to.have.ordered.members(this.content); }); }); describe('pop', function () { it('front', async function () { const value = this.content.shift(); // remove first element - expectEvent(await this.deque.$popFront(0), 'return$popFront', { value }); + await expect(this.mock.$popFront(0)).to.emit(this.mock, 'return$popFront').withArgs(value); - expect(await getContent(this.deque)).to.have.ordered.members(this.content); + expect(await this.getContent()).to.have.ordered.members(this.content); }); it('back', async function () { const value = this.content.pop(); // remove last element - expectEvent(await this.deque.$popBack(0), 'return$popBack', { value }); + await expect(this.mock.$popBack(0)).to.emit(this.mock, 'return$popBack').withArgs(value); - expect(await getContent(this.deque)).to.have.ordered.members(this.content); + expect(await this.getContent()).to.have.ordered.members(this.content); }); }); it('clear', async function () { - await this.deque.$clear(0); + await this.mock.$clear(0); - expect(await this.deque.$empty(0)).to.be.equal(true); - expect(await getContent(this.deque)).to.have.ordered.members([]); + expect(await this.mock.$empty(0)).to.be.true; + expect(await this.getContent()).to.have.ordered.members([]); }); }); }); diff --git a/test/utils/structs/EnumerableMap.behavior.js b/test/utils/structs/EnumerableMap.behavior.js index 67b19e39a..fb967b34c 100644 --- a/test/utils/structs/EnumerableMap.behavior.js +++ b/test/utils/structs/EnumerableMap.behavior.js @@ -1,173 +1,146 @@ -const { expectEvent } = require('@openzeppelin/test-helpers'); const { expect } = require('chai'); +const { ethers } = require('hardhat'); -const zip = require('lodash.zip'); -const { expectRevertCustomError } = require('../../helpers/customError'); +const zip = (array1, array2) => array1.map((item, index) => [item, array2[index]]); -function shouldBehaveLikeMap(keys, values, zeroValue, methods, events) { - const [keyA, keyB, keyC] = keys; - const [valueA, valueB, valueC] = values; - - async function expectMembersMatch(map, keys, values) { +function shouldBehaveLikeMap(zeroValue, keyType, events) { + async function expectMembersMatch(methods, keys, values) { expect(keys.length).to.equal(values.length); + expect(await methods.length()).to.equal(keys.length); + expect([...(await methods.keys())]).to.have.members(keys); - await Promise.all(keys.map(async key => expect(await methods.contains(map, key)).to.equal(true))); + for (const [key, value] of zip(keys, values)) { + expect(await methods.contains(key)).to.be.true; + expect(await methods.get(key)).to.equal(value); + } - expect(await methods.length(map)).to.bignumber.equal(keys.length.toString()); - - expect((await Promise.all(keys.map(key => methods.get(map, key)))).map(k => k.toString())).to.have.same.members( - values.map(value => value.toString()), - ); - - // To compare key-value pairs, we zip keys and values, and convert BNs to - // strings to workaround Chai limitations when dealing with nested arrays - expect( - await Promise.all( - [...Array(keys.length).keys()].map(async index => { - const entry = await methods.at(map, index); - return [entry[0].toString(), entry[1].toString()]; - }), - ), - ).to.have.same.deep.members( - zip( - keys.map(k => k.toString()), - values.map(v => v.toString()), - ), - ); - - // This also checks that both arrays have the same length - expect((await methods.keys(map)).map(k => k.toString())).to.have.same.members(keys.map(key => key.toString())); + expect(await Promise.all(keys.map((_, index) => methods.at(index)))).to.have.deep.members(zip(keys, values)); } it('starts empty', async function () { - expect(await methods.contains(this.map, keyA)).to.equal(false); + expect(await this.methods.contains(this.keyA)).to.be.false; - await expectMembersMatch(this.map, [], []); + await expectMembersMatch(this.methods, [], []); }); describe('set', function () { it('adds a key', async function () { - const receipt = await methods.set(this.map, keyA, valueA); - expectEvent(receipt, events.setReturn, { ret0: true }); + await expect(this.methods.set(this.keyA, this.valueA)).to.emit(this.mock, events.setReturn).withArgs(true); - await expectMembersMatch(this.map, [keyA], [valueA]); + await expectMembersMatch(this.methods, [this.keyA], [this.valueA]); }); it('adds several keys', async function () { - await methods.set(this.map, keyA, valueA); - await methods.set(this.map, keyB, valueB); + await this.methods.set(this.keyA, this.valueA); + await this.methods.set(this.keyB, this.valueB); - await expectMembersMatch(this.map, [keyA, keyB], [valueA, valueB]); - expect(await methods.contains(this.map, keyC)).to.equal(false); + await expectMembersMatch(this.methods, [this.keyA, this.keyB], [this.valueA, this.valueB]); + expect(await this.methods.contains(this.keyC)).to.be.false; }); it('returns false when adding keys already in the set', async function () { - await methods.set(this.map, keyA, valueA); + await this.methods.set(this.keyA, this.valueA); - const receipt = await methods.set(this.map, keyA, valueA); - expectEvent(receipt, events.setReturn, { ret0: false }); + await expect(this.methods.set(this.keyA, this.valueA)).to.emit(this.mock, events.setReturn).withArgs(false); - await expectMembersMatch(this.map, [keyA], [valueA]); + await expectMembersMatch(this.methods, [this.keyA], [this.valueA]); }); it('updates values for keys already in the set', async function () { - await methods.set(this.map, keyA, valueA); - await methods.set(this.map, keyA, valueB); + await this.methods.set(this.keyA, this.valueA); + await this.methods.set(this.keyA, this.valueB); - await expectMembersMatch(this.map, [keyA], [valueB]); + await expectMembersMatch(this.methods, [this.keyA], [this.valueB]); }); }); describe('remove', function () { it('removes added keys', async function () { - await methods.set(this.map, keyA, valueA); + await this.methods.set(this.keyA, this.valueA); - const receipt = await methods.remove(this.map, keyA); - expectEvent(receipt, events.removeReturn, { ret0: true }); + await expect(this.methods.remove(this.keyA)).to.emit(this.mock, events.removeReturn).withArgs(true); - expect(await methods.contains(this.map, keyA)).to.equal(false); - await expectMembersMatch(this.map, [], []); + expect(await this.methods.contains(this.keyA)).to.be.false; + await expectMembersMatch(this.methods, [], []); }); it('returns false when removing keys not in the set', async function () { - const receipt = await methods.remove(this.map, keyA); - expectEvent(receipt, events.removeReturn, { ret0: false }); + await expect(await this.methods.remove(this.keyA)) + .to.emit(this.mock, events.removeReturn) + .withArgs(false); - expect(await methods.contains(this.map, keyA)).to.equal(false); + expect(await this.methods.contains(this.keyA)).to.be.false; }); it('adds and removes multiple keys', async function () { // [] - await methods.set(this.map, keyA, valueA); - await methods.set(this.map, keyC, valueC); + await this.methods.set(this.keyA, this.valueA); + await this.methods.set(this.keyC, this.valueC); // [A, C] - await methods.remove(this.map, keyA); - await methods.remove(this.map, keyB); + await this.methods.remove(this.keyA); + await this.methods.remove(this.keyB); // [C] - await methods.set(this.map, keyB, valueB); + await this.methods.set(this.keyB, this.valueB); // [C, B] - await methods.set(this.map, keyA, valueA); - await methods.remove(this.map, keyC); + await this.methods.set(this.keyA, this.valueA); + await this.methods.remove(this.keyC); // [A, B] - await methods.set(this.map, keyA, valueA); - await methods.set(this.map, keyB, valueB); + await this.methods.set(this.keyA, this.valueA); + await this.methods.set(this.keyB, this.valueB); // [A, B] - await methods.set(this.map, keyC, valueC); - await methods.remove(this.map, keyA); + await this.methods.set(this.keyC, this.valueC); + await this.methods.remove(this.keyA); // [B, C] - await methods.set(this.map, keyA, valueA); - await methods.remove(this.map, keyB); + await this.methods.set(this.keyA, this.valueA); + await this.methods.remove(this.keyB); // [A, C] - await expectMembersMatch(this.map, [keyA, keyC], [valueA, valueC]); + await expectMembersMatch(this.methods, [this.keyA, this.keyC], [this.valueA, this.valueC]); - expect(await methods.contains(this.map, keyA)).to.equal(true); - expect(await methods.contains(this.map, keyB)).to.equal(false); - expect(await methods.contains(this.map, keyC)).to.equal(true); + expect(await this.methods.contains(this.keyA)).to.be.true; + expect(await this.methods.contains(this.keyB)).to.be.false; + expect(await this.methods.contains(this.keyC)).to.be.true; }); }); describe('read', function () { beforeEach(async function () { - await methods.set(this.map, keyA, valueA); + await this.methods.set(this.keyA, this.valueA); }); describe('get', function () { it('existing value', async function () { - expect(await methods.get(this.map, keyA).then(r => r.toString())).to.be.equal(valueA.toString()); + expect(await this.methods.get(this.keyA)).to.be.equal(this.valueA); }); + it('missing value', async function () { - const key = web3.utils.toHex(keyB); - await expectRevertCustomError(methods.get(this.map, keyB), 'EnumerableMapNonexistentKey', [ - key.length == 66 ? key : web3.utils.padLeft(key, 64, '0'), - ]); + await expect(this.methods.get(this.keyB)) + .to.be.revertedWithCustomError(this.mock, 'EnumerableMapNonexistentKey') + .withArgs(ethers.AbiCoder.defaultAbiCoder().encode([keyType], [this.keyB])); }); }); describe('tryGet', function () { it('existing value', async function () { - const result = await methods.tryGet(this.map, keyA); - expect(result['0']).to.be.equal(true); - expect(result['1'].toString()).to.be.equal(valueA.toString()); + expect(await this.methods.tryGet(this.keyA)).to.have.ordered.members([true, this.valueA]); }); + it('missing value', async function () { - const result = await methods.tryGet(this.map, keyB); - expect(result['0']).to.be.equal(false); - expect(result['1'].toString()).to.be.equal(zeroValue.toString()); + expect(await this.methods.tryGet(this.keyB)).to.have.ordered.members([false, zeroValue]); }); }); }); diff --git a/test/utils/structs/EnumerableMap.test.js b/test/utils/structs/EnumerableMap.test.js index 545e12a4f..accdb52fa 100644 --- a/test/utils/structs/EnumerableMap.test.js +++ b/test/utils/structs/EnumerableMap.test.js @@ -1,149 +1,145 @@ -const { BN, constants } = require('@openzeppelin/test-helpers'); +const { ethers } = require('hardhat'); +const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers'); const { mapValues } = require('../../helpers/iterate'); - -const EnumerableMap = artifacts.require('$EnumerableMap'); +const { randomArray, generators } = require('../../helpers/random'); const { shouldBehaveLikeMap } = require('./EnumerableMap.behavior'); -const getMethods = ms => { +const getMethods = (mock, fnSigs) => { return mapValues( - ms, - m => - (self, ...args) => - self.methods[m](0, ...args), + fnSigs, + fnSig => + (...args) => + mock.getFunction(fnSig)(0, ...args), ); }; -// Get the name of the library. In the transpiled code it will be EnumerableMapUpgradeable. -const library = EnumerableMap._json.contractName.replace(/^\$/, ''); - -contract('EnumerableMap', function (accounts) { - const [accountA, accountB, accountC] = accounts; - - const keyA = new BN('7891'); - const keyB = new BN('451'); - const keyC = new BN('9592328'); - - const bytesA = '0xdeadbeef'.padEnd(66, '0'); - const bytesB = '0x0123456789'.padEnd(66, '0'); - const bytesC = '0x42424242'.padEnd(66, '0'); - - beforeEach(async function () { - this.map = await EnumerableMap.new(); - }); - - // AddressToUintMap - describe('AddressToUintMap', function () { - shouldBehaveLikeMap( - [accountA, accountB, accountC], - [keyA, keyB, keyC], - new BN('0'), - getMethods({ - set: '$set(uint256,address,uint256)', - get: '$get(uint256,address)', - tryGet: '$tryGet(uint256,address)', - remove: '$remove(uint256,address)', - length: `$length_${library}_AddressToUintMap(uint256)`, - at: `$at_${library}_AddressToUintMap(uint256,uint256)`, - contains: '$contains(uint256,address)', - keys: `$keys_${library}_AddressToUintMap(uint256)`, - }), - { - setReturn: `return$set_${library}_AddressToUintMap_address_uint256`, - removeReturn: `return$remove_${library}_AddressToUintMap_address`, - }, - ); - }); - +describe('EnumerableMap', function () { // UintToAddressMap describe('UintToAddressMap', function () { - shouldBehaveLikeMap( - [keyA, keyB, keyC], - [accountA, accountB, accountC], - constants.ZERO_ADDRESS, - getMethods({ + const fixture = async () => { + const mock = await ethers.deployContract('$EnumerableMap'); + + const [keyA, keyB, keyC] = randomArray(generators.uint256); + const [valueA, valueB, valueC] = randomArray(generators.address); + + const methods = getMethods(mock, { set: '$set(uint256,uint256,address)', - get: `$get_${library}_UintToAddressMap(uint256,uint256)`, - tryGet: `$tryGet_${library}_UintToAddressMap(uint256,uint256)`, - remove: `$remove_${library}_UintToAddressMap(uint256,uint256)`, - length: `$length_${library}_UintToAddressMap(uint256)`, - at: `$at_${library}_UintToAddressMap(uint256,uint256)`, - contains: `$contains_${library}_UintToAddressMap(uint256,uint256)`, - keys: `$keys_${library}_UintToAddressMap(uint256)`, - }), - { - setReturn: `return$set_${library}_UintToAddressMap_uint256_address`, - removeReturn: `return$remove_${library}_UintToAddressMap_uint256`, - }, - ); + get: '$get_EnumerableMap_UintToAddressMap(uint256,uint256)', + tryGet: '$tryGet_EnumerableMap_UintToAddressMap(uint256,uint256)', + remove: '$remove_EnumerableMap_UintToAddressMap(uint256,uint256)', + length: '$length_EnumerableMap_UintToAddressMap(uint256)', + at: '$at_EnumerableMap_UintToAddressMap(uint256,uint256)', + contains: '$contains_EnumerableMap_UintToAddressMap(uint256,uint256)', + keys: '$keys_EnumerableMap_UintToAddressMap(uint256)', + }); + + return { mock, keyA, keyB, keyC, valueA, valueB, valueC, methods }; + }; + + beforeEach(async function () { + Object.assign(this, await loadFixture(fixture)); + }); + + shouldBehaveLikeMap(ethers.ZeroAddress, 'uint256', { + setReturn: 'return$set_EnumerableMap_UintToAddressMap_uint256_address', + removeReturn: 'return$remove_EnumerableMap_UintToAddressMap_uint256', + }); }); // Bytes32ToBytes32Map describe('Bytes32ToBytes32Map', function () { - shouldBehaveLikeMap( - [keyA, keyB, keyC].map(k => '0x' + k.toString(16).padEnd(64, '0')), - [bytesA, bytesB, bytesC], - constants.ZERO_BYTES32, - getMethods({ + const fixture = async () => { + const mock = await ethers.deployContract('$EnumerableMap'); + + const [keyA, keyB, keyC] = randomArray(generators.bytes32); + const [valueA, valueB, valueC] = randomArray(generators.bytes32); + + const methods = getMethods(mock, { set: '$set(uint256,bytes32,bytes32)', - get: `$get_${library}_Bytes32ToBytes32Map(uint256,bytes32)`, - tryGet: `$tryGet_${library}_Bytes32ToBytes32Map(uint256,bytes32)`, - remove: `$remove_${library}_Bytes32ToBytes32Map(uint256,bytes32)`, - length: `$length_${library}_Bytes32ToBytes32Map(uint256)`, - at: `$at_${library}_Bytes32ToBytes32Map(uint256,uint256)`, - contains: `$contains_${library}_Bytes32ToBytes32Map(uint256,bytes32)`, - keys: `$keys_${library}_Bytes32ToBytes32Map(uint256)`, - }), - { - setReturn: `return$set_${library}_Bytes32ToBytes32Map_bytes32_bytes32`, - removeReturn: `return$remove_${library}_Bytes32ToBytes32Map_bytes32`, - }, - ); + get: '$get_EnumerableMap_Bytes32ToBytes32Map(uint256,bytes32)', + tryGet: '$tryGet_EnumerableMap_Bytes32ToBytes32Map(uint256,bytes32)', + remove: '$remove_EnumerableMap_Bytes32ToBytes32Map(uint256,bytes32)', + length: '$length_EnumerableMap_Bytes32ToBytes32Map(uint256)', + at: '$at_EnumerableMap_Bytes32ToBytes32Map(uint256,uint256)', + contains: '$contains_EnumerableMap_Bytes32ToBytes32Map(uint256,bytes32)', + keys: '$keys_EnumerableMap_Bytes32ToBytes32Map(uint256)', + }); + + return { mock, keyA, keyB, keyC, valueA, valueB, valueC, methods }; + }; + + beforeEach(async function () { + Object.assign(this, await loadFixture(fixture)); + }); + + shouldBehaveLikeMap(ethers.ZeroHash, 'bytes32', { + setReturn: 'return$set_EnumerableMap_Bytes32ToBytes32Map_bytes32_bytes32', + removeReturn: 'return$remove_EnumerableMap_Bytes32ToBytes32Map_bytes32', + }); }); // UintToUintMap describe('UintToUintMap', function () { - shouldBehaveLikeMap( - [keyA, keyB, keyC], - [keyA, keyB, keyC].map(k => k.add(new BN('1332'))), - new BN('0'), - getMethods({ + const fixture = async () => { + const mock = await ethers.deployContract('$EnumerableMap'); + + const [keyA, keyB, keyC] = randomArray(generators.uint256); + const [valueA, valueB, valueC] = randomArray(generators.uint256); + + const methods = getMethods(mock, { set: '$set(uint256,uint256,uint256)', - get: `$get_${library}_UintToUintMap(uint256,uint256)`, - tryGet: `$tryGet_${library}_UintToUintMap(uint256,uint256)`, - remove: `$remove_${library}_UintToUintMap(uint256,uint256)`, - length: `$length_${library}_UintToUintMap(uint256)`, - at: `$at_${library}_UintToUintMap(uint256,uint256)`, - contains: `$contains_${library}_UintToUintMap(uint256,uint256)`, - keys: `$keys_${library}_UintToUintMap(uint256)`, - }), - { - setReturn: `return$set_${library}_UintToUintMap_uint256_uint256`, - removeReturn: `return$remove_${library}_UintToUintMap_uint256`, - }, - ); + get: '$get_EnumerableMap_UintToUintMap(uint256,uint256)', + tryGet: '$tryGet_EnumerableMap_UintToUintMap(uint256,uint256)', + remove: '$remove_EnumerableMap_UintToUintMap(uint256,uint256)', + length: '$length_EnumerableMap_UintToUintMap(uint256)', + at: '$at_EnumerableMap_UintToUintMap(uint256,uint256)', + contains: '$contains_EnumerableMap_UintToUintMap(uint256,uint256)', + keys: '$keys_EnumerableMap_UintToUintMap(uint256)', + }); + + return { mock, keyA, keyB, keyC, valueA, valueB, valueC, methods }; + }; + + beforeEach(async function () { + Object.assign(this, await loadFixture(fixture)); + }); + + shouldBehaveLikeMap(0n, 'uint256', { + setReturn: 'return$set_EnumerableMap_UintToUintMap_uint256_uint256', + removeReturn: 'return$remove_EnumerableMap_UintToUintMap_uint256', + }); }); // Bytes32ToUintMap describe('Bytes32ToUintMap', function () { - shouldBehaveLikeMap( - [bytesA, bytesB, bytesC], - [keyA, keyB, keyC], - new BN('0'), - getMethods({ + const fixture = async () => { + const mock = await ethers.deployContract('$EnumerableMap'); + + const [keyA, keyB, keyC] = randomArray(generators.bytes32); + const [valueA, valueB, valueC] = randomArray(generators.uint256); + + const methods = getMethods(mock, { set: '$set(uint256,bytes32,uint256)', - get: `$get_${library}_Bytes32ToUintMap(uint256,bytes32)`, - tryGet: `$tryGet_${library}_Bytes32ToUintMap(uint256,bytes32)`, - remove: `$remove_${library}_Bytes32ToUintMap(uint256,bytes32)`, - length: `$length_${library}_Bytes32ToUintMap(uint256)`, - at: `$at_${library}_Bytes32ToUintMap(uint256,uint256)`, - contains: `$contains_${library}_Bytes32ToUintMap(uint256,bytes32)`, - keys: `$keys_${library}_Bytes32ToUintMap(uint256)`, - }), - { - setReturn: `return$set_${library}_Bytes32ToUintMap_bytes32_uint256`, - removeReturn: `return$remove_${library}_Bytes32ToUintMap_bytes32`, - }, - ); + get: '$get_EnumerableMap_Bytes32ToUintMap(uint256,bytes32)', + tryGet: '$tryGet_EnumerableMap_Bytes32ToUintMap(uint256,bytes32)', + remove: '$remove_EnumerableMap_Bytes32ToUintMap(uint256,bytes32)', + length: '$length_EnumerableMap_Bytes32ToUintMap(uint256)', + at: '$at_EnumerableMap_Bytes32ToUintMap(uint256,uint256)', + contains: '$contains_EnumerableMap_Bytes32ToUintMap(uint256,bytes32)', + keys: '$keys_EnumerableMap_Bytes32ToUintMap(uint256)', + }); + + return { mock, keyA, keyB, keyC, valueA, valueB, valueC, methods }; + }; + + beforeEach(async function () { + Object.assign(this, await loadFixture(fixture)); + }); + + shouldBehaveLikeMap(0n, 'bytes32', { + setReturn: 'return$set_EnumerableMap_Bytes32ToUintMap_bytes32_uint256', + removeReturn: 'return$remove_EnumerableMap_Bytes32ToUintMap_bytes32', + }); }); }); diff --git a/test/utils/structs/EnumerableSet.behavior.js b/test/utils/structs/EnumerableSet.behavior.js index f80eb8169..5b9e067e8 100644 --- a/test/utils/structs/EnumerableSet.behavior.js +++ b/test/utils/structs/EnumerableSet.behavior.js @@ -1,125 +1,106 @@ -const { expectEvent, expectRevert } = require('@openzeppelin/test-helpers'); const { expect } = require('chai'); -function shouldBehaveLikeSet(values, methods, events) { - const [valueA, valueB, valueC] = values; +function shouldBehaveLikeSet(events) { + async function expectMembersMatch(methods, values) { + expect(await methods.length()).to.equal(values.length); + for (const value of values) expect(await methods.contains(value)).to.be.true; - async function expectMembersMatch(set, values) { - const contains = await Promise.all(values.map(value => methods.contains(set, value))); - expect(contains.every(Boolean)).to.be.equal(true); - - const length = await methods.length(set); - expect(length).to.bignumber.equal(values.length.toString()); - - // To compare values we convert to strings to workaround Chai - // limitations when dealing with nested arrays (required for BNs) - const indexedValues = await Promise.all( - Array(values.length) - .fill() - .map((_, index) => methods.at(set, index)), - ); - expect(indexedValues.map(v => v.toString())).to.have.same.members(values.map(v => v.toString())); - - const returnedValues = await methods.values(set); - expect(returnedValues.map(v => v.toString())).to.have.same.members(values.map(v => v.toString())); + expect(await Promise.all(values.map((_, index) => methods.at(index)))).to.have.deep.members(values); + expect([...(await methods.values())]).to.have.deep.members(values); } it('starts empty', async function () { - expect(await methods.contains(this.set, valueA)).to.equal(false); + expect(await this.methods.contains(this.valueA)).to.be.false; - await expectMembersMatch(this.set, []); + await expectMembersMatch(this.methods, []); }); describe('add', function () { it('adds a value', async function () { - const receipt = await methods.add(this.set, valueA); - expectEvent(receipt, events.addReturn, { ret0: true }); + await expect(this.methods.add(this.valueA)).to.emit(this.mock, events.addReturn).withArgs(true); - await expectMembersMatch(this.set, [valueA]); + await expectMembersMatch(this.methods, [this.valueA]); }); it('adds several values', async function () { - await methods.add(this.set, valueA); - await methods.add(this.set, valueB); + await this.methods.add(this.valueA); + await this.methods.add(this.valueB); - await expectMembersMatch(this.set, [valueA, valueB]); - expect(await methods.contains(this.set, valueC)).to.equal(false); + await expectMembersMatch(this.methods, [this.valueA, this.valueB]); + expect(await this.methods.contains(this.valueC)).to.be.false; }); it('returns false when adding values already in the set', async function () { - await methods.add(this.set, valueA); + await this.methods.add(this.valueA); - const receipt = await methods.add(this.set, valueA); - expectEvent(receipt, events.addReturn, { ret0: false }); + await expect(this.methods.add(this.valueA)).to.emit(this.mock, events.addReturn).withArgs(false); - await expectMembersMatch(this.set, [valueA]); + await expectMembersMatch(this.methods, [this.valueA]); }); }); describe('at', function () { it('reverts when retrieving non-existent elements', async function () { - await expectRevert.unspecified(methods.at(this.set, 0)); + await expect(this.methods.at(0)).to.be.reverted; }); }); describe('remove', function () { it('removes added values', async function () { - await methods.add(this.set, valueA); + await this.methods.add(this.valueA); - const receipt = await methods.remove(this.set, valueA); - expectEvent(receipt, events.removeReturn, { ret0: true }); + await expect(this.methods.remove(this.valueA)).to.emit(this.mock, events.removeReturn).withArgs(true); - expect(await methods.contains(this.set, valueA)).to.equal(false); - await expectMembersMatch(this.set, []); + expect(await this.methods.contains(this.valueA)).to.be.false; + await expectMembersMatch(this.methods, []); }); it('returns false when removing values not in the set', async function () { - const receipt = await methods.remove(this.set, valueA); - expectEvent(receipt, events.removeReturn, { ret0: false }); + await expect(this.methods.remove(this.valueA)).to.emit(this.mock, events.removeReturn).withArgs(false); - expect(await methods.contains(this.set, valueA)).to.equal(false); + expect(await this.methods.contains(this.valueA)).to.be.false; }); it('adds and removes multiple values', async function () { // [] - await methods.add(this.set, valueA); - await methods.add(this.set, valueC); + await this.methods.add(this.valueA); + await this.methods.add(this.valueC); // [A, C] - await methods.remove(this.set, valueA); - await methods.remove(this.set, valueB); + await this.methods.remove(this.valueA); + await this.methods.remove(this.valueB); // [C] - await methods.add(this.set, valueB); + await this.methods.add(this.valueB); // [C, B] - await methods.add(this.set, valueA); - await methods.remove(this.set, valueC); + await this.methods.add(this.valueA); + await this.methods.remove(this.valueC); // [A, B] - await methods.add(this.set, valueA); - await methods.add(this.set, valueB); + await this.methods.add(this.valueA); + await this.methods.add(this.valueB); // [A, B] - await methods.add(this.set, valueC); - await methods.remove(this.set, valueA); + await this.methods.add(this.valueC); + await this.methods.remove(this.valueA); // [B, C] - await methods.add(this.set, valueA); - await methods.remove(this.set, valueB); + await this.methods.add(this.valueA); + await this.methods.remove(this.valueB); // [A, C] - await expectMembersMatch(this.set, [valueA, valueC]); + await expectMembersMatch(this.methods, [this.valueA, this.valueC]); - expect(await methods.contains(this.set, valueB)).to.equal(false); + expect(await this.methods.contains(this.valueB)).to.be.false; }); }); } diff --git a/test/utils/structs/EnumerableSet.test.js b/test/utils/structs/EnumerableSet.test.js index a1840257b..726ea0ee3 100644 --- a/test/utils/structs/EnumerableSet.test.js +++ b/test/utils/structs/EnumerableSet.test.js @@ -1,79 +1,104 @@ -const EnumerableSet = artifacts.require('$EnumerableSet'); +const { ethers } = require('hardhat'); +const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers'); const { mapValues } = require('../../helpers/iterate'); +const { randomArray, generators } = require('../../helpers/random'); const { shouldBehaveLikeSet } = require('./EnumerableSet.behavior'); -const getMethods = ms => { +const getMethods = (mock, fnSigs) => { return mapValues( - ms, - m => - (self, ...args) => - self.methods[m](0, ...args), + fnSigs, + fnSig => + (...args) => + mock.getFunction(fnSig)(0, ...args), ); }; -// Get the name of the library. In the transpiled code it will be EnumerableSetUpgradeable. -const library = EnumerableSet._json.contractName.replace(/^\$/, ''); - -contract('EnumerableSet', function (accounts) { - beforeEach(async function () { - this.set = await EnumerableSet.new(); - }); - +describe('EnumerableSet', function () { // Bytes32Set describe('EnumerableBytes32Set', function () { - shouldBehaveLikeSet( - ['0xdeadbeef', '0x0123456789', '0x42424242'].map(e => e.padEnd(66, '0')), - getMethods({ + const fixture = async () => { + const mock = await ethers.deployContract('$EnumerableSet'); + + const [valueA, valueB, valueC] = randomArray(generators.bytes32); + + const methods = getMethods(mock, { add: '$add(uint256,bytes32)', remove: '$remove(uint256,bytes32)', contains: '$contains(uint256,bytes32)', - length: `$length_${library}_Bytes32Set(uint256)`, - at: `$at_${library}_Bytes32Set(uint256,uint256)`, - values: `$values_${library}_Bytes32Set(uint256)`, - }), - { - addReturn: `return$add_${library}_Bytes32Set_bytes32`, - removeReturn: `return$remove_${library}_Bytes32Set_bytes32`, - }, - ); + length: `$length_EnumerableSet_Bytes32Set(uint256)`, + at: `$at_EnumerableSet_Bytes32Set(uint256,uint256)`, + values: `$values_EnumerableSet_Bytes32Set(uint256)`, + }); + + return { mock, valueA, valueB, valueC, methods }; + }; + + beforeEach(async function () { + Object.assign(this, await loadFixture(fixture)); + }); + + shouldBehaveLikeSet({ + addReturn: `return$add_EnumerableSet_Bytes32Set_bytes32`, + removeReturn: `return$remove_EnumerableSet_Bytes32Set_bytes32`, + }); }); // AddressSet describe('EnumerableAddressSet', function () { - shouldBehaveLikeSet( - accounts, - getMethods({ + const fixture = async () => { + const mock = await ethers.deployContract('$EnumerableSet'); + + const [valueA, valueB, valueC] = randomArray(generators.address); + + const methods = getMethods(mock, { add: '$add(uint256,address)', remove: '$remove(uint256,address)', contains: '$contains(uint256,address)', - length: `$length_${library}_AddressSet(uint256)`, - at: `$at_${library}_AddressSet(uint256,uint256)`, - values: `$values_${library}_AddressSet(uint256)`, - }), - { - addReturn: `return$add_${library}_AddressSet_address`, - removeReturn: `return$remove_${library}_AddressSet_address`, - }, - ); + length: `$length_EnumerableSet_AddressSet(uint256)`, + at: `$at_EnumerableSet_AddressSet(uint256,uint256)`, + values: `$values_EnumerableSet_AddressSet(uint256)`, + }); + + return { mock, valueA, valueB, valueC, methods }; + }; + + beforeEach(async function () { + Object.assign(this, await loadFixture(fixture)); + }); + + shouldBehaveLikeSet({ + addReturn: `return$add_EnumerableSet_AddressSet_address`, + removeReturn: `return$remove_EnumerableSet_AddressSet_address`, + }); }); // UintSet describe('EnumerableUintSet', function () { - shouldBehaveLikeSet( - [1234, 5678, 9101112].map(e => web3.utils.toBN(e)), - getMethods({ + const fixture = async () => { + const mock = await ethers.deployContract('$EnumerableSet'); + + const [valueA, valueB, valueC] = randomArray(generators.uint256); + + const methods = getMethods(mock, { add: '$add(uint256,uint256)', remove: '$remove(uint256,uint256)', contains: '$contains(uint256,uint256)', - length: `$length_${library}_UintSet(uint256)`, - at: `$at_${library}_UintSet(uint256,uint256)`, - values: `$values_${library}_UintSet(uint256)`, - }), - { - addReturn: `return$add_${library}_UintSet_uint256`, - removeReturn: `return$remove_${library}_UintSet_uint256`, - }, - ); + length: `$length_EnumerableSet_UintSet(uint256)`, + at: `$at_EnumerableSet_UintSet(uint256,uint256)`, + values: `$values_EnumerableSet_UintSet(uint256)`, + }); + + return { mock, valueA, valueB, valueC, methods }; + }; + + beforeEach(async function () { + Object.assign(this, await loadFixture(fixture)); + }); + + shouldBehaveLikeSet({ + addReturn: `return$add_EnumerableSet_UintSet_uint256`, + removeReturn: `return$remove_EnumerableSet_UintSet_uint256`, + }); }); });