Fix SafeMath test file (#865)

test/math/SafeMath.test.js

@@ -1,60 +1,91 @@
-import assertRevert from '../helpers/assertRevert';
-const assertJump = require('../helpers/assertJump');
-var SafeMathMock = artifacts.require('SafeMathMock');
+import assertJump from '../helpers/assertJump';
+const BigNumber = web3.BigNumber;
+const SafeMathMock = artifacts.require('SafeMathMock');
 
-contract('SafeMath', function (accounts) {
-  let safeMath;
+require('chai')
+  .use(require('chai-bignumber')(BigNumber))
+  .should();
+
+contract('SafeMath', () => {
+  const MAX_UINT = new BigNumber('115792089237316195423570985008687907853269984665640564039457584007913129639935');
 
   before(async function () {
-    safeMath = await SafeMathMock.new();
+    this.safeMath = await SafeMathMock.new();
   });
 
-  it('multiplies correctly', async function () {
-    let a = 5678;
-    let b = 1234;
-    await safeMath.multiply(a, b);
-    let result = await safeMath.result();
-    assert.equal(result, a * b);
+  describe('add', function () {
+    it('adds correctly', async function () {
+      const a = new BigNumber(5678);
+      const b = new BigNumber(1234);
+
+      const result = await this.safeMath.add(a, b);
+      result.should.be.bignumber.equal(a.plus(b));
+    });
+
+    it('throws an error on addition overflow', async function () {
+      const a = MAX_UINT;
+      const b = new BigNumber(1);
+
+      await assertJump(this.safeMath.add(a, b));
+    });
   });
 
-  it('adds correctly', async function () {
-    let a = 5678;
-    let b = 1234;
-    await safeMath.add(a, b);
-    let result = await safeMath.result();
+  describe('sub', function () {
+    it('subtracts correctly', async function () {
+      const a = new BigNumber(5678);
+      const b = new BigNumber(1234);
 
-    assert.equal(result, a + b);
+      const result = await this.safeMath.sub(a, b);
+      result.should.be.bignumber.equal(a.minus(b));
+    });
+
+    it('throws an error if subtraction result would be negative', async function () {
+      const a = new BigNumber(1234);
+      const b = new BigNumber(5678);
+
+      await assertJump(this.safeMath.sub(a, b));
+    });
   });
 
-  it('subtracts correctly', async function () {
-    let a = 5678;
-    let b = 1234;
-    await safeMath.subtract(a, b);
-    let result = await safeMath.result();
+  describe('mul', function () {
+    it('multiplies correctly', async function () {
+      const a = new BigNumber(1234);
+      const b = new BigNumber(5678);
 
-    assert.equal(result, a - b);
+      const result = await this.safeMath.mul(a, b);
+      result.should.be.bignumber.equal(a.times(b));
+    });
+
+    it('handles a zero product correctly', async function () {
+      const a = new BigNumber(0);
+      const b = new BigNumber(5678);
+
+      const result = await this.safeMath.mul(a, b);
+      result.should.be.bignumber.equal(a.times(b));
+    });
+
+    it('throws an error on multiplication overflow', async function () {
+      const a = MAX_UINT;
+      const b = new BigNumber(2);
+
+      await assertJump(this.safeMath.mul(a, b));
+    });
   });
 
-  it('should throw an error if subtraction result would be negative', async function () {
-    let a = 1234;
-    let b = 5678;
-    try {
-      await safeMath.subtract(a, b);
-      assert.fail('should have thrown before');
-    } catch (error) {
-      assertJump(error);
-    }
-  });
+  describe('div', function () {
+    it('divides correctly', async function () {
+      const a = new BigNumber(5678);
+      const b = new BigNumber(5678);
 
-  it('should throw an error on addition overflow', async function () {
-    let a = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
-    let b = 1;
-    await assertRevert(safeMath.add(a, b));
-  });
+      const result = await this.safeMath.div(a, b);
+      result.should.be.bignumber.equal(a.div(b));
+    });
 
-  it('should throw an error on multiplication overflow', async function () {
-    let a = 115792089237316195423570985008687907853269984665640564039457584007913129639933;
-    let b = 2;
-    await assertRevert(safeMath.multiply(a, b));
+    it('throws an error on zero division', async function () {
+      const a = new BigNumber(5678);
+      const b = new BigNumber(0);
+
+      await assertJump(this.safeMath.div(a, b));
+    });
   });
 });