Merge pull request #327 from jakub-wojciechowski/master

fix testing error throwing

test/BasicToken.js

@@ -26,10 +26,10 @@ contract('BasicToken', function(accounts) {
     let token = await BasicTokenMock.new(accounts[0], 100);
     try {
       let transfer = await token.transfer(accounts[1], 101);
+      assert.fail('should have thrown before');
     } catch(error) {
-      return assertJump(error);
-    }
-    assert.fail('should have thrown before');
+      assertJump(error);
+    }    
   });
 
 });

test/Claimable.js

@@ -25,9 +25,10 @@ contract('Claimable', function(accounts) {
 
   it('should prevent to claimOwnership from no pendingOwner', async function() {
     try {
-        await claimable.claimOwnership({from: accounts[2]});
+      await claimable.claimOwnership({from: accounts[2]});
+      assert.fail('should have thrown before');
     } catch(error) {
-        assertJump(error);
+      assertJump(error);
     }
   });
 
@@ -36,9 +37,10 @@ contract('Claimable', function(accounts) {
     const owner = await claimable.owner.call();
     assert.isTrue(owner !== other);
     try {
-        await claimable.transferOwnership(other, {from: other});
+      await claimable.transferOwnership(other, {from: other});
+      assert.fail('should have thrown before');
     } catch(error) {
-        assertJump(error);
+      assertJump(error);
     }
   });
 

test/DayLimit.js

@@ -35,9 +35,10 @@ contract('DayLimit', function(accounts) {
     assert.equal(spentToday, 8);
 
     try {
-        await dayLimit.attemptSpend(3);
+      await dayLimit.attemptSpend(3);
+      assert.fail('should have thrown before');
     } catch(error) {
-        assertJump(error);
+      assertJump(error);
     }
   });
 
@@ -47,9 +48,10 @@ contract('DayLimit', function(accounts) {
     assert.equal(spentToday, 8);
 
     try {
-        await dayLimit.attemptSpend(3);
+      await dayLimit.attemptSpend(3);
+      assert.fail('should have thrown before');
     } catch(error) {
-        assertJump(error);
+      assertJump(error);
     }
     spentToday = await dayLimit.spentToday();
     assert.equal(spentToday, 8);
@@ -66,9 +68,10 @@ contract('DayLimit', function(accounts) {
     assert.equal(spentToday, 8);
 
     try {
-        await dayLimit.attemptSpend(3);
+      await dayLimit.attemptSpend(3);
+      assert.fail('should have thrown before');
     } catch(error) {
-        assertJump(error);
+      assertJump(error);
     }
     spentToday = await dayLimit.spentToday();
     assert.equal(spentToday, 8);
@@ -89,6 +92,7 @@ contract('DayLimit', function(accounts) {
 
     try {
       await dayLimit.attemptSpend(3);
+      assert.fail('should have thrown before');
     } catch(error) {
       assertJump(error);
     }

test/LimitBalance.js

@@ -27,11 +27,11 @@ contract('LimitBalance', function(accounts) {
   it('shouldnt allow sending above limit', async function() {
     let amount = 1110;
     try {
-       await lb.limitedDeposit({value: amount});
+      await lb.limitedDeposit({value: amount});
+      assert.fail('should have thrown before');
     } catch(error) {
-      return assertJump(error);
-    }
-    assert.fail('should have thrown before');
+      assertJump(error);
+    }    
   });
 
   it('should allow multiple sends below limit', async function() {
@@ -52,10 +52,10 @@ contract('LimitBalance', function(accounts) {
 
     try {
       await lb.limitedDeposit({value: amount+1});
+      assert.fail('should have thrown before');
     } catch(error) {
-      return assertJump(error);
-    }
-    assert.fail('should have thrown before');
+      assertJump(error);
+    }    
   });
 
 });

test/Ownable.js

@@ -29,6 +29,7 @@ contract('Ownable', function(accounts) {
     assert.isTrue(owner !== other);
     try {
       await ownable.transferOwnership(other, {from: other});
+      assert.fail('should have thrown before');
     } catch(error) {
       assertJump(error);
     }

test/Pausable.js

@@ -23,6 +23,7 @@ contract('Pausable', function(accounts) {
 
     try {
       await Pausable.normalProcess();
+      assert.fail('should have thrown before');
     } catch(error) {
       assertJump(error);
     }
@@ -35,10 +36,10 @@ contract('Pausable', function(accounts) {
     let Pausable = await PausableMock.new();
     try {
       await Pausable.drasticMeasure();
+      assert.fail('should have thrown before');
     } catch(error) {
       assertJump(error);
     }
-
     const drasticMeasureTaken = await Pausable.drasticMeasureTaken();
     assert.isFalse(drasticMeasureTaken);
   });
@@ -68,6 +69,7 @@ contract('Pausable', function(accounts) {
     await Pausable.unpause();
     try {
       await Pausable.drasticMeasure();
+      assert.fail('should have thrown before');
     } catch(error) {
       assertJump(error);
     }

test/PausableToken.js

@@ -55,19 +55,19 @@ contract('PausableToken', function(accounts) {
     await token.pause();
     try { 
       await token.transfer(accounts[1], 100);
+      assert.fail('should have thrown before');
     } catch (error) {
-      return assertJump(error);
+      assertJump(error);
     }
-    assert.fail('should have thrown before');
   });
 
   it('should throw an error trying to transfer from another account while transactions are paused', async function() {
     await token.pause();
     try { 
       await token.transferFrom(accounts[0], accounts[1], 100);
+      assert.fail('should have thrown before');
     } catch (error) {
-      return assertJump(error);
+      assertJump(error);
     }
-    assert.fail('should have thrown before');
   });
 })

test/SafeMath.js

@@ -40,10 +40,10 @@ contract('SafeMath', function(accounts) {
     let b = 5678;
     try {
       let subtract = await safeMath.subtract(a, b);
+      assert.fail('should have thrown before');
     } catch(error) {
-      return assertJump(error);
+      assertJump(error);
     }
-    assert.fail('should have thrown before');
   });
 
   it("should throw an error on addition overflow", async function() {
@@ -51,10 +51,10 @@ contract('SafeMath', function(accounts) {
     let b = 1;
     try {
       let add = await safeMath.add(a, b);
+      assert.fail('should have thrown before');
     } catch(error) {
-      return assertJump(error);
+      assertJump(error);
     }
-    assert.fail('should have thrown before');
   });
 
   it("should throw an error on multiplication overflow", async function() {
@@ -62,10 +62,10 @@ contract('SafeMath', function(accounts) {
     let b = 2;
     try {
       let multiply = await safeMath.multiply(a, b);
+      assert.fail('should have thrown before');
     } catch(error) {
-      return assertJump(error);
+      assertJump(error);
     }
-    assert.fail('should have thrown before');
   });
 
 });

test/StandardToken.js

@@ -39,10 +39,10 @@ contract('StandardToken', function(accounts) {
     let token = await StandardTokenMock.new(accounts[0], 100);
     try {
       await token.transfer(accounts[1], 101);
+      assert.fail('should have thrown before');
     } catch(error) {
-      return assertJump(error);
+      assertJump(error);
     }
-    assert.fail('should have thrown before');
   });
 
   it('should return correct balances after transfering from another account', async function() {
@@ -64,10 +64,10 @@ contract('StandardToken', function(accounts) {
     await token.approve(accounts[1], 99);
     try {
       await token.transferFrom(accounts[0], accounts[2], 100, {from: accounts[1]});
+      assert.fail('should have thrown before');
     } catch (error) {
-      return assertJump(error);
+      assertJump(error);
     }
-    assert.fail('should have thrown before');
   });
 
 });

test/VestedToken.js

@@ -46,20 +46,20 @@ contract('VestedToken', function(accounts) {
     it('throws when trying to transfer non vested tokens', async () => {
       try {
         await token.transfer(accounts[7], 1, { from: receiver })
+        assert.fail('should have thrown before');
       } catch(error) {
-        return assertJump(error);
+        assertJump(error);
       }
-      assert.fail('should have thrown before');
     })
 
     it('throws when trying to transfer from non vested tokens', async () => {
       try {
         await token.approve(accounts[7], 1, { from: receiver })
         await token.transferFrom(receiver, accounts[7], tokenAmount, { from: accounts[7] })
+        assert.fail('should have thrown before');
       } catch(error) {
-        return assertJump(error);
+        assertJump(error);
       }
-      assert.fail('should have thrown before');
     })
 
     it('can be revoked by granter', async () => {
@@ -71,10 +71,10 @@ contract('VestedToken', function(accounts) {
     it('cannot be revoked by non granter', async () => {
       try {
         await token.revokeTokenGrant(receiver, 0, { from: accounts[3] });
+        assert.fail('should have thrown before');
       } catch(error) {
-        return assertJump(error);
+        assertJump(error);
       }
-      assert.fail('should have thrown before');
     })
 
     it('can be revoked by granter and non vested tokens are returned', async () => {
@@ -131,10 +131,10 @@ contract('VestedToken', function(accounts) {
     it('throws when granter attempts to revoke', async () => {
       try {
         await token.revokeTokenGrant(receiver, 0, { from: granter });
+        assert.fail('should have thrown before');
       } catch(error) {
-        return assertJump(error);
+        assertJump(error);
       }
-      assert.fail('should have thrown before');
     })
   })
 
@@ -160,10 +160,10 @@ contract('VestedToken', function(accounts) {
     it('cannot be revoked by non granter', async () => {
       try {
         await token.revokeTokenGrant(receiver, 0, { from: accounts[3] });
+        assert.fail('should have thrown before');
       } catch(error) {
-        return assertJump(error);
+        assertJump(error);
       }
-      assert.fail('should have thrown before');
     })
 
     it('can be revoked by granter and non vested tokens are returned', async () => {