Replace chai.should with chai.expect (#1780)

* changed exxpect to expect wherever applicable

* Merged with latest branch

* Updated merkleTree helper to latest master branch

* Made linting fixes

* Fix for test build

* updated for Coverage

* Updated Address.test.js

* Undo package-lock changes.

test/utils/Address.test.js

@@ -1,4 +1,5 @@
 const { constants } = require('openzeppelin-test-helpers');
+const { expect } = require('chai');
 
 const AddressImpl = artifacts.require('AddressImpl');
 const SimpleToken = artifacts.require('SimpleToken');
@@ -12,26 +13,26 @@ contract('Address', function ([_, other]) {
 
   describe('isContract', function () {
     it('should return false for account address', async function () {
-      (await this.mock.isContract(other)).should.equal(false);
+      expect(await this.mock.isContract(other)).to.equal(false);
     });
 
     it('should return true for contract address', async function () {
       const contract = await SimpleToken.new();
-      (await this.mock.isContract(contract.address)).should.equal(true);
+      expect(await this.mock.isContract(contract.address)).to.equal(true);
     });
   });
 
   describe('toPayable', function () {
     it('should return a payable address when the account is the zero address', async function () {
-      (await this.mock.toPayable(constants.ZERO_ADDRESS)).should.equal(constants.ZERO_ADDRESS);
+      expect(await this.mock.toPayable(constants.ZERO_ADDRESS)).to.equal(constants.ZERO_ADDRESS);
     });
 
     it('should return a payable address when the account is an arbitrary address', async function () {
-      (await this.mock.toPayable(other)).should.equal(other);
+      expect(await this.mock.toPayable(other)).to.equal(other);
     });
 
     it('should return a payable address when the account is the all ones address', async function () {
-      (await this.mock.toPayable(ALL_ONES_ADDRESS)).should.equal(ALL_ONES_ADDRESS);
+      expect(await this.mock.toPayable(ALL_ONES_ADDRESS)).to.equal(ALL_ONES_ADDRESS);
     });
   });
 });

test/utils/Arrays.test.js

@@ -1,5 +1,7 @@
 require('openzeppelin-test-helpers');
 
+const { expect } = require('chai');
+
 const ArraysImpl = artifacts.require('ArraysImpl');
 
 contract('Arrays', function () {
@@ -11,23 +13,23 @@ contract('Arrays', function () {
     });
 
     it('should return correct index for the basic case', async function () {
-      (await this.arrays.findUpperBound(16)).should.be.bignumber.equal('5');
+      expect(await this.arrays.findUpperBound(16)).to.be.bignumber.equal('5');
     });
 
     it('should return 0 for the first element', async function () {
-      (await this.arrays.findUpperBound(11)).should.be.bignumber.equal('0');
+      expect(await this.arrays.findUpperBound(11)).to.be.bignumber.equal('0');
     });
 
     it('should return index of the last element', async function () {
-      (await this.arrays.findUpperBound(20)).should.be.bignumber.equal('9');
+      expect(await this.arrays.findUpperBound(20)).to.be.bignumber.equal('9');
     });
 
     it('should return first index after last element if searched value is over the upper boundary', async function () {
-      (await this.arrays.findUpperBound(32)).should.be.bignumber.equal('10');
+      expect(await this.arrays.findUpperBound(32)).to.be.bignumber.equal('10');
     });
 
     it('should return 0 for the element under the lower boundary', async function () {
-      (await this.arrays.findUpperBound(2)).should.be.bignumber.equal('0');
+      expect(await this.arrays.findUpperBound(2)).to.be.bignumber.equal('0');
     });
   });
 
@@ -39,23 +41,23 @@ contract('Arrays', function () {
     });
 
     it('should return correct index for the basic case', async function () {
-      (await this.arrays.findUpperBound(16)).should.be.bignumber.equal('5');
+      expect(await this.arrays.findUpperBound(16)).to.be.bignumber.equal('5');
     });
 
     it('should return 0 for the first element', async function () {
-      (await this.arrays.findUpperBound(11)).should.be.bignumber.equal('0');
+      expect(await this.arrays.findUpperBound(11)).to.be.bignumber.equal('0');
     });
 
     it('should return index of the last element', async function () {
-      (await this.arrays.findUpperBound(21)).should.be.bignumber.equal('10');
+      expect(await this.arrays.findUpperBound(21)).to.be.bignumber.equal('10');
     });
 
     it('should return first index after last element if searched value is over the upper boundary', async function () {
-      (await this.arrays.findUpperBound(32)).should.be.bignumber.equal('11');
+      expect(await this.arrays.findUpperBound(32)).to.be.bignumber.equal('11');
     });
 
     it('should return 0 for the element under the lower boundary', async function () {
-      (await this.arrays.findUpperBound(2)).should.be.bignumber.equal('0');
+      expect(await this.arrays.findUpperBound(2)).to.be.bignumber.equal('0');
     });
   });
 
@@ -67,7 +69,7 @@ contract('Arrays', function () {
     });
 
     it('should return index of first element in next filled range', async function () {
-      (await this.arrays.findUpperBound(17)).should.be.bignumber.equal('5');
+      expect(await this.arrays.findUpperBound(17)).to.be.bignumber.equal('5');
     });
   });
 
@@ -77,7 +79,7 @@ contract('Arrays', function () {
     });
 
     it('should always return 0 for empty array', async function () {
-      (await this.arrays.findUpperBound(10)).should.be.bignumber.equal('0');
+      expect(await this.arrays.findUpperBound(10)).to.be.bignumber.equal('0');
     });
   });
 });

test/utils/ReentrancyGuard.test.js

@@ -1,12 +1,14 @@
 const { expectRevert } = require('openzeppelin-test-helpers');
 
+const { expect } = require('chai');
+
 const ReentrancyMock = artifacts.require('ReentrancyMock');
 const ReentrancyAttack = artifacts.require('ReentrancyAttack');
 
 contract('ReentrancyGuard', function () {
   beforeEach(async function () {
     this.reentrancyMock = await ReentrancyMock.new();
-    (await this.reentrancyMock.counter()).should.be.bignumber.equal('0');
+    expect(await this.reentrancyMock.counter()).to.be.bignumber.equal('0');
   });
 
   it('should not allow remote callback', async function () {