Add combinatorial tests for internal Exchange functions (#807)

* WIP add combinatorial tests for internal Exchange functions

* Change combinitorial testing strategy based on feedback

* Check value of filled[orderHash] in updateFilledState tests

* Add combinatorial tests for addFillResults

* Add combinatorial tests for getPartialAmount

* Implement generic `testWithReferenceFuncAsync`

* Implement generic `testCombinatoriallyWithReferenceFuncAsync`

* Add combinatorial tests for isRoundingError

* Add combinatorial tests for calculateFillResults

* Add support for Geth in internal contract tests

* Fix contract artifacts

* Change DECIMAL_PLACES to 78 and add a note.

* Document new functions in utils

* Optimize tests by only reseting state when needed

* Rename/move some files

* Print parameter names on failure in testWithReferenceFuncAsync

* Add to changelog for utils package

* Appease various linters

* Rename some more things related to FillOrderCombinatorialUtils

* Remove .only from test/exchange/internal.ts

* Remove old test for isRoundingError and getPartialAmount

* Appease linters again

* Remove old todos

* Fix typos, add comments, rename some things

* Re-add some LibMath tests

* Update contract internal tests to use new SafeMath revert reasons

* Apply PR feedback from Amir

* Apply PR feedback from Remco

* Re-add networks to ZRXToken artifact

* Remove duplicate Whitelist in compiler.json

1 files changed, 29 insertions, 92 deletions

diff --git a/packages/contracts/test/exchange/libs.ts b/packages/contracts/test/exchange/libs.ts
index 51794d8a3..5c9f9aac7 100644
--- a/packages/contracts/test/exchange/libs.ts
+++ b/packages/contracts/test/exchange/libs.ts
@@ -67,6 +67,35 @@ describe('Exchange libs', () => {
             });
         });
     });
+    // Note(albrow): These tests are designed to be supplemental to the
+    // combinatorial tests in test/exchange/internal. They test specific edge
+    // cases that are not covered by the combinatorial tests.
+    describe('LibMath', () => {
+        it('should return false if there is a rounding error of 0.1%', async () => {
+            const numerator = new BigNumber(20);
+            const denominator = new BigNumber(999);
+            const target = new BigNumber(50);
+            // rounding error = ((20*50/999) - floor(20*50/999)) / (20*50/999) = 0.1%
+            const isRoundingError = await libs.publicIsRoundingError.callAsync(numerator, denominator, target);
+            expect(isRoundingError).to.be.false();
+        });
+        it('should return false if there is a rounding of 0.09%', async () => {
+            const numerator = new BigNumber(20);
+            const denominator = new BigNumber(9991);
+            const target = new BigNumber(500);
+            // rounding error = ((20*500/9991) - floor(20*500/9991)) / (20*500/9991) = 0.09%
+            const isRoundingError = await libs.publicIsRoundingError.callAsync(numerator, denominator, target);
+            expect(isRoundingError).to.be.false();
+        });
+        it('should return true if there is a rounding error of 0.11%', async () => {
+            const numerator = new BigNumber(20);
+            const denominator = new BigNumber(9989);
+            const target = new BigNumber(500);
+            // rounding error = ((20*500/9989) - floor(20*500/9989)) / (20*500/9989) = 0.011%
+            const isRoundingError = await libs.publicIsRoundingError.callAsync(numerator, denominator, target);
+            expect(isRoundingError).to.be.true();
+        });
+    });
 
     describe('LibOrder', () => {
         describe('getOrderSchema', () => {
@@ -93,96 +122,4 @@ describe('Exchange libs', () => {
             });
         });
     });
