You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
256 lines
7.6 KiB
256 lines
7.6 KiB
const assert = require('assert');
|
|
const util = require('./../util/util.js');
|
|
|
|
const client = require('ganache-cli');
|
|
const Coverage = require('./../../lib/coverage');
|
|
const Api = require('./../../lib/api')
|
|
|
|
describe('ternary conditionals', () => {
|
|
let coverage;
|
|
let api;
|
|
|
|
before(async () => {
|
|
api = new Api({silent: true});
|
|
await api.ganache(client);
|
|
})
|
|
beforeEach(() => coverage = new Coverage());
|
|
after(async() => await api.finish());
|
|
|
|
async function setupAndRun(solidityFile){
|
|
const contract = await util.bootstrapCoverage(solidityFile, api);
|
|
coverage.addContract(contract.instrumented, util.filePath);
|
|
await contract.instance.a();
|
|
return coverage.generate(contract.data, util.pathPrefix);
|
|
}
|
|
|
|
it('should cover a conditional that reaches the consequent (same-line)', async function() {
|
|
const mapping = await setupAndRun('conditional/sameline-consequent');
|
|
|
|
assert.deepEqual(mapping[util.filePath].l, {
|
|
5: 1, 6: 1, 7: 1,
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].b, {
|
|
1: [1, 0],
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].s, {
|
|
1: 1, 2: 1,
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].f, {
|
|
1: 1,
|
|
});
|
|
});
|
|
|
|
it('should cover an unbracketed conditional that reaches the consequent (same-line)', async function() {
|
|
const mapping = await setupAndRun('conditional/unbracketed-condition');
|
|
|
|
assert.deepEqual(mapping[util.filePath].l, {
|
|
5: 1, 6: 1, 7: 1,
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].b, {
|
|
1: [1, 0],
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].s, {
|
|
1: 1, 2: 1,
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].f, {
|
|
1: 1,
|
|
});
|
|
});
|
|
|
|
it('should cover a multi-part conditional (&&) that reaches the consequent', async function() {
|
|
const mapping = await setupAndRun('conditional/and-condition');
|
|
|
|
assert.deepEqual(mapping[util.filePath].l, {
|
|
5: 1, 6: 1, 7: 1,
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].b, {
|
|
1: [1, 0],
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].s, {
|
|
1: 1, 2: 1,
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].f, {
|
|
1: 1,
|
|
});
|
|
});
|
|
|
|
it('should cover a multi-part conditional (||) that reaches the consequent', async function() {
|
|
const mapping = await setupAndRun('conditional/or-condition');
|
|
|
|
assert.deepEqual(mapping[util.filePath].l, {
|
|
5: 1, 6: 1, 7: 1,
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].b, {
|
|
1: [0, 1], 2: [1, 0],
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].s, {
|
|
1: 1, 2: 1,
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].f, {
|
|
1: 1,
|
|
});
|
|
});
|
|
|
|
it('should cover a multi-part unbracketed conditional (||) that reaches the consequent', async function() {
|
|
const mapping = await setupAndRun('conditional/unbracketed-or-condition');
|
|
|
|
assert.deepEqual(mapping[util.filePath].l, {
|
|
5: 1, 6: 1, 7: 1,
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].b, {
|
|
1: [0, 1], 2: [1, 0],
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].s, {
|
|
1: 1, 2: 1,
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].f, {
|
|
1: 1,
|
|
});
|
|
});
|
|
|
|
it('should cover an always-false multi-part unbracketed conditional (||)', async function() {
|
|
const mapping = await setupAndRun('conditional/or-always-false-condition');
|
|
|
|
assert.deepEqual(mapping[util.filePath].l, {
|
|
5: 1, 6: 1, 7: 1,
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].b, {
|
|
1: [0, 0], 2: [0, 1],
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].s, {
|
|
1: 1, 2: 1,
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].f, {
|
|
1: 1,
|
|
});
|
|
});
|
|
|
|
it('should cover a conditional that reaches the alternate (same-line)', async function() {
|
|
const mapping = await setupAndRun('conditional/sameline-alternate');
|
|
|
|
assert.deepEqual(mapping[util.filePath].l, {
|
|
5: 1, 6: 1, 7: 1,
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].b, {
|
|
1: [0, 1],
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].s, {
|
|
1: 1, 2: 1,
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].f, {
|
|
1: 1,
|
|
});
|
|
});
|
|
|
|
it('should cover a conditional that reaches the consequent (multi-line)', async function() {
|
|
const mapping = await setupAndRun('conditional/multiline-consequent');
|
|
|
|
assert.deepEqual(mapping[util.filePath].l, {
|
|
5: 1, 6: 1, 7: 1,
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].b, {
|
|
1: [1, 0],
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].s, {
|
|
1: 1, 2: 1,
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].f, {
|
|
1: 1,
|
|
});
|
|
});
|
|
|
|
it('should cover a conditional that reaches the alternate (multi-line)', async function() {
|
|
const mapping = await setupAndRun('conditional/multiline-alternate');
|
|
|
|
assert.deepEqual(mapping[util.filePath].l, {
|
|
5: 1, 6: 1, 7: 1,
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].b, {
|
|
1: [0, 1],
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].s, {
|
|
1: 1, 2: 1,
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].f, {
|
|
1: 1,
|
|
});
|
|
});
|
|
|
|
// Runs bool z = (x) ? false : true;
|
|
it('should cover a definition assignment by conditional that reaches the alternate', async function() {
|
|
const mapping = await setupAndRun('conditional/declarative-exp-assignment-alternate');
|
|
|
|
assert.deepEqual(mapping[util.filePath].l, {
|
|
5: 1, 6: 1, 7: 1,
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].b, {
|
|
1: [0, 1],
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].s, {
|
|
1: 1, 2: 1, 3: 1,
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].f, {
|
|
1: 1,
|
|
});
|
|
});
|
|
|
|
// Runs z = (x) ? false : true;
|
|
it('should cover an identifier assignment by conditional that reaches the alternate', async function() {
|
|
const mapping = await setupAndRun('conditional/identifier-assignment-alternate');
|
|
|
|
assert.deepEqual(mapping[util.filePath].l, {
|
|
5: 1, 6: 1, 7: 1, 8: 1,
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].b, {
|
|
1: [0, 1],
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].s, {
|
|
1: 1, 2: 1, 3: 1,
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].f, {
|
|
1: 1,
|
|
});
|
|
});
|
|
|
|
it('should cover an assignment to a member expression (reaches the alternate)', async function() {
|
|
const mapping = await setupAndRun('conditional/mapping-assignment');
|
|
|
|
assert.deepEqual(mapping[util.filePath].l, {
|
|
11: 1, 12: 1,
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].b, {
|
|
1: [0, 1],
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].s, {
|
|
1: 1,
|
|
});
|
|
assert.deepEqual(mapping[util.filePath].f, {
|
|
1: 1,
|
|
});
|
|
});
|
|
|
|
it('should compile after instrumenting a ternary conditional which follows an unbracketed else', () => {
|
|
const info = util.instrumentAndCompile('conditional/ternary-with-unbracketed-else');
|
|
util.report(info.solcOutput.errors);
|
|
});
|
|
|
|
it('should compile after instrumenting a chain of ternary conditionals (single line)', () => {
|
|
const info = util.instrumentAndCompile('conditional/chained-singleline');
|
|
util.report(info.solcOutput.errors);
|
|
});
|
|
|
|
it('should compile after instrumenting a chain of ternary conditionals (multi-line)', () => {
|
|
const info = util.instrumentAndCompile('conditional/chained-multiline');
|
|
util.report(info.solcOutput.errors);
|
|
});
|
|
|
|
it('should compile after instrumenting a chain of ternary conditionals (parens)', () => {
|
|
const info = util.instrumentAndCompile('conditional/chained-with-parens');
|
|
util.report(info.solcOutput.errors);
|
|
});
|
|
|
|
it('should compile after instrumenting a chain of ternary conditionals (true expr is tern)', () => {
|
|
const info = util.instrumentAndCompile('conditional/chained-true');
|
|
util.report(info.solcOutput.errors);
|
|
});
|
|
});
|
|
|