Separate unsigned and signed safemath libraries (#1588)

* separate unsigned and signed safemath libraries

* update changelog entry for SignedSafeMath

test/drafts/SignedSafeMath.test.js

@@ -0,0 +1,138 @@
+const shouldFail = require('../helpers/shouldFail');
+const { MIN_INT256, MAX_INT256 } = require('../helpers/constants');
+
+const SignedSafeMathMock = artifacts.require('SignedSafeMathMock');
+
+const { BigNumber } = require('../helpers/setup');
+
+contract('SignedSafeMath', function () {
+  beforeEach(async function () {
+    this.safeMath = await SignedSafeMathMock.new();
+  });
+
+  describe('add', function () {
+    it('adds correctly if it does not overflow and the result is positve', async function () {
+      const a = new BigNumber(1234);
+      const b = new BigNumber(5678);
+
+      (await this.safeMath.add(a, b)).should.be.bignumber.equal(a.plus(b));
+    });
+
+    it('adds correctly if it does not overflow and the result is negative', async function () {
+      const a = MAX_INT256;
+      const b = MIN_INT256;
+
+      const result = await this.safeMath.add(a, b);
+      result.should.be.bignumber.equal(a.plus(b));
+    });
+
+    it('reverts on positive addition overflow', async function () {
+      const a = MAX_INT256;
+      const b = new BigNumber(1);
+
+      await shouldFail.reverting(this.safeMath.add(a, b));
+    });
+
+    it('reverts on negative addition overflow', async function () {
+      const a = MIN_INT256;
+      const b = new BigNumber(-1);
+
+      await shouldFail.reverting(this.safeMath.add(a, b));
+    });
+  });
+
+  describe('sub', function () {
+    it('subtracts correctly if it does not overflow and the result is positive', async function () {
+      const a = new BigNumber(5678);
+      const b = new BigNumber(1234);
+
+      const result = await this.safeMath.sub(a, b);
+      result.should.be.bignumber.equal(a.minus(b));
+    });
+
+    it('subtracts correctly if it does not overflow and the result is negative', async function () {
+      const a = new BigNumber(1234);
+      const b = new BigNumber(5678);
+
+      const result = await this.safeMath.sub(a, b);
+      result.should.be.bignumber.equal(a.minus(b));
+    });
+
+    it('reverts on positive subtraction overflow', async function () {
+      const a = MAX_INT256;
+      const b = new BigNumber(-1);
+
+      await shouldFail.reverting(this.safeMath.sub(a, b));
+    });
+
+    it('reverts on negative subtraction overflow', async function () {
+      const a = MIN_INT256;
+      const b = new BigNumber(1);
+
+      await shouldFail.reverting(this.safeMath.sub(a, b));
+    });
+  });
+
+  describe('mul', function () {
+    it('multiplies correctly', async function () {
+      const a = new BigNumber(5678);
+      const b = new BigNumber(-1234);
+
+      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('reverts on multiplication overflow, positive operands', async function () {
+      const a = MAX_INT256;
+      const b = new BigNumber(2);
+
+      await shouldFail.reverting(this.safeMath.mul(a, b));
+    });
+
+    it('reverts when minimum integer is multiplied by -1', async function () {
+      const a = MIN_INT256;
+      const b = new BigNumber(-1);
+
+      await shouldFail.reverting(this.safeMath.mul(a, b));
+    });
+
+    it('reverts when -1 is multiplied by minimum integer', async function () {
+      const a = new BigNumber(-1);
+      const b = MIN_INT256;
+
+      await shouldFail.reverting(this.safeMath.mul(a, b));
+    });
+  });
+
+  describe('div', function () {
+    it('divides correctly', async function () {
+      const a = new BigNumber(-5678);
+      const b = new BigNumber(5678);
+
+      const result = await this.safeMath.div(a, b);
+      result.should.be.bignumber.equal(a.div(b));
+    });
+
+    it('reverts on zero division', async function () {
+      const a = new BigNumber(-5678);
+      const b = new BigNumber(0);
+
+      await shouldFail.reverting(this.safeMath.div(a, b));
+    });
+
+    it('reverts on overflow, negative second', async function () {
+      const a = new BigNumber(MIN_INT256);
+      const b = new BigNumber(-1);
+
+      await shouldFail.reverting(this.safeMath.div(a, b));
+    });
+  });
+});