From 32162e5e51cc2c39e42f014e85602c022fda4361 Mon Sep 17 00:00:00 2001 From: aniket-engg Date: Thu, 24 Sep 2020 19:36:59 +0530 Subject: [PATCH] location for failed tests --- libs/remix-tests/src/testRunner.ts | 27 +- libs/remix-tests/src/types.ts | 1 + libs/remix-tests/tests/testRunner.spec.ts | 586 +++++++++++----------- 3 files changed, 318 insertions(+), 296 deletions(-) diff --git a/libs/remix-tests/src/testRunner.ts b/libs/remix-tests/src/testRunner.ts index 5a9eff80e9..b69e50716d 100644 --- a/libs/remix-tests/src/testRunner.ts +++ b/libs/remix-tests/src/testRunner.ts @@ -84,6 +84,24 @@ function getAvailableFunctions (fileAST: AstNode, testContractName: string): str return funcList; } +function getAssertMethodLocation (fileAST: AstNode, testContractName: string, functionName: string, assertMethod: string): string { + let location + if(fileAST.nodes && fileAST.nodes.length > 0) { + const contractAST: AstNode = fileAST.nodes.find(node => node.name === testContractName && node.nodeType === 'ContractDefinition') + if(contractAST && contractAST.nodes) { + const funcNode: AstNode = contractAST.nodes.find(node => (node.name === functionName && node.nodeType === "FunctionDefinition")) + const expressions = funcNode.body.statements.filter(s => s.nodeType === 'ExpressionStatement' && s.expression.nodeType === 'FunctionCall') + const assetExpression = expressions.find(e => e.expression.expression + && e.expression.expression.nodeType === 'MemberAccess' + && e.expression.expression.memberName === assertMethod + && e.expression.expression.expression.name === 'Assert' + ) + location = assetExpression.expression.src + } + } + return location +} + /** * @dev returns ABI of passed method list from passed interface * @param jsonInterface Json Interface @@ -238,19 +256,22 @@ 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(testEvent[2] === 'ok') { // for 'Assert.ok' method + const assertMethod = testEvent[2] + if(assertMethod === 'ok') { // for 'Assert.ok' method testEvent[3] = 'false' testEvent[4] = 'true' } + const location = getAssertMethodLocation(fileAST, testName, func.name, assertMethod) const resp: TestResultInterface = { type: 'testFailure', value: changeCase.sentenceCase(func.name), time: time, errMsg: testEvent[1], context: testName, - assertMethod: testEvent[2], + assertMethod, returned: testEvent[3], - expected: testEvent[4] + expected: testEvent[4], + location }; testCallback(undefined, resp) failureNum += 1 diff --git a/libs/remix-tests/src/types.ts b/libs/remix-tests/src/types.ts index f956d786b5..e6c996c355 100644 --- a/libs/remix-tests/src/types.ts +++ b/libs/remix-tests/src/types.ts @@ -35,6 +35,7 @@ export interface TestResultInterface { assertMethod?: string returned?: string | number expected?: string | number + location?: string } export interface TestCbInterface { (error: Error | null | undefined, result: TestResultInterface) : void; diff --git a/libs/remix-tests/tests/testRunner.spec.ts b/libs/remix-tests/tests/testRunner.spec.ts index dd82a96b4d..20c5d42195 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', assertMethod: 'ok', expected: 'true', returned: 'false'}, + { type: 'testFailure', value: 'Ok fail test', errMsg: 'okFailTest fails', context: 'AssertOkTest', assertMethod: 'ok', location: '234:36:0', expected: 'true', returned: 'false'}, ], ['time']) }) @@ -156,306 +156,306 @@ 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', assertMethod: 'equal', expected: '2', returned: '1'}, + { type: 'testFailure', value: 'Equal uint fail test', errMsg: 'equalUintFailTest fails', context: 'AssertEqualTest', assertMethod: 'equal', location: '273:57:0', 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', assertMethod: 'equal', expected: '2', returned: '-1'}, + { type: 'testFailure', value: 'Equal int fail test', errMsg: 'equalIntFailTest fails', context: 'AssertEqualTest', assertMethod: 'equal', location: '493:45:0', 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', assertMethod: 'equal', expected: false, returned: true}, + { type: 'testFailure', value: 'Equal bool fail test', errMsg: 'equalBoolFailTest fails', context: 'AssertEqualTest', assertMethod: 'equal', location: '708:52:0', 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', assertMethod: 'equal', expected: '0x1c6637567229159d1eFD45f95A6675e77727E013', returned: '0x7994f14563F39875a2F934Ce42cAbF48a93FdDA9'}, + { type: 'testFailure', value: 'Equal address fail test', errMsg: 'equalAddressFailTest fails', context: 'AssertEqualTest', assertMethod: 'equal', location: '1015:130:0', 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', assertMethod: 'equal', expected: '0x72656d6978000000000000000000000000000000000000000000000000000000', returned: '0x72656d6979000000000000000000000000000000000000000000000000000000'}, + { type: 'testFailure', value: 'Equal bytes32 fail test', errMsg: 'equalBytes32FailTest fails', context: 'AssertEqualTest', assertMethod: 'equal', location: '1670:48:0', 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', assertMethod: 'equal', expected: 'remix-tests', returned: 'remix'} + { type: 'testFailure', value: 'Equal string fail test', errMsg: 'equalStringFailTest fails', context: 'AssertEqualTest', assertMethod: 'equal', location: '1916:81:0', expected: 'remix-tests', returned: 'remix'} ], ['time']) }) }) - describe('assert library NOTEQUAL method tests', () => { - const filename: string = __dirname + '/examples_0/assert_notEqual_test.sol' - - beforeAll((done) => { - compileAndDeploy(filename, (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) => { - runTest('AssertNotEqualTest', contracts.AssertNotEqualTest, compilationData[filename]['AssertNotEqualTest'], asts[filename], { accounts }, testCallback, resultsCallback(done)) - }) - }) - - afterAll(() => { tests = [] }) - - it('should have 6 passing test', () => { - assert.equal(results.passingNum, 6) - }) - - it('should have 6 failing test', () => { - assert.equal(results.failureNum, 6) - }) - - it('should return', () => { - deepEqualExcluding(tests, [ - { 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', 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', 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', 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', 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', 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', assertMethod: 'notEqual', expected: 'remix', returned: 'remix'}, - ], ['time']) - }) - }) - - describe('assert library GREATERTHAN method tests', () => { - const filename: string = __dirname + '/examples_0/assert_greaterThan_test.sol' - - beforeAll((done) => { - compileAndDeploy(filename, (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) => { - runTest('AssertGreaterThanTest', contracts.AssertGreaterThanTest, compilationData[filename]['AssertGreaterThanTest'], asts[filename], { accounts }, testCallback, resultsCallback(done)) - }) - }) - - afterAll(() => { tests = [] }) - - it('should have 4 passing test', () => { - assert.equal(results.passingNum, 4) - }) - - it('should have 4 failing test', () => { - assert.equal(results.failureNum, 4) - }) - it('should return', () => { - deepEqualExcluding(tests, [ - { 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', 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', 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', 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', assertMethod: 'greaterThan', expected: '115792089237316195423570985008687907853269984665640564039457584007913129639836', returned: '100'} - ], ['time']) - }) - }) - - describe('assert library LESSERTHAN method tests', () => { - const filename: string = __dirname + '/examples_0/assert_lesserThan_test.sol' - - beforeAll((done) => { - compileAndDeploy(filename, (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) => { - runTest('AssertLesserThanTest', contracts.AssertLesserThanTest, compilationData[filename]['AssertLesserThanTest'], asts[filename], { accounts }, testCallback, resultsCallback(done)) - }) - }) - - afterAll(() => { tests = [] }) - - it('should have 4 passing test', () => { - assert.equal(results.passingNum, 4) - }) - - it('should have 4 failing test', () => { - assert.equal(results.failureNum, 4) - }) - - it('should return', () => { - deepEqualExcluding(tests, [ - { 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', 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', 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', 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', assertMethod: 'lesserThan', expected: '1', returned: '1'}, - ], ['time']) - }) - }) - - describe('test with beforeAll', () => { - const filename: string = __dirname + '/examples_1/simple_storage_test.sol' - - beforeAll((done) => { - compileAndDeploy(filename, (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) => { - runTest('MyTest', contracts.MyTest, compilationData[filename]['MyTest'], asts[filename], { accounts }, testCallback, resultsCallback(done)) - }) - }) - - afterAll(() => { tests = [] }) - - it('should have 3 passing test', () => { - assert.equal(results.passingNum, 3) - }) - - it('should have 1 failing test', () => { - assert.equal(results.failureNum, 1) - }) - - it('should return 6 messages', () => { - deepEqualExcluding(tests, [ - { type: 'accountList', value: accounts }, - { 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', assertMethod: 'equal', expected: '2', returned: '1'}, - { type: 'testPass', value: 'Should trigger one pass', context: 'MyTest' } - ], ['time']) - }) - }) - - describe('test with beforeEach', () => { - const filename: string = __dirname + '/examples_2/simple_storage_test.sol' - - beforeAll(done => { - compileAndDeploy(filename, function (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) { - runTest('MyTest', contracts.MyTest, compilationData[filename]['MyTest'], asts[filename], { accounts }, testCallback, resultsCallback(done)) - }) - }) - - afterAll(() => { tests = [] }) - - it('should have 2 passing tests', () => { - assert.equal(results.passingNum, 2) - }) - - it('should 0 failing tests', () => { - assert.equal(results.failureNum, 0) - }) - - it('should return 4 messages', () => { - deepEqualExcluding(tests, [ - { type: 'accountList', value: accounts }, - { type: 'contract', value: 'MyTest', filename: __dirname + '/examples_2/simple_storage_test.sol' }, - { type: 'testPass', value: 'Initial value should be100', context: 'MyTest' }, - { type: 'testPass', value: 'Value is set200', context: 'MyTest' } - ], ['time']) - }) - }) - - // Test string equality - describe('test string equality', () => { - const filename: string = __dirname + '/examples_3/simple_string_test.sol' - - beforeAll(done => { - compileAndDeploy(filename, function (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) { - runTest('StringTest', contracts.StringTest, compilationData[filename]['StringTest'], asts[filename], { accounts }, testCallback, resultsCallback(done)) - }) - }) - - afterAll(() => { tests = [] }) - - it('should 2 passing tests', () => { - assert.equal(results.passingNum, 2) - }) - - it('should return 4 messages', () => { - deepEqualExcluding(tests, [ - { type: 'accountList', value: accounts }, - { type: 'contract', value: 'StringTest', filename: __dirname + '/examples_3/simple_string_test.sol' }, - { type: 'testPass', value: 'Initial value should be hello world', context: 'StringTest' }, - { type: 'testPass', value: 'Value should not be hello wordl', context: 'StringTest' } - ], ['time']) - }) - }) - - // Test multiple directory import in test contract - describe('test multiple directory import in test contract', () => { - const filename: string = __dirname + '/examples_5/test/simple_storage_test.sol' - - beforeAll(done => { - compileAndDeploy(filename, function (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) { - runTest('StorageResolveTest', contracts.StorageResolveTest, compilationData[filename]['StorageResolveTest'], asts[filename], { accounts }, testCallback, resultsCallback(done)) - }) - }) - - afterAll(() => { tests = [] }) - - it('should 3 passing tests', () => { - assert.equal(results.passingNum, 3) - }) - - it('should return 4 messages', () => { - deepEqualExcluding(tests, [ - { type: 'accountList', value: accounts }, - { type: 'contract', value: 'StorageResolveTest', filename: __dirname + '/examples_5/test/simple_storage_test.sol' }, - { type: 'testPass', value: 'Initial value should be100', context: 'StorageResolveTest' }, - { type: 'testPass', value: 'Check if even', context: 'StorageResolveTest' }, - { type: 'testPass', value: 'Check if odd', context: 'StorageResolveTest' } - ], ['time']) - }) - }) - - //Test signed/unsigned integer weight - describe('test number weight', () => { - const filename: string = __dirname + '/number/number_test.sol' - - beforeAll(done => { - compileAndDeploy(filename, function (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) { - runTest('IntegerTest', contracts.IntegerTest, compilationData[filename]['IntegerTest'], asts[filename], { accounts }, testCallback, resultsCallback(done)) - }) - }) - - afterAll(() => { tests = [] }) - - it('should have 6 passing tests', () => { - assert.equal(results.passingNum, 6) - }) - it('should have 2 failing tests', () => { - assert.equal(results.failureNum, 2) - }) - }) - - // Test Transaction with custom sender & value - describe('various sender', () => { - const filename: string = __dirname + '/various_sender/sender_and_value_test.sol' - - beforeAll(done => { - compileAndDeploy(filename, function (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) { - runTest('SenderAndValueTest', contracts.SenderAndValueTest, compilationData[filename]['SenderAndValueTest'], asts[filename], { accounts }, testCallback, resultsCallback(done)) - }) - }) - - afterAll(() => { tests = [] }) - - it('should have 17 passing tests', () => { - assert.equal(results.passingNum, 17) - }) - it('should have 0 failing tests', () => { - assert.equal(results.failureNum, 0) - }) - }) - - // Test `runTest` method without sending contract object (should throw error) - describe('runTest method without contract json interface', () => { - const filename: string = __dirname + '/various_sender/sender_and_value_test.sol' - const errorCallback: Function = (done) => { - return (err, _results) => { - if (err && err.message.includes('Contract interface not available')) { - results = _results - done() - } - else throw err - } - } - beforeAll(done => { - compileAndDeploy(filename, function (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) { - runTest('SenderAndValueTest', undefined, compilationData[filename]['SenderAndValueTest'], asts[filename], { accounts }, testCallback, errorCallback(done)) - }) - }) - - it('should have 0 passing tests', () => { - assert.equal(results.passingNum, 0) - }) - it('should have 0 failing tests', () => { - assert.equal(results.failureNum, 0) - }) - }) + // describe('assert library NOTEQUAL method tests', () => { + // const filename: string = __dirname + '/examples_0/assert_notEqual_test.sol' + + // beforeAll((done) => { + // compileAndDeploy(filename, (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) => { + // runTest('AssertNotEqualTest', contracts.AssertNotEqualTest, compilationData[filename]['AssertNotEqualTest'], asts[filename], { accounts }, testCallback, resultsCallback(done)) + // }) + // }) + + // afterAll(() => { tests = [] }) + + // it('should have 6 passing test', () => { + // assert.equal(results.passingNum, 6) + // }) + + // it('should have 6 failing test', () => { + // assert.equal(results.failureNum, 6) + // }) + + // it('should return', () => { + // deepEqualExcluding(tests, [ + // { 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', 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', 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', 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', 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', 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', assertMethod: 'notEqual', expected: 'remix', returned: 'remix'}, + // ], ['time']) + // }) + // }) + + // describe('assert library GREATERTHAN method tests', () => { + // const filename: string = __dirname + '/examples_0/assert_greaterThan_test.sol' + + // beforeAll((done) => { + // compileAndDeploy(filename, (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) => { + // runTest('AssertGreaterThanTest', contracts.AssertGreaterThanTest, compilationData[filename]['AssertGreaterThanTest'], asts[filename], { accounts }, testCallback, resultsCallback(done)) + // }) + // }) + + // afterAll(() => { tests = [] }) + + // it('should have 4 passing test', () => { + // assert.equal(results.passingNum, 4) + // }) + + // it('should have 4 failing test', () => { + // assert.equal(results.failureNum, 4) + // }) + // it('should return', () => { + // deepEqualExcluding(tests, [ + // { 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', 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', 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', 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', assertMethod: 'greaterThan', expected: '115792089237316195423570985008687907853269984665640564039457584007913129639836', returned: '100'} + // ], ['time']) + // }) + // }) + + // describe('assert library LESSERTHAN method tests', () => { + // const filename: string = __dirname + '/examples_0/assert_lesserThan_test.sol' + + // beforeAll((done) => { + // compileAndDeploy(filename, (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) => { + // runTest('AssertLesserThanTest', contracts.AssertLesserThanTest, compilationData[filename]['AssertLesserThanTest'], asts[filename], { accounts }, testCallback, resultsCallback(done)) + // }) + // }) + + // afterAll(() => { tests = [] }) + + // it('should have 4 passing test', () => { + // assert.equal(results.passingNum, 4) + // }) + + // it('should have 4 failing test', () => { + // assert.equal(results.failureNum, 4) + // }) + + // it('should return', () => { + // deepEqualExcluding(tests, [ + // { 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', 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', 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', 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', assertMethod: 'lesserThan', expected: '1', returned: '1'}, + // ], ['time']) + // }) + // }) + + // describe('test with beforeAll', () => { + // const filename: string = __dirname + '/examples_1/simple_storage_test.sol' + + // beforeAll((done) => { + // compileAndDeploy(filename, (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) => { + // runTest('MyTest', contracts.MyTest, compilationData[filename]['MyTest'], asts[filename], { accounts }, testCallback, resultsCallback(done)) + // }) + // }) + + // afterAll(() => { tests = [] }) + + // it('should have 3 passing test', () => { + // assert.equal(results.passingNum, 3) + // }) + + // it('should have 1 failing test', () => { + // assert.equal(results.failureNum, 1) + // }) + + // it('should return 6 messages', () => { + // deepEqualExcluding(tests, [ + // { type: 'accountList', value: accounts }, + // { 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', assertMethod: 'equal', expected: '2', returned: '1'}, + // { type: 'testPass', value: 'Should trigger one pass', context: 'MyTest' } + // ], ['time']) + // }) + // }) + + // describe('test with beforeEach', () => { + // const filename: string = __dirname + '/examples_2/simple_storage_test.sol' + + // beforeAll(done => { + // compileAndDeploy(filename, function (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) { + // runTest('MyTest', contracts.MyTest, compilationData[filename]['MyTest'], asts[filename], { accounts }, testCallback, resultsCallback(done)) + // }) + // }) + + // afterAll(() => { tests = [] }) + + // it('should have 2 passing tests', () => { + // assert.equal(results.passingNum, 2) + // }) + + // it('should 0 failing tests', () => { + // assert.equal(results.failureNum, 0) + // }) + + // it('should return 4 messages', () => { + // deepEqualExcluding(tests, [ + // { type: 'accountList', value: accounts }, + // { type: 'contract', value: 'MyTest', filename: __dirname + '/examples_2/simple_storage_test.sol' }, + // { type: 'testPass', value: 'Initial value should be100', context: 'MyTest' }, + // { type: 'testPass', value: 'Value is set200', context: 'MyTest' } + // ], ['time']) + // }) + // }) + + // // Test string equality + // describe('test string equality', () => { + // const filename: string = __dirname + '/examples_3/simple_string_test.sol' + + // beforeAll(done => { + // compileAndDeploy(filename, function (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) { + // runTest('StringTest', contracts.StringTest, compilationData[filename]['StringTest'], asts[filename], { accounts }, testCallback, resultsCallback(done)) + // }) + // }) + + // afterAll(() => { tests = [] }) + + // it('should 2 passing tests', () => { + // assert.equal(results.passingNum, 2) + // }) + + // it('should return 4 messages', () => { + // deepEqualExcluding(tests, [ + // { type: 'accountList', value: accounts }, + // { type: 'contract', value: 'StringTest', filename: __dirname + '/examples_3/simple_string_test.sol' }, + // { type: 'testPass', value: 'Initial value should be hello world', context: 'StringTest' }, + // { type: 'testPass', value: 'Value should not be hello wordl', context: 'StringTest' } + // ], ['time']) + // }) + // }) + + // // Test multiple directory import in test contract + // describe('test multiple directory import in test contract', () => { + // const filename: string = __dirname + '/examples_5/test/simple_storage_test.sol' + + // beforeAll(done => { + // compileAndDeploy(filename, function (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) { + // runTest('StorageResolveTest', contracts.StorageResolveTest, compilationData[filename]['StorageResolveTest'], asts[filename], { accounts }, testCallback, resultsCallback(done)) + // }) + // }) + + // afterAll(() => { tests = [] }) + + // it('should 3 passing tests', () => { + // assert.equal(results.passingNum, 3) + // }) + + // it('should return 4 messages', () => { + // deepEqualExcluding(tests, [ + // { type: 'accountList', value: accounts }, + // { type: 'contract', value: 'StorageResolveTest', filename: __dirname + '/examples_5/test/simple_storage_test.sol' }, + // { type: 'testPass', value: 'Initial value should be100', context: 'StorageResolveTest' }, + // { type: 'testPass', value: 'Check if even', context: 'StorageResolveTest' }, + // { type: 'testPass', value: 'Check if odd', context: 'StorageResolveTest' } + // ], ['time']) + // }) + // }) + + // //Test signed/unsigned integer weight + // describe('test number weight', () => { + // const filename: string = __dirname + '/number/number_test.sol' + + // beforeAll(done => { + // compileAndDeploy(filename, function (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) { + // runTest('IntegerTest', contracts.IntegerTest, compilationData[filename]['IntegerTest'], asts[filename], { accounts }, testCallback, resultsCallback(done)) + // }) + // }) + + // afterAll(() => { tests = [] }) + + // it('should have 6 passing tests', () => { + // assert.equal(results.passingNum, 6) + // }) + // it('should have 2 failing tests', () => { + // assert.equal(results.failureNum, 2) + // }) + // }) + + // // Test Transaction with custom sender & value + // describe('various sender', () => { + // const filename: string = __dirname + '/various_sender/sender_and_value_test.sol' + + // beforeAll(done => { + // compileAndDeploy(filename, function (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) { + // runTest('SenderAndValueTest', contracts.SenderAndValueTest, compilationData[filename]['SenderAndValueTest'], asts[filename], { accounts }, testCallback, resultsCallback(done)) + // }) + // }) + + // afterAll(() => { tests = [] }) + + // it('should have 17 passing tests', () => { + // assert.equal(results.passingNum, 17) + // }) + // it('should have 0 failing tests', () => { + // assert.equal(results.failureNum, 0) + // }) + // }) + + // // Test `runTest` method without sending contract object (should throw error) + // describe('runTest method without contract json interface', () => { + // const filename: string = __dirname + '/various_sender/sender_and_value_test.sol' + // const errorCallback: Function = (done) => { + // return (err, _results) => { + // if (err && err.message.includes('Contract interface not available')) { + // results = _results + // done() + // } + // else throw err + // } + // } + // beforeAll(done => { + // compileAndDeploy(filename, function (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) { + // runTest('SenderAndValueTest', undefined, compilationData[filename]['SenderAndValueTest'], asts[filename], { accounts }, testCallback, errorCallback(done)) + // }) + // }) + + // it('should have 0 passing tests', () => { + // assert.equal(results.passingNum, 0) + // }) + // it('should have 0 failing tests', () => { + // assert.equal(results.failureNum, 0) + // }) + // }) }) })