EnumerableMapUintToAddress tests

Author: NouDaimon

test/data/EnumerableMap.ts

@@ -1,14 +1,16 @@
 import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/signers';
-import { bnToBytes32, bnToAddress } from '@solidstate/library';
+import { bnToAddress } from '@solidstate/library';
 import {
   EnumerableMapAddressToAddressMock,
   EnumerableMapAddressToAddressMock__factory,
+  EnumerableMapUintToAddressMock,
+  EnumerableMapUintToAddressMock__factory,
 } from '@solidstate/typechain-types';
 import { expect } from 'chai';
 import { BigNumber } from 'ethers';
 import { ethers } from 'hardhat';
 
-describe('EnumerableMap', async () => {
+describe('EnumerableMap', () => {
   describe('AddressToAddressMap', async () => {
     let instance: EnumerableMapAddressToAddressMock;
     let deployer: SignerWithAddress;
@@ -200,4 +202,203 @@ describe('EnumerableMap', async () => {
       });
     });
   });
+
+  describe('UintToAddressMap', async () => {
+    let instance: EnumerableMapUintToAddressMock;
+    let deployer: SignerWithAddress;
+
+    beforeEach(async () => {
+      [deployer] = await ethers.getSigners();
+      instance = await new EnumerableMapUintToAddressMock__factory(
+        deployer,
+      ).deploy();
+    });
+
+    describe('__internal', () => {
+      const addressOne = bnToAddress(BigNumber.from('100'));
+      const addressTwo = bnToAddress(BigNumber.from('200'));
+      const addressThree = bnToAddress(BigNumber.from('300'));
+      const uintOne = BigNumber.from('1');
+      const uintTwo = BigNumber.from('2');
+      const uintThree = BigNumber.from('3');
+
+      describe('#at(uint256)', () => {
+        it('returns value coresponding to index provided', async () => {
+          await instance['set(uint256,address)'](uintOne, addressOne);
+          await instance['set(uint256,address)'](uintTwo, addressTwo);
+          await instance['set(uint256,address)'](uintThree, addressThree);
+
+          expect(await instance['at(uint256)'](0)).to.deep.equal([
+            uintOne,
+            addressOne,
+          ]);
+          expect(await instance['at(uint256)'](1)).to.deep.equal([
+            uintTwo,
+            addressTwo,
+          ]);
+          expect(await instance['at(uint256)'](2)).to.deep.equal([
+            uintThree,
+            addressThree,
+          ]);
+        });
+
+        describe('reverts if', () => {
+          it('index is out of bounds', async () => {
+            await expect(
+              instance['at(uint256)'](0),
+            ).to.be.revertedWithCustomError(
+              instance,
+              'EnumerableMap__IndexOutOfBounds',
+            );
+          });
+        });
+      });
+
+      describe('#contains(uint256)', () => {
+        it('returns true if value has been added', async () => {
+          await instance['set(uint256,address)'](uintOne, addressOne);
+          await instance['set(uint256,address)'](uintTwo, addressTwo);
+          await instance['set(uint256,address)'](uintThree, addressThree);
+
+          expect(await instance['contains(uint256)'](uintOne)).to.be.true;
+          expect(await instance['contains(uint256)'](uintTwo)).to.be.true;
+          expect(await instance['contains(uint256)'](uintThree)).to.be.true;
+        });
+
+        it('returns false if value has not been added', async () => {
+          expect(await instance['contains(uint256)'](uintOne)).to.be.false;
+        });
+      });
+
+      describe('#length()', () => {
+        it('returns length of enumerable map', async () => {
+          expect(await instance['length()']()).to.equal(0);
+
+          await instance['set(uint256,address)'](uintOne, addressOne);
+          expect(await instance['length()']()).to.equal(1);
+
+          await instance['set(uint256,address)'](uintTwo, addressTwo);
+          expect(await instance['length()']()).to.equal(2);
+
+          await instance['set(uint256,address)'](uintThree, addressThree);
+          expect(await instance['length()']()).to.equal(3);
+
+          await instance['remove(uint256)'](uintOne);
+          expect(await instance['length()']()).to.equal(2);
+
+          await instance['remove(uint256)'](uintTwo);
+          expect(await instance['length()']()).to.equal(1);
+
+          await instance['remove(uint256)'](uintThree);
+          expect(await instance['length()']()).to.equal(0);
+        });
+      });
+
+      describe('#get(uint256)', () => {
+        it('returns address stored at key', async () => {
+          await instance['set(uint256,address)'](uintOne, addressOne);
+          await instance['set(uint256,address)'](uintTwo, addressTwo);
+          await instance['set(uint256,address)'](uintThree, addressThree);
+
+          expect(await instance['get(uint256)'](uintOne)).to.eq(addressOne);
+          expect(await instance['get(uint256)'](uintTwo)).to.eq(addressTwo);
+          expect(await instance['get(uint256)'](uintThree)).to.eq(addressThree);
+        });
+
+        describe('reverts if', () => {
+          it('key does not exist', async () => {
+            await expect(
+              instance['get(uint256)'](uintOne),
+            ).to.be.revertedWithCustomError(
+              instance,
+              'EnumerableMap__NonExistentKey',
+            );
+          });
+        });
+      });
+
+      describe('#set(uint256,address)', () => {
+        it('sets the address value at uint256 key', async () => {
+          await instance['set(uint256,address)'](uintOne, addressOne);
+          await instance['set(uint256,address)'](uintTwo, addressTwo);
+          await instance['set(uint256,address)'](uintThree, addressThree);
+
+          expect(await instance['contains(uint256)'](uintOne)).to.be.true;
+          expect(await instance['contains(uint256)'](uintTwo)).to.be.true;
+          expect(await instance['contains(uint256)'](uintThree)).to.be.true;
+
+          expect(await instance['get(uint256)'](uintOne)).to.eq(addressOne);
+          expect(await instance['get(uint256)'](uintTwo)).to.eq(addressTwo);
+          expect(await instance['get(uint256)'](uintThree)).to.eq(addressThree);
+        });
+
+        it('returns true if address value is added at uint256 key', async () => {
+          expect(
+            await instance.callStatic['set(uint256,address)'](
+              uintOne,
+              addressOne,
+            ),
+          ).to.be.true;
+        });
+
+        it('returns false if address value is already added at uint256 key', async () => {
+          await instance['set(uint256,address)'](uintOne, addressOne);
+
+          expect(
+            await instance.callStatic['set(uint256,address)'](
+              uintOne,
+              addressOne,
+            ),
+          ).to.be.false;
+        });
+      });
+
+      describe('#remove(uint256)', () => {
+        it('removes the address value at given uint256 key', async () => {
+          await instance['set(uint256,address)'](uintOne, addressOne);
+          await instance['set(uint256,address)'](uintTwo, addressTwo);
+          await instance['set(uint256,address)'](uintThree, addressThree);
+
+          expect(await instance['length()']()).to.eq(3);
+
+          await instance['remove(uint256)'](uintOne);
+          await expect(
+            instance['get(uint256)'](uintOne),
+          ).to.be.revertedWithCustomError(
+            instance,
+            'EnumerableMap__NonExistentKey',
+          );
+          expect(await instance['length()']()).to.eq(2);
+
+          await instance['remove(uint256)'](uintTwo);
+          await expect(
+            instance['get(uint256)'](uintTwo),
+          ).to.be.revertedWithCustomError(
+            instance,
+            'EnumerableMap__NonExistentKey',
+          );
+          expect(await instance['length()']()).to.eq(1);
+
+          await instance['remove(uint256)'](uintThree);
+          await expect(
+            instance['get(uint256)'](uintThree),
+          ).to.be.revertedWithCustomError(
+            instance,
+            'EnumerableMap__NonExistentKey',
+          );
+          expect(await instance['length()']()).to.eq(0);
+        });
+
+        it('returns true if uint256 key removed', async () => {
+          await instance['set(uint256,address)'](uintOne, addressOne);
+          expect(await instance.callStatic['remove(uint256)'](uintOne)).to.be
+            .true;
+        });
+        it('returns false if uint256 key does not exist', async () => {
+          expect(await instance.callStatic['remove(uint256)'](uintOne)).to.be
+            .false;
+        });
+      });
+    });
+  });
 });