From b1bea305ebea5f4322475a871005ea3a763efcdb Mon Sep 17 00:00:00 2001 From: cgewecke Date: Tue, 23 Jul 2019 17:33:28 -0700 Subject: [PATCH] Update function & expression tests --- test/units/expressions.js | 24 +--- test/units/function.js | 269 +++++++++++++++++--------------------- 2 files changed, 128 insertions(+), 165 deletions(-) diff --git a/test/units/expressions.js b/test/units/expressions.js index 8e24ec2..c6c8619 100644 --- a/test/units/expressions.js +++ b/test/units/expressions.js @@ -1,24 +1,14 @@ -/* eslint-env node, mocha */ - -/*const solc = require('solc'); -const getInstrumentedVersion = require('./../lib/instrumentSolidity.js'); -const util = require('./util/util.js'); -const path = require('path'); +const assert = require('assert'); +const util = require('./../util/util.js'); describe('generic expressions', () => { - const filePath = path.resolve('./test.sol'); - it('should compile after instrumenting a single binary expression', () => { - const contract = util.getCode('expressions/single-binary-expression.sol'); - const info = getInstrumentedVersion(contract, filePath); - const output = JSON.parse(solc.compile(util.codeToCompilerInput(info.contract))); - util.report(output.errors); + const info = util.instrumentAndCompile('expressions/single-binary-expression'); + util.report(info.solcOutput.errors); }); it('should compile after instrumenting a new expression', () => { - const contract = util.getCode('expressions/new-expression.sol'); - const info = getInstrumentedVersion(contract, filePath); - const output = JSON.parse(solc.compile(util.codeToCompilerInput(info.contract))); - util.report(output.errors); + const info = util.instrumentAndCompile('expressions/new-expression'); + util.report(info.solcOutput.errors); }); -});*/ +}); diff --git a/test/units/function.js b/test/units/function.js index fd3c3c2..c8b506f 100644 --- a/test/units/function.js +++ b/test/units/function.js @@ -1,186 +1,159 @@ -/*const solc = require('solc'); -const getInstrumentedVersion = require('./../lib/instrumentSolidity.js'); -const util = require('./util/util.js'); -const path = require('path'); -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'); describe('function declarations', () => { - const filePath = path.resolve('./test.sol'); - const pathPrefix = './'; + let coverage; + let provider; + let collector; + + before(async () => ({ provider, collector } = await util.initializeProvider(ganache))); + beforeEach(() => coverage = new Coverage()); + after((done) => provider.close(done)); it('should compile after instrumenting an ordinary function declaration', () => { - const contract = util.getCode('function/function.sol'); - const info = getInstrumentedVersion(contract, 'test.sol'); - const output = JSON.parse(solc.compile(util.codeToCompilerInput(info.contract))); - util.report(output.errors); + const info = util.instrumentAndCompile('function/function'); + util.report(info.solcOutput.errors); }); it('should compile after instrumenting an abstract function declaration', () => { - const contract = util.getCode('function/abstract.sol'); - const info = getInstrumentedVersion(contract, 'test.sol'); - const output = JSON.parse(solc.compile(util.codeToCompilerInput(info.contract))); - util.report(output.errors); + const info = util.instrumentAndCompile('function/abstract'); + util.report(info.solcOutput.errors); }); it('should compile after instrumenting a function declaration with an empty body', () => { - const contract = util.getCode('function/empty-body.sol'); - const info = getInstrumentedVersion(contract, 'test.sol'); - const output = JSON.parse(solc.compile(util.codeToCompilerInput(info.contract))); - util.report(output.errors); + const info = util.instrumentAndCompile('function/empty-body'); + util.report(info.solcOutput.errors); }); it('should compile after instrumenting lots of declarations in row', () => { - const contract = util.getCode('function/multiple.sol'); - const info = getInstrumentedVersion(contract, 'test.sol'); - const output = JSON.parse(solc.compile(util.codeToCompilerInput(info.contract))); - util.report(output.errors); + const info = util.instrumentAndCompile('function/multiple'); + util.report(info.solcOutput.errors); }); it('should compile after instrumenting a new->constructor-->method chain', () => { - const contract = util.getCode('function/chainable-new.sol'); - const info = getInstrumentedVersion(contract, 'test.sol'); - const output = JSON.parse(solc.compile(util.codeToCompilerInput(info.contract))); - util.report(output.errors); + const info = util.instrumentAndCompile('function/chainable-new'); + util.report(info.solcOutput.errors); }); it('should compile after instrumenting a constructor call that chains to a method call', () => { - const contract = util.getCode('function/chainable.sol'); - const info = getInstrumentedVersion(contract, 'test.sol'); - const output = JSON.parse(solc.compile(util.codeToCompilerInput(info.contract))); - util.report(output.errors); + const info = util.instrumentAndCompile('function/chainable'); + util.report(info.solcOutput.errors); }); it('should compile after instrumenting a function with calldata keyword', () => { - const contract = util.getCode('function/calldata.sol'); - const info = getInstrumentedVersion(contract, 'test.sol'); - const output = JSON.parse(solc.compile(util.codeToCompilerInput(info.contract))); - util.report(output.errors); + const info = util.instrumentAndCompile('function/calldata'); + util.report(info.solcOutput.errors); }); it('should compile after instrumenting a constructor-->method-->value chain', () => { - const contract = util.getCode('function/chainable-value.sol'); - const info = getInstrumentedVersion(contract, 'test.sol'); - const output = JSON.parse(solc.compile(util.codeToCompilerInput(info.contract))); - util.report(output.errors); + const info = util.instrumentAndCompile('function/chainable-value'); + util.report(info.solcOutput.errors); }); - it('should cover a simple invoked function call', done => { - const contract = util.getCode('function/function-call.sol'); - const info = getInstrumentedVersion(contract, filePath); - const coverage = new CoverageMap(); - coverage.addContract(info, filePath); - - vm.execute(info.contract, 'a', []).then(events => { - const mapping = coverage.generate(events, pathPrefix); - assert.deepEqual(mapping[filePath].l, { - 7: 1, - }); - assert.deepEqual(mapping[filePath].b, {}); - assert.deepEqual(mapping[filePath].s, { - 1: 1, - }); - assert.deepEqual(mapping[filePath].f, { - 1: 1, - 2: 1, - }); - done(); - }).catch(done); + it('should cover a simple invoked function call', async function() { + const contract = await util.bootstrapCoverage('function/function-call', provider, collector); + coverage.addContract(contract.instrumented, util.filePath); + await contract.instance.a(); + const mapping = coverage.generate(contract.data, util.pathPrefix); + + assert.deepEqual(mapping[util.filePath].l, { + 7: 1, + }); + assert.deepEqual(mapping[util.filePath].b, {}); + assert.deepEqual(mapping[util.filePath].s, { + 1: 1, + }); + assert.deepEqual(mapping[util.filePath].f, { + 1: 1, + 2: 1, + }); }); - it('should cover a modifier used on a function', done => { - const contract = util.getCode('function/modifier.sol'); - const info = getInstrumentedVersion(contract, filePath); - const coverage = new CoverageMap(); - coverage.addContract(info, filePath); - - vm.execute(info.contract, 'a', [0]).then(events => { - const mapping = coverage.generate(events, pathPrefix); - assert.deepEqual(mapping[filePath].l, { - 5: 1, 6: 1, 9: 1, - }); - assert.deepEqual(mapping[filePath].b, {}); - assert.deepEqual(mapping[filePath].s, { - 1: 1 - }); - assert.deepEqual(mapping[filePath].f, { - 1: 1, - 2: 1, - }); - done(); - }).catch(done); + it('should cover a modifier used on a function', async function() { + const contract = await util.bootstrapCoverage('function/modifier', provider, collector); + coverage.addContract(contract.instrumented, util.filePath); + await contract.instance.a(0); + const mapping = coverage.generate(contract.data, util.pathPrefix); + + assert.deepEqual(mapping[util.filePath].l, { + 5: 1, 6: 1, 9: 1, + }); + assert.deepEqual(mapping[util.filePath].b, {}); + assert.deepEqual(mapping[util.filePath].s, { + 1: 1 + }); + assert.deepEqual(mapping[util.filePath].f, { + 1: 1, + 2: 1, + }); }); - it('should cover a constructor that uses the `constructor` keyword', done => { - const contract = util.getCode('function/constructor-keyword.sol'); - const info = getInstrumentedVersion(contract, filePath); - const coverage = new CoverageMap(); - coverage.addContract(info, filePath); - - vm.execute(info.contract, 'a', []).then(events => { - const mapping = coverage.generate(events, pathPrefix); - assert.deepEqual(mapping[filePath].l, { - 6: 1, 11: 1 - }); - assert.deepEqual(mapping[filePath].b, {}); - assert.deepEqual(mapping[filePath].s, { - 1: 1, 2: 1 - }); - assert.deepEqual(mapping[filePath].f, { - 1: 1, - 2: 1, - }); - done(); - }).catch(done); + it('should cover a constructor that uses the `constructor` keyword', async function() { + const contract = await util.bootstrapCoverage('function/constructor-keyword', provider, collector); + coverage.addContract(contract.instrumented, util.filePath); + await contract.instance.a(); + const mapping = coverage.generate(contract.data, util.pathPrefix); + + assert.deepEqual(mapping[util.filePath].l, { + 6: 1, 11: 1 + }); + assert.deepEqual(mapping[util.filePath].b, {}); + assert.deepEqual(mapping[util.filePath].s, { + 1: 1, 2: 1 + }); + assert.deepEqual(mapping[util.filePath].f, { + 1: 1, + 2: 1, + }); }); - it('should cover a constructor call that chains to a method call', done => { - const contract = util.getCode('function/chainable.sol'); - const info = getInstrumentedVersion(contract, filePath); - const coverage = new CoverageMap(); - coverage.addContract(info, filePath); - // We try and call a contract at an address where it doesn't exist and the VM - // throws, but we can verify line / statement / fn coverage is getting mapped. - vm.execute(info.contract, 'a', []).then(events => { - const mapping = coverage.generate(events, pathPrefix); - assert.deepEqual(mapping[filePath].l, { - 9: 1, - }); - assert.deepEqual(mapping[filePath].b, {}); - assert.deepEqual(mapping[filePath].s, { - 1: 1, - }); - assert.deepEqual(mapping[filePath].f, { - 1: 0, - 2: 1, - }); - done(); - }).catch(done); + // We try and call a contract at an address where it doesn't exist and the VM + // throws, but we can verify line / statement / fn coverage is getting mapped. + it('should cover a constructor call that chains to a method call', async function() { + const contract = await util.bootstrapCoverage('function/chainable', provider, collector); + coverage.addContract(contract.instrumented, util.filePath); + + try { await contract.instance.a() } catch(err){} + + const mapping = coverage.generate(contract.data, util.pathPrefix); + + assert.deepEqual(mapping[util.filePath].l, { + 9: 1, + }); + assert.deepEqual(mapping[util.filePath].b, {}); + assert.deepEqual(mapping[util.filePath].s, { + 1: 1, + }); + assert.deepEqual(mapping[util.filePath].f, { + 1: 0, + 2: 1, + }); }); - it('should cover a constructor call that chains to a method call', done => { - const contract = util.getCode('function/chainable-value.sol'); - const info = getInstrumentedVersion(contract, filePath); - const coverage = new CoverageMap(); - coverage.addContract(info, filePath); - // The vm runs out of gas here - but we can verify line / statement / fn - // coverage is getting mapped. - vm.execute(info.contract, 'a', []).then(events => { - const mapping = coverage.generate(events, pathPrefix); - assert.deepEqual(mapping[filePath].l, { - 10: 1, - }); - assert.deepEqual(mapping[filePath].b, {}); - assert.deepEqual(mapping[filePath].s, { - 1: 1, - }); - assert.deepEqual(mapping[filePath].f, { - 1: 0, - 2: 1, - }); - done(); - }).catch(done); + // The vm runs out of gas here - but we can verify line / statement / fn + // coverage is getting mapped. + it('should cover a constructor call that chains to a method call', async function() { + const contract = await util.bootstrapCoverage('function/chainable-value', provider, collector); + coverage.addContract(contract.instrumented, util.filePath); + + try { await contract.instance.a() } catch(err){} + + const mapping = coverage.generate(contract.data, util.pathPrefix); + + assert.deepEqual(mapping[util.filePath].l, { + 10: 1, + }); + assert.deepEqual(mapping[util.filePath].b, {}); + assert.deepEqual(mapping[util.filePath].s, { + 1: 1, + }); + assert.deepEqual(mapping[util.filePath].f, { + 1: 0, + 2: 1, + }); }); }); -*/ +