测试松露中的智能合约要求：如果功能不无效，则交易将被还原

Question

im trying to test the requires of a Smart Contract using just solidity according to this article:

http://truffleframework.com/tutorials/testing-for-throws-in-solidity-tests

This is the contract, the throw proxy contract and the test:

/* Testing with solidity tests. */

import "truffle/Assert.sol";
import "truffle/DeployedAddresses.sol";
import "../contracts/MyContract.sol";

contract TestMyContract {

function testInitialStoredValue() {
    MyContract mycontract = new MyContract();

    uint expected = 24;

    Assert.equal(mycontract.mynumber(), expected, "First number set should be 24.");
}

function testTheThrow() {
    MyContract mycontract = new MyContract(); 

    ThrowProxy throwproxy = new ThrowProxy(address(mycontract)); 
    uint num = 7;
    MyContract(address(throwproxy)).storeNum(num);

    bool r = throwproxy.execute.gas(200000)(); 

    Assert.isFalse(r, "Should be false because is should throw!");

}

function testNoThrow() {
    MyContract mycontract = new MyContract(); 

    ThrowProxy throwproxy = new ThrowProxy(address(mycontract)); 

    MyContract(address(throwproxy)).storeNum(22);

    bool r = throwproxy.execute.gas(200000)(); 

    Assert.isTrue(r, "Should be true because is should throw!");

}

}

// Proxy contract for testing throws
contract ThrowProxy {
  address public target;
  bytes data;

  function ThrowProxy(address _target) {
    target = _target;
  }

  //prime the data using the fallback function.
  function() {
    data = msg.data;
  }

  function execute() returns (bool) {
    return target.call(data);
  }
}

If i run the tests i get this error:

If i change the storeNum function to void from

 function storeNum(uint mynum)
        public
        returns (bool)
    {
     require(mynum > 10);
     mynumber = mynum; 
     return true;    
    }

to

 function storeNum(uint mynum)
        public
    {
     require(mynum > 10);
     mynumber = mynum; 
     return true;    
    }

the tests works..

Any ideas?

Im using Truffle v4.1.11

Answer 1

Let's look at your code:

function storeNum(uint mynum)
        public
        returns (bool success)
    {
     require(mynum > 10);
     mynumber = mynum; 
     return true;    
    }

By defining returns (bool success) you're saying to the solidity compiler two things:

• There is a variable named success of the type bool (variable definition)
• That variable success will be returned by the function (return definition)

But your variable isn't returned after all (your function ends with return true , and that's why you get an InvalidResponse error on your tests.

For your code, the most efficient code would be:

function storeNum(uint mynum)
        public
        returns (bool)    // you should define at least the type
    {
     require(mynum > 10);
     mynumber = mynum; 
     return true;    
    }

As an exercise, a version using the variable success :

function storeNum(uint mynum)
        public
        returns (bool success)
    {
     require(mynum > 10);
     mynumber = mynum; 
     success = true;    // don't need to use return
    }

Hope it helps.

Answer 2

Well, i have submited an issue into Truffle github and it is still opened, maybe this is related to recent solidity changes:

https://github.com/trufflesuite/truffle/issues/1001

A workarround for now is to wrap the functions into void functions and test if the execution succeeds or not:

/*
    Contract wrapper that inherits from MyContract. This contract wraps the calls of non void functions when
    testing for exceptions.

    Why not invoke directly the function?: https://github.com/trufflesuite/truffle/issues/1001
*/

contract MyExposedContract is MyContract() {


    function callStoreNum(uint256 num)  public {
        storeNum(num);
    }

}

Then use that wrapper in your tests:

function testTheThrow() {
    MyExposedContract mycontract = new MyExposedContract (); 

    ThrowProxy throwproxy = new ThrowProxy(address(mycontract)); 
    uint num = 7;
    MyExposedContract (address(throwproxy)).callStoreNum(num);

    bool r = throwproxy.execute.gas(200000)(); 

    Assert.isFalse(r, "Should be false because it should throw!");

}