Update assert tests

lib/coverage.js

@@ -2,6 +2,9 @@
  * Converts instrumentation data accumulated a the vm steps to an instanbul spec coverage object.
  * @type {Coverage}
  */
+
+const util = require('util');
+
 class Coverage {
 
   constructor() {
@@ -92,7 +95,7 @@ class Coverage {
     for (let contractPath of contractPaths){
       const contract = this.data[contractPath];
 
-      Object.keys(contract.b).forEach((item, i) => {
+      for (let i = 1; i <= Object.keys(contract.b).length; i++) {
         const branch = this.assertData[contractPath][i];
 
         // Was it an assert branch?
@@ -102,7 +105,7 @@ class Coverage {
             branch.preEvents - branch.postEvents
           ]
         }
-      })
+      }
     }
 
     return Object.assign({}, this.data);

test/units/assert.js

@@ -1,109 +1,101 @@
-/* eslint-env node, mocha */
-
-/*const path = require('path');
-const getInstrumentedVersion = require('./../lib/instrumentSolidity.js');
-const util = require('./util/util.js');
-const CoverageMap = require('./../lib/coverageMap');
-const vm = require('./util/vm');
 const assert = require('assert');
+const util = require('./../util/util.js');
+
+const ganache = require('ganache-core');
+const Coverage = require('./../../lib/coverage');
+const DataCollector = require('./../../lib/collector');
+const nodeUtil = require('util');
 
 describe('asserts and requires', () => {
-  const filePath = path.resolve('./test.sol');
+  let coverage;
-  const pathPrefix = './';
+  let provider;
+  let collector;
 
-  it('should cover assert statements as if they are if statements when they pass', done => {
+  before(async () => ({ provider, collector } = await util.initializeProvider(ganache)));
-    const contract = util.getCode('assert/Assert.sol');
+  beforeEach(() => coverage = new Coverage());
-    const info = getInstrumentedVersion(contract, filePath);
+  after((done) => provider.close(done));
-    const coverage = new CoverageMap();
-    coverage.addContract(info, filePath);
 
-    vm.execute(info.contract, 'a', [true]).then(events => {
+  it('should cover assert statements as `if` statements when they pass', async function() {
-      const mapping = coverage.generate(events, pathPrefix);
+    const contract = await util.bootstrapCoverage('assert/Assert', provider, collector);
-      assert.deepEqual(mapping[filePath].l, {
+    coverage.addContract(contract.instrumented, util.filePath);
-        5: 1,
+    await contract.instance.a(true);
-      });
+    const mapping = coverage.generate(contract.data, util.pathPrefix);
-      assert.deepEqual(mapping[filePath].b, {
+
-        1: [1, 0],
+    assert.deepEqual(mapping[util.filePath].l, {
-      });
+      5: 1,
-      assert.deepEqual(mapping[filePath].s, {
+    });
-        1: 1,
+    assert.deepEqual(mapping[util.filePath].b, {
-      });
+      1: [1, 0],
-      assert.deepEqual(mapping[filePath].f, {
+    });
-        1: 1,
+    assert.deepEqual(mapping[util.filePath].s, {
-      });
+      1: 1,
-      done();
+    });
-    }).catch(done);
+    assert.deepEqual(mapping[util.filePath].f, {
+      1: 1,
+    });
   });
 
-  it('should cover assert statements as if they are if statements when they fail', done => {
+  it('should cover assert statements as `if` statements when they fail', async function() {
-    const contract = util.getCode('assert/Assert.sol');
+    const contract = await util.bootstrapCoverage('assert/Assert', provider, collector);
-    const info = getInstrumentedVersion(contract, filePath);
+    coverage.addContract(contract.instrumented, util.filePath);
-    const coverage = new CoverageMap();
+
-    coverage.addContract(info, filePath);
+    try { await contract.instance.a(false) } catch(err) { /* Invalid opcode */ }
 
-    vm.execute(info.contract, 'a', [false]).then(events => {
+    const mapping = coverage.generate(contract.data, util.pathPrefix);
-      const mapping = coverage.generate(events, pathPrefix);
+
-      assert.deepEqual(mapping[filePath].l, {
+    assert.deepEqual(mapping[util.filePath].l, {
-        5: 1,
+      5: 1,
-      });
+    });
-      assert.deepEqual(mapping[filePath].b, {
+    assert.deepEqual(mapping[util.filePath].b, {
-        1: [0, 1],
+      1: [0, 1],
-      });
+    });
-      assert.deepEqual(mapping[filePath].s, {
+    assert.deepEqual(mapping[util.filePath].s, {
-        1: 1,
+      1: 1,
-      });
+    });
-      assert.deepEqual(mapping[filePath].f, {
+    assert.deepEqual(mapping[util.filePath].f, {
-        1: 1,
+      1: 1,
-      });
+    });
-      done();
-    }).catch(done);
   });
 
