TheDude
/
solidity-coverage
mirror of https://github.com/sc-forks/solidity-coverage
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Update function & expression tests

Browse Source
truffle-plugin
cgewecke 5 years ago
parent 2cf6dd6d48
commit 40fbe927fd
2 changed files with 128 additions and 165 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 24
      test/units/expressions.js
  2. 269
      test/units/function.js

24
test/units/expressions.js
Unescape View File

@ -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);
});
});*/
});

269
test/units/function.js
Unescape View File

@ -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,
});
});
});
*/

Write Preview
Loading…
Cancel
Save