-
-    describe('LibMath', () => {
-        describe('isRoundingError', () => {
-            it('should return false if there is a rounding error of 0.1%', async () => {
-                const numerator = new BigNumber(20);
-                const denominator = new BigNumber(999);
-                const target = new BigNumber(50);
-                // rounding error = ((20*50/999) - floor(20*50/999)) / (20*50/999) = 0.1%
-                const isRoundingError = await libs.publicIsRoundingError.callAsync(numerator, denominator, target);
-                expect(isRoundingError).to.be.false();
-            });
-
-            it('should return false if there is a rounding of 0.09%', async () => {
-                const numerator = new BigNumber(20);
-                const denominator = new BigNumber(9991);
-                const target = new BigNumber(500);
-                // rounding error = ((20*500/9991) - floor(20*500/9991)) / (20*500/9991) = 0.09%
-                const isRoundingError = await libs.publicIsRoundingError.callAsync(numerator, denominator, target);
-                expect(isRoundingError).to.be.false();
-            });
-
-            it('should return true if there is a rounding error of 0.11%', async () => {
-                const numerator = new BigNumber(20);
-                const denominator = new BigNumber(9989);
-                const target = new BigNumber(500);
-                // rounding error = ((20*500/9989) - floor(20*500/9989)) / (20*500/9989) = 0.011%
-                const isRoundingError = await libs.publicIsRoundingError.callAsync(numerator, denominator, target);
-                expect(isRoundingError).to.be.true();
-            });
-
-            it('should return true if there is a rounding error > 0.1%', async () => {
-                const numerator = new BigNumber(3);
-                const denominator = new BigNumber(7);
-                const target = new BigNumber(10);
-                // rounding error = ((3*10/7) - floor(3*10/7)) / (3*10/7) = 6.67%
-                const isRoundingError = await libs.publicIsRoundingError.callAsync(numerator, denominator, target);
-                expect(isRoundingError).to.be.true();
-            });
-
-            it('should return false when there is no rounding error', async () => {
-                const numerator = new BigNumber(1);
-                const denominator = new BigNumber(2);
-                const target = new BigNumber(10);
-
-                const isRoundingError = await libs.publicIsRoundingError.callAsync(numerator, denominator, target);
-                expect(isRoundingError).to.be.false();
-            });
-
-            it('should return false when there is rounding error <= 0.1%', async () => {
-                // randomly generated numbers
-                const numerator = new BigNumber(76564);
-                const denominator = new BigNumber(676373677);
-                const target = new BigNumber(105762562);
-                // rounding error = ((76564*105762562/676373677) - floor(76564*105762562/676373677)) /
-                // (76564*105762562/676373677) = 0.0007%
-                const isRoundingError = await libs.publicIsRoundingError.callAsync(numerator, denominator, target);
-                expect(isRoundingError).to.be.false();
-            });
-        });
-
-        describe('getPartialAmount', () => {
-            it('should return the numerator/denominator*target', async () => {
-                const numerator = new BigNumber(1);
-                const denominator = new BigNumber(2);
-                const target = new BigNumber(10);
-
-                const partialAmount = await libs.publicGetPartialAmount.callAsync(numerator, denominator, target);
-                const expectedPartialAmount = 5;
-                expect(partialAmount).to.be.bignumber.equal(expectedPartialAmount);
-            });
-
-            it('should round down', async () => {
-                const numerator = new BigNumber(2);
-                const denominator = new BigNumber(3);
-                const target = new BigNumber(10);
-
-                const partialAmount = await libs.publicGetPartialAmount.callAsync(numerator, denominator, target);
-                const expectedPartialAmount = 6;
-                expect(partialAmount).to.be.bignumber.equal(expectedPartialAmount);
-            });
-
-            it('should round .5 down', async () => {
-                const numerator = new BigNumber(1);
-                const denominator = new BigNumber(20);
-                const target = new BigNumber(10);
-
-                const partialAmount = await libs.publicGetPartialAmount.callAsync(numerator, denominator, target);
-                const expectedPartialAmount = 0;
-                expect(partialAmount).to.be.bignumber.equal(expectedPartialAmount);
-            });
-        });
-    });
 });