mirror
/
remix-project
mirror of https://github.com/ethereum/remix-project.git
2
0
Fork 0
Code Issues Releases Wiki Activity

return assert emthod for failed tests

Browse Source
pull/61/head
aniket-engg 5 years ago committed by Aniket
parent 1348017821
commit e9faef98bc
5 changed files with 69 additions and 58 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. 53
      libs/remix-tests/sol/tests.sol.ts
  2. 18
      libs/remix-tests/src/assertionEvents.ts
  3. 11
      libs/remix-tests/src/testRunner.ts
  4. 1
      libs/remix-tests/src/types.ts
  5. 44
      libs/remix-tests/tests/testRunner.spec.ts

53
libs/remix-tests/sol/tests.sol.ts
Unescape View File

@ -5,12 +5,14 @@ library Assert {
event AssertionEvent(
bool passed,
string message
string message,
string methodName
);
event AssertionEventUint(
bool passed,
string message,
string methodName,
uint256 returned,
uint256 expected
);
@ -18,6 +20,7 @@ library Assert {
event AssertionEventInt(
bool passed,
string message,
string methodName,
int256 returned,
int256 expected
);
@ -25,6 +28,7 @@ library Assert {
event AssertionEventBool(
bool passed,
string message,
string methodName,
bool returned,
bool expected
);
@ -32,6 +36,7 @@ library Assert {
event AssertionEventAddress(
bool passed,
string message,
string methodName,
address returned,
address expected
);
@ -39,6 +44,7 @@ library Assert {
event AssertionEventBytes32(
bool passed,
string message,
string methodName,
bytes32 returned,
bytes32 expected
);
@ -46,6 +52,7 @@ library Assert {
event AssertionEventString(
bool passed,
string message,
string methodName,
string returned,
string expected
);
@ -53,6 +60,7 @@ library Assert {
event AssertionEventUintInt(
bool passed,
string message,
string methodName,
uint256 returned,
int256 expected
);
@ -60,28 +68,29 @@ library Assert {
event AssertionEventIntUint(
bool passed,
string message,
string methodName,
int256 returned,
uint256 expected
);
function ok(bool a, string memory message) public returns (bool result) {
result = a;
emit AssertionEvent(result, message);
emit AssertionEvent(result, message, "ok");
}
function equal(uint256 a, uint256 b, string memory message) public returns (bool result) {
result = (a == b);
emit AssertionEventUint(result, message, a, b);
emit AssertionEventUint(result, message, "equal", a, b);
}
function equal(int256 a, int256 b, string memory message) public returns (bool result) {
result = (a == b);
emit AssertionEventInt(result, message, a, b);
emit AssertionEventInt(result, message, "equal", a, b);
}
function equal(bool a, bool b, string memory message) public returns (bool result) {
result = (a == b);
emit AssertionEventBool(result, message, a, b);
emit AssertionEventBool(result, message, "equal", a, b);
}
// TODO: only for certain versions of solc
@ -98,32 +107,32 @@ library Assert {
function equal(address a, address b, string memory message) public returns (bool result) {
result = (a == b);
emit AssertionEventAddress(result, message, a, b);
emit AssertionEventAddress(result, message, "equal", a, b);
}
function equal(bytes32 a, bytes32 b, string memory message) public returns (bool result) {
result = (a == b);
emit AssertionEventBytes32(result, message, a, b);
emit AssertionEventBytes32(result, message, "equal", a, b);
}
function equal(string memory a, string memory b, string memory message) public returns (bool result) {
result = (keccak256(abi.encodePacked(a)) == keccak256(abi.encodePacked(b)));
emit AssertionEventString(result, message, a, b);
emit AssertionEventString(result, message, "equal", a, b);
}
function notEqual(uint256 a, uint256 b, string memory message) public returns (bool result) {
result = (a != b);
emit AssertionEventUint(result, message, a, b);
emit AssertionEventUint(result, message, "notEqual", a, b);
}
function notEqual(int256 a, int256 b, string memory message) public returns (bool result) {
result = (a != b);
emit AssertionEventInt(result, message, a, b);
emit AssertionEventInt(result, message, "notEqual", a, b);
}
function notEqual(bool a, bool b, string memory message) public returns (bool result) {
result = (a != b);
emit AssertionEventBool(result, message, a, b);
emit AssertionEventBool(result, message, "notEqual", a, b);
}
// TODO: only for certain versions of solc
@ -140,28 +149,28 @@ library Assert {
function notEqual(address a, address b, string memory message) public returns (bool result) {
result = (a != b);
emit AssertionEventAddress(result, message, a, b);
emit AssertionEventAddress(result, message, "notEqual", a, b);
}
function notEqual(bytes32 a, bytes32 b, string memory message) public returns (bool result) {
result = (a != b);
emit AssertionEventBytes32(result, message, a, b);
emit AssertionEventBytes32(result, message, "notEqual", a, b);
}
function notEqual(string memory a, string memory b, string memory message) public returns (bool result) {
result = (keccak256(abi.encodePacked(a)) != keccak256(abi.encodePacked(b)));
emit AssertionEventString(result, message, a, b);
emit AssertionEventString(result, message, "notEqual", a, b);
}
/*----------------- Greater than --------------------*/
function greaterThan(uint256 a, uint256 b, string memory message) public returns (bool result) {
result = (a > b);
emit AssertionEventUint(result, message, a, b);
emit AssertionEventUint(result, message, "greaterThan", a, b);
}
function greaterThan(int256 a, int256 b, string memory message) public returns (bool result) {
result = (a > b);
emit AssertionEventInt(result, message, a, b);
emit AssertionEventInt(result, message, "greaterThan", a, b);
}
// TODO: safely compare between uint and int
function greaterThan(uint256 a, int256 b, string memory message) public returns (bool result) {
@ -171,7 +180,7 @@ library Assert {
} else {
result = (a > uint(b));
}
emit AssertionEventUintInt(result, message, a, b);
emit AssertionEventUintInt(result, message, "greaterThan", a, b);
}
function greaterThan(int256 a, uint256 b, string memory message) public returns (bool result) {
if(a < int(0)) {
@ -180,17 +189,17 @@ library Assert {
} else {
result = (uint(a) > b);
}
emit AssertionEventIntUint(result, message, a, b);
emit AssertionEventIntUint(result, message, "greaterThan", a, b);
}
/*----------------- Lesser than --------------------*/
function lesserThan(uint256 a, uint256 b, string memory message) public returns (bool result) {
result = (a < b);
emit AssertionEventUint(result, message, a, b);
emit AssertionEventUint(result, message, "lesserThan", a, b);
}
function lesserThan(int256 a, int256 b, string memory message) public returns (bool result) {
result = (a < b);
emit AssertionEventInt(result, message, a, b);
emit AssertionEventInt(result, message, "lesserThan", a, b);
}
// TODO: safely compare between uint and int
function lesserThan(uint256 a, int256 b, string memory message) public returns (bool result) {
@ -200,7 +209,7 @@ library Assert {
} else {
result = (a < uint(b));
}
emit AssertionEventUintInt(result, message, a, b);
emit AssertionEventUintInt(result, message, "lesserThan", a, b);
}
function lesserThan(int256 a, uint256 b, string memory message) public returns (bool result) {
@ -210,7 +219,7 @@ library Assert {
} else {
result = (uint(a) < b);
}
emit AssertionEventIntUint(result, message, a, b);
emit AssertionEventIntUint(result, message, "lesserThan", a, b);
}
}
`

18
libs/remix-tests/src/assertionEvents.ts
Unescape View File

@ -1,39 +1,39 @@
const assertionEvents = [
{
name: 'AssertionEvent',
params: ['bool', 'string']
params: ['bool', 'string', 'string']
},
{
name: 'AssertionEventUint',
params: ['bool', 'string', 'uint256', 'uint256']
params: ['bool', 'string', 'string', 'uint256', 'uint256']
},
{
name: 'AssertionEventInt',
params: ['bool', 'string', 'int256', 'int256']
params: ['bool', 'string', 'string', 'int256', 'int256']
},
{
name: 'AssertionEventBool',
params: ['bool', 'string', 'bool', 'bool']
params: ['bool', 'string', 'string', 'bool', 'bool']
},
{
name: 'AssertionEventAddress',
params: ['bool', 'string', 'address', 'address']
params: ['bool', 'string', 'string', 'address', 'address']
},
{
name: 'AssertionEventBytes32',
params: ['bool', 'string', 'bytes32', 'bytes32']
params: ['bool', 'string', 'string', 'bytes32', 'bytes32']
},
{
name: 'AssertionEventString',
params: ['bool', 'string', 'string', 'string']
params: ['bool', 'string', 'string', 'string', 'string']
},
{
name: 'AssertionEventUintInt',
params: ['bool', 'string', 'uint256', 'int256']
params: ['bool', 'string', 'string', 'uint256', 'int256']
},
{
name: 'AssertionEventIntUint',
params: ['bool', 'string', 'int256', 'uint256']
params: ['bool', 'string', 'string', 'int256', 'uint256']
}
]

11
libs/remix-tests/src/testRunner.ts
Unescape View File

@ -237,9 +237,9 @@ export function runTest (testName: string, testObject: any, contractDetails: Com
if (eIndex >= 0) {
const testEvent = web3.eth.abi.decodeParameters(assertionEvents[eIndex].params, event.raw.data)
if (!testEvent[0]) {
if(eIndex === 0) { // for 'Assert.ok' method
testEvent[2] = 'false'
testEvent[3] = 'true'
if(testEvent[2] === 'ok') { // for 'Assert.ok' method
testEvent[3] = 'false'
testEvent[4] = 'true'
}
const resp: TestResultInterface = {
type: 'testFailure',
@ -247,8 +247,9 @@ export function runTest (testName: string, testObject: any, contractDetails: Com
time: time,
errMsg: testEvent[1],
context: testName,
returned: testEvent[2],
expected: testEvent[3]
assertMethod: testEvent[2],
returned: testEvent[3],
expected: testEvent[4]
};
testCallback(undefined, resp)
failureNum += 1

1
libs/remix-tests/src/types.ts
Unescape View File

@ -32,6 +32,7 @@ export interface TestResultInterface {
context?: string
errMsg?: string
filename?: string
assertMethod?: string
returned?: string | number
expected?: string | number
}

44
libs/remix-tests/tests/testRunner.spec.ts
Unescape View File

@ -126,7 +126,7 @@ describe('testRunner', () => {
{ type: 'accountList', value: accounts },
{ type: 'contract', value: 'AssertOkTest', filename: __dirname + '/examples_0/assert_ok_test.sol' },
{ type: 'testPass', value: 'Ok pass test', context: 'AssertOkTest' },
{ type: 'testFailure', value: 'Ok fail test', errMsg: 'okFailTest fails', context: 'AssertOkTest', expected: 'true', returned: 'false'},
{ type: 'testFailure', value: 'Ok fail test', errMsg: 'okFailTest fails', context: 'AssertOkTest', assertMethod: 'ok', expected: 'true', returned: 'false'},
], ['time'])
})
@ -156,17 +156,17 @@ describe('testRunner', () => {
{ type: 'accountList', value: accounts },
{ type: 'contract', value: 'AssertEqualTest', filename: __dirname + '/examples_0/assert_equal_test.sol' },
{ type: 'testPass', value: 'Equal uint pass test', context: 'AssertEqualTest' },
{ type: 'testFailure', value: 'Equal uint fail test', errMsg: 'equalUintFailTest fails', context: 'AssertEqualTest', expected: '2', returned: '1'},
{ type: 'testFailure', value: 'Equal uint fail test', errMsg: 'equalUintFailTest fails', context: 'AssertEqualTest', assertMethod: 'equal', expected: '2', returned: '1'},
{ type: 'testPass', value: 'Equal int pass test', context: 'AssertEqualTest' },
{ type: 'testFailure', value: 'Equal int fail test', errMsg: 'equalIntFailTest fails', context: 'AssertEqualTest', expected: '2', returned: '-1'},
{ type: 'testFailure', value: 'Equal int fail test', errMsg: 'equalIntFailTest fails', context: 'AssertEqualTest', assertMethod: 'equal', expected: '2', returned: '-1'},
{ type: 'testPass', value: 'Equal bool pass test', context: 'AssertEqualTest' },
{ type: 'testFailure', value: 'Equal bool fail test', errMsg: 'equalBoolFailTest fails', context: 'AssertEqualTest', expected: false, returned: true},
{ type: 'testFailure', value: 'Equal bool fail test', errMsg: 'equalBoolFailTest fails', context: 'AssertEqualTest', assertMethod: 'equal', expected: false, returned: true},
{ type: 'testPass', value: 'Equal address pass test', context: 'AssertEqualTest' },
{ type: 'testFailure', value: 'Equal address fail test', errMsg: 'equalAddressFailTest fails', context: 'AssertEqualTest', expected: '0x1c6637567229159d1eFD45f95A6675e77727E013', returned: '0x7994f14563F39875a2F934Ce42cAbF48a93FdDA9'},
{ type: 'testFailure', value: 'Equal address fail test', errMsg: 'equalAddressFailTest fails', context: 'AssertEqualTest', assertMethod: 'equal', expected: '0x1c6637567229159d1eFD45f95A6675e77727E013', returned: '0x7994f14563F39875a2F934Ce42cAbF48a93FdDA9'},
{ type: 'testPass', value: 'Equal bytes32 pass test', context: 'AssertEqualTest' },
{ type: 'testFailure', value: 'Equal bytes32 fail test', errMsg: 'equalBytes32FailTest fails', context: 'AssertEqualTest', expected: '0x72656d6978000000000000000000000000000000000000000000000000000000', returned: '0x72656d6979000000000000000000000000000000000000000000000000000000'},
{ type: 'testFailure', value: 'Equal bytes32 fail test', errMsg: 'equalBytes32FailTest fails', context: 'AssertEqualTest', assertMethod: 'equal', expected: '0x72656d6978000000000000000000000000000000000000000000000000000000', returned: '0x72656d6979000000000000000000000000000000000000000000000000000000'},
{ type: 'testPass', value: 'Equal string pass test', context: 'AssertEqualTest' },
{ type: 'testFailure', value: 'Equal string fail test', errMsg: 'equalStringFailTest fails', context: 'AssertEqualTest', expected: 'remix-tests', returned: 'remix'}
{ type: 'testFailure', value: 'Equal string fail test', errMsg: 'equalStringFailTest fails', context: 'AssertEqualTest', assertMethod: 'equal', expected: 'remix-tests', returned: 'remix'}
], ['time'])
})
})
@ -195,17 +195,17 @@ describe('testRunner', () => {
{ type: 'accountList', value: accounts },
{ type: 'contract', value: 'AssertNotEqualTest', filename: __dirname + '/examples_0/assert_notEqual_test.sol' },
{ type: 'testPass', value: 'Not equal uint pass test', context: 'AssertNotEqualTest' },
{ type: 'testFailure', value: 'Not equal uint fail test', errMsg: 'notEqualUintFailTest fails', context: 'AssertNotEqualTest', expected: '1', returned: '1'},
{ type: 'testFailure', value: 'Not equal uint fail test', errMsg: 'notEqualUintFailTest fails', context: 'AssertNotEqualTest', assertMethod: 'notEqual', expected: '1', returned: '1'},
{ type: 'testPass', value: 'Not equal int pass test', context: 'AssertNotEqualTest' },
{ type: 'testFailure', value: 'Not equal int fail test', errMsg: 'notEqualIntFailTest fails', context: 'AssertNotEqualTest', expected: '-2', returned: '-2'},
{ type: 'testFailure', value: 'Not equal int fail test', errMsg: 'notEqualIntFailTest fails', context: 'AssertNotEqualTest', assertMethod: 'notEqual', expected: '-2', returned: '-2'},
{ type: 'testPass', value: 'Not equal bool pass test', context: 'AssertNotEqualTest' },
{ type: 'testFailure', value: 'Not equal bool fail test', errMsg: 'notEqualBoolFailTest fails', context: 'AssertNotEqualTest', expected: true, returned: true},
{ type: 'testFailure', value: 'Not equal bool fail test', errMsg: 'notEqualBoolFailTest fails', context: 'AssertNotEqualTest', assertMethod: 'notEqual', expected: true, returned: true},
{ type: 'testPass', value: 'Not equal address pass test', context: 'AssertNotEqualTest' },
{ type: 'testFailure', value: 'Not equal address fail test', errMsg: 'notEqualAddressFailTest fails', context: 'AssertNotEqualTest', expected: 0x7994f14563F39875a2F934Ce42cAbF48a93FdDA9, returned: 0x7994f14563F39875a2F934Ce42cAbF48a93FdDA9},
{ type: 'testFailure', value: 'Not equal address fail test', errMsg: 'notEqualAddressFailTest fails', context: 'AssertNotEqualTest', assertMethod: 'notEqual', expected: 0x7994f14563F39875a2F934Ce42cAbF48a93FdDA9, returned: 0x7994f14563F39875a2F934Ce42cAbF48a93FdDA9},
{ type: 'testPass', value: 'Not equal bytes32 pass test', context: 'AssertNotEqualTest' },
{ type: 'testFailure', value: 'Not equal bytes32 fail test', errMsg: 'notEqualBytes32FailTest fails', context: 'AssertNotEqualTest', expected: '0x72656d6978000000000000000000000000000000000000000000000000000000', returned: '0x72656d6978000000000000000000000000000000000000000000000000000000'},
{ type: 'testFailure', value: 'Not equal bytes32 fail test', errMsg: 'notEqualBytes32FailTest fails', context: 'AssertNotEqualTest', assertMethod: 'notEqual', expected: '0x72656d6978000000000000000000000000000000000000000000000000000000', returned: '0x72656d6978000000000000000000000000000000000000000000000000000000'},
{ type: 'testPass', value: 'Not equal string pass test', context: 'AssertNotEqualTest' },
{ type: 'testFailure', value: 'Not equal string fail test', errMsg: 'notEqualStringFailTest fails', context: 'AssertNotEqualTest', expected: 'remix', returned: 'remix'},
{ type: 'testFailure', value: 'Not equal string fail test', errMsg: 'notEqualStringFailTest fails', context: 'AssertNotEqualTest', assertMethod: 'notEqual', expected: 'remix', returned: 'remix'},
], ['time'])
})
})
@ -233,13 +233,13 @@ describe('testRunner', () => {
{ type: 'accountList', value: accounts },
{ type: 'contract', value: 'AssertGreaterThanTest', filename: __dirname + '/examples_0/assert_greaterThan_test.sol' },
{ type: 'testPass', value: 'Greater than uint pass test', context: 'AssertGreaterThanTest' },
{ type: 'testFailure', value: 'Greater than uint fail test', errMsg: 'greaterThanUintFailTest fails', context: 'AssertGreaterThanTest', expected: '4', returned: '1'},
{ type: 'testFailure', value: 'Greater than uint fail test', errMsg: 'greaterThanUintFailTest fails', context: 'AssertGreaterThanTest', assertMethod: 'greaterThan', expected: '4', returned: '1'},
{ type: 'testPass', value: 'Greater than int pass test', context: 'AssertGreaterThanTest' },
{ type: 'testFailure', value: 'Greater than int fail test', errMsg: 'greaterThanIntFailTest fails', context: 'AssertGreaterThanTest', expected: '1', returned: '-1'},
{ type: 'testFailure', value: 'Greater than int fail test', errMsg: 'greaterThanIntFailTest fails', context: 'AssertGreaterThanTest', assertMethod: 'greaterThan', expected: '1', returned: '-1'},
{ type: 'testPass', value: 'Greater than uint int pass test', context: 'AssertGreaterThanTest' },
{ type: 'testFailure', value: 'Greater than uint int fail test', errMsg: 'greaterThanUintIntFailTest fails', context: 'AssertGreaterThanTest', expected: '2', returned: '1'},
{ type: 'testFailure', value: 'Greater than uint int fail test', errMsg: 'greaterThanUintIntFailTest fails', context: 'AssertGreaterThanTest', assertMethod: 'greaterThan', expected: '2', returned: '1'},
{ type: 'testPass', value: 'Greater than int uint pass test', context: 'AssertGreaterThanTest' },
{ type: 'testFailure', value: 'Greater than int uint fail test', errMsg: 'greaterThanIntUintFailTest fails', context: 'AssertGreaterThanTest', expected: '115792089237316195423570985008687907853269984665640564039457584007913129639836', returned: '100'}
{ type: 'testFailure', value: 'Greater than int uint fail test', errMsg: 'greaterThanIntUintFailTest fails', context: 'AssertGreaterThanTest', assertMethod: 'greaterThan', expected: '115792089237316195423570985008687907853269984665640564039457584007913129639836', returned: '100'}
], ['time'])
})
})
@ -268,13 +268,13 @@ describe('testRunner', () => {
{ type: 'accountList', value: accounts },
{ type: 'contract', value: 'AssertLesserThanTest', filename: __dirname + '/examples_0/assert_lesserThan_test.sol' },
{ type: 'testPass', value: 'Lesser than uint pass test', context: 'AssertLesserThanTest' },
{ type: 'testFailure', value: 'Lesser than uint fail test', errMsg: 'lesserThanUintFailTest fails', context: 'AssertLesserThanTest', expected: '2', returned: '4'},
{ type: 'testFailure', value: 'Lesser than uint fail test', errMsg: 'lesserThanUintFailTest fails', context: 'AssertLesserThanTest', assertMethod: 'lesserThan', expected: '2', returned: '4'},
{ type: 'testPass', value: 'Lesser than int pass test', context: 'AssertLesserThanTest' },
{ type: 'testFailure', value: 'Lesser than int fail test', errMsg: 'lesserThanIntFailTest fails', context: 'AssertLesserThanTest', expected: '-1', returned: '1'},
{ type: 'testFailure', value: 'Lesser than int fail test', errMsg: 'lesserThanIntFailTest fails', context: 'AssertLesserThanTest', assertMethod: 'lesserThan', expected: '-1', returned: '1'},
{ type: 'testPass', value: 'Lesser than uint int pass test', context: 'AssertLesserThanTest' },
{ type: 'testFailure', value: 'Lesser than uint int fail test', errMsg: 'lesserThanUintIntFailTest fails', context: 'AssertLesserThanTest', expected: '-1', returned: '115792089237316195423570985008687907853269984665640564039457584007913129639935'},
{ type: 'testFailure', value: 'Lesser than uint int fail test', errMsg: 'lesserThanUintIntFailTest fails', context: 'AssertLesserThanTest', assertMethod: 'lesserThan', expected: '-1', returned: '115792089237316195423570985008687907853269984665640564039457584007913129639935'},
{ type: 'testPass', value: 'Lesser than int uint pass test', context: 'AssertLesserThanTest' },
{ type: 'testFailure', value: 'Lesser than int uint fail test', errMsg: 'lesserThanIntUintFailTest fails', context: 'AssertLesserThanTest', expected: '1', returned: '1'},
{ type: 'testFailure', value: 'Lesser than int uint fail test', errMsg: 'lesserThanIntUintFailTest fails', context: 'AssertLesserThanTest', assertMethod: 'lesserThan', expected: '1', returned: '1'},
], ['time'])
})
})
@ -304,7 +304,7 @@ describe('testRunner', () => {
{ type: 'contract', value: 'MyTest', filename: __dirname + '/examples_1/simple_storage_test.sol' },
{ type: 'testPass', value: 'Initial value should be100', context: 'MyTest' },
{ type: 'testPass', value: 'Initial value should not be200', context: 'MyTest' },
{ type: 'testFailure', value: 'Should trigger one fail', errMsg: 'uint test 1 fails', context: 'MyTest', expected: '2', returned: '1'},
{ type: 'testFailure', value: 'Should trigger one fail', errMsg: 'uint test 1 fails', context: 'MyTest', assertMethod: 'equal', expected: '2', returned: '1'},
{ type: 'testPass', value: 'Should trigger one pass', context: 'MyTest' }
], ['time'])
})

Write Preview
Loading…
Cancel
Save