location for failed tests

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

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;

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)
+    //   })
+    // })
   })
 })