-  it('should cover multi-line require statements as if they are if statements when they pass', done => {
+  it('should cover multi-line require stmts as `if` statements when they pass', async function() {
-    const contract = util.getCode('assert/RequireMultiline.sol');
+    const contract = await util.bootstrapCoverage('assert/RequireMultiline', provider, collector);
-    const info = getInstrumentedVersion(contract, filePath);
+    coverage.addContract(contract.instrumented, util.filePath);
-    const coverage = new CoverageMap();
+    await contract.instance.a(true, true, true);
-    coverage.addContract(info, filePath);
+    const mapping = coverage.generate(contract.data, util.pathPrefix);
 
-    vm.execute(info.contract, 'a', [true, true, true]).then(events => {
+    assert.deepEqual(mapping[util.filePath].l, {
-      const mapping = coverage.generate(events, pathPrefix);
+      5: 1,
-      assert.deepEqual(mapping[filePath].l, {
+    });
-        5: 1,
+    assert.deepEqual(mapping[util.filePath].b, {
-      });
+      1: [1, 0],
-      assert.deepEqual(mapping[filePath].b, {
+    });
-        1: [1, 0],
+    assert.deepEqual(mapping[util.filePath].s, {
-      });
+      1: 1,
-      assert.deepEqual(mapping[filePath].s, {
+    });
-        1: 1,
+    assert.deepEqual(mapping[util.filePath].f, {
-      });
+      1: 1,
-      assert.deepEqual(mapping[filePath].f, {
+    });
-        1: 1,
-      });
-      done();
-    }).catch(done);
   });
 
-  it('should cover multi-line require statements as if they are if statements when they fail', done => {
+  it('should cover multi-line require stmts as `if` statements when they fail', async function() {
-    const contract = util.getCode('assert/RequireMultiline.sol');
+    const contract = await util.bootstrapCoverage('assert/RequireMultiline', provider, collector);
-    const info = getInstrumentedVersion(contract, filePath);
+    coverage.addContract(contract.instrumented, util.filePath);
-    const coverage = new CoverageMap();
+
-    coverage.addContract(info, filePath);
+    try { await contract.instance.a(true, true, false) } catch(err) { /* Revert */ }
+
+    const mapping = coverage.generate(contract.data, util.pathPrefix);
 
-    vm.execute(info.contract, 'a', [true, true, false]).then(events => {
+    assert.deepEqual(mapping[util.filePath].l, {
-      const mapping = coverage.generate(events, pathPrefix);
+      5: 1,
-      assert.deepEqual(mapping[filePath].l, {
+    });
-        5: 1,
+    assert.deepEqual(mapping[util.filePath].b, {
-      });
+      1: [0, 1],
-      assert.deepEqual(mapping[filePath].b, {
+    });
-        1: [0, 1],
+    assert.deepEqual(mapping[util.filePath].s, {
-      });
+      1: 1,
-      assert.deepEqual(mapping[filePath].s, {
+    });
-        1: 1,
+    assert.deepEqual(mapping[util.filePath].f, {
-      });
+      1: 1,
-      assert.deepEqual(mapping[filePath].f, {
+    });
-        1: 1,
-      });
-      done();
-    }).catch(done);
   });
-});*/
+});

test/units/if.js

@@ -5,7 +5,7 @@ const ganache = require('ganache-core');
 const Coverage = require('./../../lib/coverage');
 const DataCollector = require('./../../lib/collector');
 
-describe.only('if, else, and else if statements', () => {
+describe('if, else, and else if statements', () => {
   let coverage;
   let provider;
   let collector;