Migrate 'arrays'

test/helpers/random.js

@@ -0,0 +1,7 @@
+const { ethers } = require("hardhat");
+
+function randomHex(length) {
+    return `0x${Buffer.from(ethers.randomBytes(length)).toString('hex')}`
+}
+
+module.exports = { randomHex }

test/utils/Arrays.test.js

@@ -1,88 +1,106 @@
-require('@openzeppelin/test-helpers');
-
+const { ethers } = require('hardhat');
 const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+const { randomHex } = require('../helpers/random');
+
+const AddressArraysMock = 'AddressArraysMock';
+const Bytes32ArraysMock = 'Bytes32ArraysMock';
+const Uint256ArraysMock = 'Uint256ArraysMock';
 
-const AddressArraysMock = artifacts.require('AddressArraysMock');
-const Bytes32ArraysMock = artifacts.require('Bytes32ArraysMock');
-const Uint256ArraysMock = artifacts.require('Uint256ArraysMock');
+async function fixture () {}
 
-contract('Arrays', function () {
+describe('Arrays', function () {
   describe('findUpperBound', function () {
-    context('Even number of elements', function () {
+    describe('Even number of elements', function () {
       const EVEN_ELEMENTS_ARRAY = [11, 12, 13, 14, 15, 16, 17, 18, 19, 20];
 
+      const fixture = async () => {
+        const arrays = await ethers.deployContract(Uint256ArraysMock, [EVEN_ELEMENTS_ARRAY]);
+        return { arrays };
+      }
+
       beforeEach(async function () {
-        this.arrays = await Uint256ArraysMock.new(EVEN_ELEMENTS_ARRAY);
+        Object.assign(this, await loadFixture(fixture));
       });
 
       it('returns correct index for the basic case', async function () {
-        expect(await this.arrays.findUpperBound(16)).to.be.bignumber.equal('5');
+        expect(await this.arrays.findUpperBound(16)).to.be.equal('5');
       });
 
       it('returns 0 for the first element', async function () {
-        expect(await this.arrays.findUpperBound(11)).to.be.bignumber.equal('0');
+        expect(await this.arrays.findUpperBound(11)).to.be.equal('0');
       });
 
       it('returns index of the last element', async function () {
-        expect(await this.arrays.findUpperBound(20)).to.be.bignumber.equal('9');
+        expect(await this.arrays.findUpperBound(20)).to.be.equal('9');
       });
 
       it('returns first index after last element if searched value is over the upper boundary', async function () {
-        expect(await this.arrays.findUpperBound(32)).to.be.bignumber.equal('10');
+        expect(await this.arrays.findUpperBound(32)).to.be.equal('10');
       });
 
       it('returns 0 for the element under the lower boundary', async function () {
-        expect(await this.arrays.findUpperBound(2)).to.be.bignumber.equal('0');
+        expect(await this.arrays.findUpperBound(2)).to.be.equal('0');
       });
     });
 
-    context('Odd number of elements', function () {
+    describe('Odd number of elements', function () {
       const ODD_ELEMENTS_ARRAY = [11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21];
 
+      const fixture = async () => {
+        const arrays = await ethers.deployContract(Uint256ArraysMock, [ODD_ELEMENTS_ARRAY]);
+        return { arrays };
+      }
+
       beforeEach(async function () {
-        this.arrays = await Uint256ArraysMock.new(ODD_ELEMENTS_ARRAY);
+        Object.assign(this, await loadFixture(fixture));
       });
 
       it('returns correct index for the basic case', async function () {
-        expect(await this.arrays.findUpperBound(16)).to.be.bignumber.equal('5');
+        expect(await this.arrays.findUpperBound(16)).to.be.equal('5');
       });
 
       it('returns 0 for the first element', async function () {
-        expect(await this.arrays.findUpperBound(11)).to.be.bignumber.equal('0');
+        expect(await this.arrays.findUpperBound(11)).to.be.equal('0');
       });
 
       it('returns index of the last element', async function () {
-        expect(await this.arrays.findUpperBound(21)).to.be.bignumber.equal('10');
+        expect(await this.arrays.findUpperBound(21)).to.be.equal('10');
       });
 
       it('returns first index after last element if searched value is over the upper boundary', async function () {
-        expect(await this.arrays.findUpperBound(32)).to.be.bignumber.equal('11');
+        expect(await this.arrays.findUpperBound(32)).to.be.equal('11');
       });
 
       it('returns 0 for the element under the lower boundary', async function () {
-        expect(await this.arrays.findUpperBound(2)).to.be.bignumber.equal('0');
+        expect(await this.arrays.findUpperBound(2)).to.be.equal('0');
       });
     });
 
-    context('Array with gap', function () {
+    describe('Array with gap', function () {
       const WITH_GAP_ARRAY = [11, 12, 13, 14, 15, 20, 21, 22, 23, 24];
 
+      const fixture = async () => {
+        const arrays = await ethers.deployContract(Uint256ArraysMock, [WITH_GAP_ARRAY]);
+        return { arrays };
+      }
+
       beforeEach(async function () {
-        this.arrays = await Uint256ArraysMock.new(WITH_GAP_ARRAY);
+        Object.assign(this, await loadFixture(fixture));
       });
 
       it('returns index of first element in next filled range', async function () {
-        expect(await this.arrays.findUpperBound(17)).to.be.bignumber.equal('5');
+        expect(await this.arrays.findUpperBound(17)).to.be.equal('5');
       });
     });
 
     context('Empty array', function () {
       beforeEach(async function () {
-        this.arrays = await Uint256ArraysMock.new([]);
+        this.arrays = await ethers.deployContract(Uint256ArraysMock, [[]]);
       });
 
       it('always returns 0 for empty array', async function () {
-        expect(await this.arrays.findUpperBound(10)).to.be.bignumber.equal('0');
+        expect(await this.arrays.findUpperBound(10)).to.be.equal('0');
       });
     });
   });
@@ -94,28 +112,30 @@ contract('Arrays', function () {
         artifact: AddressArraysMock,
         elements: Array(10)
           .fill()
-          .map(() => web3.utils.randomHex(20)),
+          .map(() => randomHex(20))
       },
       {
         type: 'bytes32',
         artifact: Bytes32ArraysMock,
         elements: Array(10)
           .fill()
-          .map(() => web3.utils.randomHex(32)),
+          .map(() => randomHex(32)),
       },
       {
         type: 'uint256',
         artifact: Uint256ArraysMock,
         elements: Array(10)
           .fill()
-          .map(() => web3.utils.randomHex(32)),
+          .map(() => randomHex(32)),
       },
     ]) {
       it(type, async function () {
-        const contract = await artifact.new(elements);
+        const contract = await ethers.deployContract(artifact, [elements]);
 
         for (const i in elements) {
-          expect(await contract.unsafeAccess(i)).to.be.bignumber.equal(elements[i]);
+          expect(await contract.unsafeAccess(i)).to.be.equal(
+            type == 'address' ? ethers.getAddress(elements[i]) : elements[i]
+          )
         }
       });
     }