diff --git a/libs/remix-tests/sol/tests.sol.ts b/libs/remix-tests/sol/tests.sol.ts index 407d399fbe..b745399b1a 100644 --- a/libs/remix-tests/sol/tests.sol.ts +++ b/libs/remix-tests/sol/tests.sol.ts @@ -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); } } ` diff --git a/libs/remix-tests/src/assertionEvents.ts b/libs/remix-tests/src/assertionEvents.ts index e6333c19e6..6f9627d9b0 100644 --- a/libs/remix-tests/src/assertionEvents.ts +++ b/libs/remix-tests/src/assertionEvents.ts @@ -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'] } ] diff --git a/libs/remix-tests/src/testRunner.ts b/libs/remix-tests/src/testRunner.ts index 74fe2c62fd..c923df4e2b 100644 --- a/libs/remix-tests/src/testRunner.ts +++ b/libs/remix-tests/src/testRunner.ts @@ -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 diff --git a/libs/remix-tests/src/types.ts b/libs/remix-tests/src/types.ts index b9b2748be2..f956d786b5 100644 --- a/libs/remix-tests/src/types.ts +++ b/libs/remix-tests/src/types.ts @@ -32,6 +32,7 @@ export interface TestResultInterface { context?: string errMsg?: string filename?: string + assertMethod?: string returned?: string | number expected?: string | number } diff --git a/libs/remix-tests/tests/testRunner.spec.ts b/libs/remix-tests/tests/testRunner.spec.ts index e6d878e1f0..dd82a96b4d 100644 --- a/libs/remix-tests/tests/testRunner.spec.ts +++ b/libs/remix-tests/tests/testRunner.spec.ts @@ -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']) })