mirror of
https://github.com/ethereum/solidity
synced 2023-10-03 13:03:40 +00:00
Merge remote-tracking branch 'upstream/develop' into bugfix
Conflicts: libevm/VM.h
This commit is contained in:
commit
ab65cbb8be
@ -72,7 +72,7 @@ ImportTest::ImportTest(json_spirit::mObject& _o, bool isFiller): m_TestObject(_o
|
||||
if (!isFiller)
|
||||
{
|
||||
importState(_o["post"].get_obj(), m_statePost);
|
||||
m_environment.sub.logs = importLog(_o["logs"].get_obj());
|
||||
m_environment.sub.logs = importLog(_o["logs"].get_array());
|
||||
}
|
||||
}
|
||||
|
||||
@ -259,16 +259,17 @@ bytes importCode(json_spirit::mObject& _o)
|
||||
return code;
|
||||
}
|
||||
|
||||
LogEntries importLog(json_spirit::mObject& _o)
|
||||
LogEntries importLog(json_spirit::mArray& _a)
|
||||
{
|
||||
LogEntries logEntries;
|
||||
for (auto const& l: _o)
|
||||
for (auto const& l: _a)
|
||||
{
|
||||
json_spirit::mObject o = l.second.get_obj();
|
||||
json_spirit::mObject o = l.get_obj();
|
||||
// cant use BOOST_REQUIRE, because this function is used outside boost test (createRandomTest)
|
||||
assert(o.count("address") > 0);
|
||||
assert(o.count("topics") > 0);
|
||||
assert(o.count("data") > 0);
|
||||
assert(o.count("bloom") > 0);
|
||||
LogEntry log;
|
||||
log.address = Address(o["address"].get_str());
|
||||
for (auto const& t: o["topics"].get_array())
|
||||
@ -279,9 +280,9 @@ LogEntries importLog(json_spirit::mObject& _o)
|
||||
return logEntries;
|
||||
}
|
||||
|
||||
json_spirit::mObject exportLog(eth::LogEntries _logs)
|
||||
json_spirit::mArray exportLog(eth::LogEntries _logs)
|
||||
{
|
||||
json_spirit::mObject ret;
|
||||
json_spirit::mArray ret;
|
||||
if (_logs.size() == 0) return ret;
|
||||
for (LogEntry const& l: _logs)
|
||||
{
|
||||
@ -292,7 +293,8 @@ json_spirit::mObject exportLog(eth::LogEntries _logs)
|
||||
topics.push_back(toString(t));
|
||||
o["topics"] = topics;
|
||||
o["data"] = "0x" + toHex(l.data);
|
||||
ret[toString(l.bloom())] = o;
|
||||
o["bloom"] = toString(l.bloom());
|
||||
ret.push_back(o);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
@ -327,6 +329,10 @@ void checkStorage(map<u256, u256> _expectedStore, map<u256, u256> _resultStore,
|
||||
BOOST_CHECK_MESSAGE(expectedStoreValue == resultStoreValue, _expectedAddr << ": store[" << expectedStoreKey << "] = " << resultStoreValue << ", expected " << expectedStoreValue);
|
||||
}
|
||||
}
|
||||
|
||||
for (auto&& resultStorePair : _resultStore)
|
||||
if (!_expectedStore.count(resultStorePair.first))
|
||||
BOOST_ERROR(_expectedAddr << ": unexpected store key " << resultStorePair.first);
|
||||
}
|
||||
|
||||
void checkLog(LogEntries _resultLogs, LogEntries _expectedLogs)
|
||||
|
@ -68,8 +68,8 @@ u256 toInt(json_spirit::mValue const& _v);
|
||||
byte toByte(json_spirit::mValue const& _v);
|
||||
bytes importCode(json_spirit::mObject& _o);
|
||||
bytes importData(json_spirit::mObject& _o);
|
||||
eth::LogEntries importLog(json_spirit::mObject& _o);
|
||||
json_spirit::mObject exportLog(eth::LogEntries _logs);
|
||||
eth::LogEntries importLog(json_spirit::mArray& _o);
|
||||
json_spirit::mArray exportLog(eth::LogEntries _logs);
|
||||
void checkOutput(bytes const& _output, json_spirit::mObject& _o);
|
||||
void checkStorage(std::map<u256, u256> _expectedStore, std::map<u256, u256> _resultStore, Address _expectedAddr);
|
||||
void checkLog(eth::LogEntries _resultLogs, eth::LogEntries _expectedLogs);
|
||||
|
@ -32,7 +32,7 @@
|
||||
#include <libdevcore/CommonIO.h>
|
||||
#include <libdevcore/CommonData.h>
|
||||
#include <libevmcore/Instruction.h>
|
||||
#include <libevm/VM.h>
|
||||
#include <libevm/VMFactory.h>
|
||||
#include "vm.h"
|
||||
|
||||
using namespace std;
|
||||
@ -142,14 +142,14 @@ void doMyTests(json_spirit::mValue& v)
|
||||
}
|
||||
|
||||
bytes output;
|
||||
eth::VM vm(fev.gas);
|
||||
auto vm = eth::VMFactory::create(fev.gas);
|
||||
|
||||
u256 gas;
|
||||
bool vmExceptionOccured = false;
|
||||
try
|
||||
{
|
||||
output = vm.go(fev, fev.simpleTrace()).toBytes();
|
||||
gas = vm.gas();
|
||||
output = vm->go(fev, fev.simpleTrace()).toBytes();
|
||||
gas = vm->gas();
|
||||
}
|
||||
catch (eth::VMException const& _e)
|
||||
{
|
||||
@ -189,7 +189,7 @@ void doMyTests(json_spirit::mValue& v)
|
||||
o["callcreates"] = fev.exportCallCreates();
|
||||
o["out"] = "0x" + toHex(output);
|
||||
fev.push(o, "gas", gas);
|
||||
o["logs"] = mValue(test::exportLog(fev.sub.logs));
|
||||
o["logs"] = test::exportLog(fev.sub.logs);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -44,6 +44,14 @@ static CryptoPP::OID s_curveOID(CryptoPP::ASN1::secp256k1());
|
||||
static CryptoPP::DL_GroupParameters_EC<CryptoPP::ECP> s_params(s_curveOID);
|
||||
static CryptoPP::DL_GroupParameters_EC<CryptoPP::ECP>::EllipticCurve s_curve(s_params.GetCurve());
|
||||
|
||||
BOOST_AUTO_TEST_CASE(cryptopp_patch)
|
||||
{
|
||||
KeyPair k = KeyPair::create();
|
||||
bytes io_text;
|
||||
s_secp256k1.decrypt(k.sec(), io_text);
|
||||
BOOST_REQUIRE_EQUAL(io_text.size(), 0);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(verify_secert)
|
||||
{
|
||||
h256 empty;
|
||||
|
@ -51,7 +51,7 @@ BOOST_AUTO_TEST_CASE(genesis_tests)
|
||||
|
||||
BOOST_CHECK_EQUAL(BlockChain::genesis().stateRoot, h256(o["genesis_state_root"].get_str()));
|
||||
BOOST_CHECK_EQUAL(toHex(BlockChain::createGenesisBlock()), toHex(fromHex(o["genesis_rlp_hex"].get_str())));
|
||||
BOOST_CHECK_EQUAL(sha3(BlockChain::createGenesisBlock()), h256(o["genesis_hash"].get_str()));
|
||||
BOOST_CHECK_EQUAL(BlockInfo::headerHash(BlockChain::createGenesisBlock()), h256(o["genesis_hash"].get_str()));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
@ -19,7 +19,7 @@
|
||||
* @date 2014
|
||||
*/
|
||||
|
||||
#if ETH_JSONRPC
|
||||
#if ETH_JSONRPC && 0
|
||||
|
||||
#include <boost/test/unit_test.hpp>
|
||||
#include <boost/lexical_cast.hpp>
|
||||
@ -43,7 +43,7 @@ using namespace dev;
|
||||
using namespace dev::eth;
|
||||
namespace js = json_spirit;
|
||||
|
||||
WebThreeDirect *web3;
|
||||
WebThreeDirect* web3;
|
||||
unique_ptr<WebThreeStubServer> jsonrpcServer;
|
||||
unique_ptr<WebThreeStubClient> jsonrpcClient;
|
||||
|
||||
|
@ -46,16 +46,23 @@ namespace
|
||||
bytes compileContract(const string& _sourceCode)
|
||||
{
|
||||
Parser parser;
|
||||
ASTPointer<ContractDefinition> contract;
|
||||
BOOST_REQUIRE_NO_THROW(contract = parser.parse(make_shared<Scanner>(CharStream(_sourceCode))));
|
||||
ASTPointer<SourceUnit> sourceUnit;
|
||||
BOOST_REQUIRE_NO_THROW(sourceUnit = parser.parse(make_shared<Scanner>(CharStream(_sourceCode))));
|
||||
NameAndTypeResolver resolver({});
|
||||
BOOST_REQUIRE_NO_THROW(resolver.resolveNamesAndTypes(*contract));
|
||||
resolver.registerDeclarations(*sourceUnit);
|
||||
for (ASTPointer<ASTNode> const& node: sourceUnit->getNodes())
|
||||
if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
|
||||
{
|
||||
BOOST_REQUIRE_NO_THROW(resolver.resolveNamesAndTypes(*contract));
|
||||
|
||||
Compiler compiler;
|
||||
compiler.compileContract(*contract, {});
|
||||
// debug
|
||||
//compiler.streamAssembly(cout);
|
||||
return compiler.getAssembledBytecode();
|
||||
Compiler compiler;
|
||||
compiler.compileContract(*contract, {});
|
||||
// debug
|
||||
//compiler.streamAssembly(cout);
|
||||
return compiler.getAssembledBytecode();
|
||||
}
|
||||
BOOST_FAIL("No contract found in source.");
|
||||
return bytes();
|
||||
}
|
||||
|
||||
/// Checks that @a _compiledCode is present starting from offset @a _offset in @a _expectation.
|
||||
@ -80,7 +87,7 @@ BOOST_AUTO_TEST_CASE(smoke_test)
|
||||
"}\n";
|
||||
bytes code = compileContract(sourceCode);
|
||||
|
||||
unsigned boilerplateSize = 42;
|
||||
unsigned boilerplateSize = 40;
|
||||
bytes expectation({byte(Instruction::JUMPDEST),
|
||||
byte(Instruction::PUSH1), 0x0, // initialize local variable x
|
||||
byte(Instruction::PUSH1), 0x2,
|
||||
@ -100,8 +107,8 @@ BOOST_AUTO_TEST_CASE(different_argument_numbers)
|
||||
"}\n";
|
||||
bytes code = compileContract(sourceCode);
|
||||
|
||||
unsigned shift = 70;
|
||||
unsigned boilerplateSize = 83;
|
||||
unsigned shift = 68;
|
||||
unsigned boilerplateSize = 81;
|
||||
bytes expectation({byte(Instruction::JUMPDEST),
|
||||
byte(Instruction::PUSH1), 0x0, // initialize return variable d
|
||||
byte(Instruction::DUP3),
|
||||
@ -118,8 +125,8 @@ BOOST_AUTO_TEST_CASE(different_argument_numbers)
|
||||
byte(Instruction::JUMP), // end of f
|
||||
byte(Instruction::JUMPDEST), // beginning of g
|
||||
byte(Instruction::PUSH1), 0x0,
|
||||
byte(Instruction::DUP1), // initialized e and h
|
||||
byte(Instruction::PUSH1), byte(0x29 + shift), // ret address
|
||||
byte(Instruction::PUSH1), 0x0, // initialized e and h
|
||||
byte(Instruction::PUSH1), byte(0x2a + shift), // ret address
|
||||
byte(Instruction::PUSH1), 0x1, byte(Instruction::PUSH1), 0xff, byte(Instruction::AND),
|
||||
byte(Instruction::PUSH1), 0x2, byte(Instruction::PUSH1), 0xff, byte(Instruction::AND),
|
||||
byte(Instruction::PUSH1), 0x3, byte(Instruction::PUSH1), 0xff, byte(Instruction::AND),
|
||||
@ -151,8 +158,8 @@ BOOST_AUTO_TEST_CASE(ifStatement)
|
||||
"}\n";
|
||||
bytes code = compileContract(sourceCode);
|
||||
|
||||
unsigned shift = 29;
|
||||
unsigned boilerplateSize = 42;
|
||||
unsigned shift = 27;
|
||||
unsigned boilerplateSize = 40;
|
||||
bytes expectation({byte(Instruction::JUMPDEST),
|
||||
byte(Instruction::PUSH1), 0x0,
|
||||
byte(Instruction::DUP1),
|
||||
@ -193,8 +200,8 @@ BOOST_AUTO_TEST_CASE(loops)
|
||||
"}\n";
|
||||
bytes code = compileContract(sourceCode);
|
||||
|
||||
unsigned shift = 29;
|
||||
unsigned boilerplateSize = 42;
|
||||
unsigned shift = 27;
|
||||
unsigned boilerplateSize = 40;
|
||||
bytes expectation({byte(Instruction::JUMPDEST),
|
||||
byte(Instruction::JUMPDEST),
|
||||
byte(Instruction::PUSH1), 0x1,
|
||||
|
@ -24,132 +24,18 @@
|
||||
#include <string>
|
||||
#include <tuple>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
#include <libethereum/State.h>
|
||||
#include <libethereum/Executive.h>
|
||||
#include <libsolidity/CompilerStack.h>
|
||||
#include <libdevcrypto/SHA3.h>
|
||||
#include <test/solidityExecutionFramework.h>
|
||||
|
||||
using namespace std;
|
||||
|
||||
namespace dev
|
||||
{
|
||||
/// Provides additional overloads for toBigEndian to encode arguments and return values.
|
||||
inline bytes toBigEndian(byte _value) { return bytes({_value}); }
|
||||
inline bytes toBigEndian(bool _value) { return bytes({byte(_value)}); }
|
||||
|
||||
namespace solidity
|
||||
{
|
||||
namespace test
|
||||
{
|
||||
|
||||
class ExecutionFramework
|
||||
{
|
||||
public:
|
||||
ExecutionFramework() { g_logVerbosity = 0; }
|
||||
|
||||
bytes const& compileAndRun(string const& _sourceCode, u256 const& _value = 0)
|
||||
{
|
||||
bytes code = dev::solidity::CompilerStack::staticCompile(_sourceCode);
|
||||
sendMessage(code, true, _value);
|
||||
BOOST_REQUIRE(!m_output.empty());
|
||||
return m_output;
|
||||
}
|
||||
|
||||
bytes const& callContractFunction(byte _index, bytes const& _data = bytes(), u256 const& _value = 0)
|
||||
{
|
||||
sendMessage(bytes(1, _index) + _data, false, _value);
|
||||
return m_output;
|
||||
}
|
||||
|
||||
template <class... Args>
|
||||
bytes const& callContractFunction(byte _index, Args const&... _arguments)
|
||||
{
|
||||
return callContractFunction(_index, argsToBigEndian(_arguments...));
|
||||
}
|
||||
|
||||
template <class CppFunction, class... Args>
|
||||
void testSolidityAgainstCpp(byte _index, CppFunction const& _cppFunction, Args const&... _arguments)
|
||||
{
|
||||
bytes solidityResult = callContractFunction(_index, _arguments...);
|
||||
bytes cppResult = callCppAndEncodeResult(_cppFunction, _arguments...);
|
||||
BOOST_CHECK_MESSAGE(solidityResult == cppResult, "Computed values do not match."
|
||||
"\nSolidity: " + toHex(solidityResult) + "\nC++: " + toHex(cppResult));
|
||||
}
|
||||
|
||||
template <class CppFunction, class... Args>
|
||||
void testSolidityAgainstCppOnRange(byte _index, CppFunction const& _cppFunction,
|
||||
u256 const& _rangeStart, u256 const& _rangeEnd)
|
||||
{
|
||||
for (u256 argument = _rangeStart; argument < _rangeEnd; ++argument)
|
||||
{
|
||||
bytes solidityResult = callContractFunction(_index, argument);
|
||||
bytes cppResult = callCppAndEncodeResult(_cppFunction, argument);
|
||||
BOOST_CHECK_MESSAGE(solidityResult == cppResult, "Computed values do not match."
|
||||
"\nSolidity: " + toHex(solidityResult) + "\nC++: " + toHex(cppResult) +
|
||||
"\nArgument: " + toHex(toBigEndian(argument)));
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
template <class FirstArg, class... Args>
|
||||
bytes argsToBigEndian(FirstArg const& _firstArg, Args const&... _followingArgs) const
|
||||
{
|
||||
return toBigEndian(_firstArg) + argsToBigEndian(_followingArgs...);
|
||||
}
|
||||
|
||||
bytes argsToBigEndian() const { return bytes(); }
|
||||
|
||||
template <class CppFunction, class... Args>
|
||||
auto callCppAndEncodeResult(CppFunction const& _cppFunction, Args const&... _arguments)
|
||||
-> typename enable_if<is_void<decltype(_cppFunction(_arguments...))>::value, bytes>::type
|
||||
{
|
||||
_cppFunction(_arguments...);
|
||||
return bytes();
|
||||
}
|
||||
template <class CppFunction, class... Args>
|
||||
auto callCppAndEncodeResult(CppFunction const& _cppFunction, Args const&... _arguments)
|
||||
-> typename enable_if<!is_void<decltype(_cppFunction(_arguments...))>::value, bytes>::type
|
||||
{
|
||||
return toBigEndian(_cppFunction(_arguments...));
|
||||
}
|
||||
|
||||
void sendMessage(bytes const& _data, bool _isCreation, u256 const& _value = 0)
|
||||
{
|
||||
eth::Executive executive(m_state);
|
||||
eth::Transaction t = _isCreation ? eth::Transaction(_value, m_gasPrice, m_gas, _data, 0, KeyPair::create().sec())
|
||||
: eth::Transaction(_value, m_gasPrice, m_gas, m_contractAddress, _data, 0, KeyPair::create().sec());
|
||||
bytes transactionRLP = t.rlp();
|
||||
try
|
||||
{
|
||||
// this will throw since the transaction is invalid, but it should nevertheless store the transaction
|
||||
executive.setup(&transactionRLP);
|
||||
}
|
||||
catch (...) {}
|
||||
if (_isCreation)
|
||||
{
|
||||
BOOST_REQUIRE(!executive.create(Address(), _value, m_gasPrice, m_gas, &_data, Address()));
|
||||
m_contractAddress = executive.newAddress();
|
||||
BOOST_REQUIRE(m_contractAddress);
|
||||
BOOST_REQUIRE(m_state.addressHasCode(m_contractAddress));
|
||||
}
|
||||
else
|
||||
{
|
||||
BOOST_REQUIRE(m_state.addressHasCode(m_contractAddress));
|
||||
BOOST_REQUIRE(!executive.call(m_contractAddress, Address(), _value, m_gasPrice, &_data, m_gas, Address()));
|
||||
}
|
||||
BOOST_REQUIRE(executive.go());
|
||||
executive.finalize();
|
||||
m_output = executive.out().toVector();
|
||||
}
|
||||
|
||||
protected:
|
||||
Address m_contractAddress;
|
||||
eth::State m_state;
|
||||
u256 const m_gasPrice = 100 * eth::szabo;
|
||||
u256 const m_gas = 1000000;
|
||||
bytes m_output;
|
||||
};
|
||||
|
||||
BOOST_FIXTURE_TEST_SUITE(SolidityCompilerEndToEndTest, ExecutionFramework)
|
||||
|
||||
BOOST_AUTO_TEST_CASE(smoke_test)
|
||||
@ -477,6 +363,48 @@ BOOST_AUTO_TEST_CASE(small_signed_types)
|
||||
testSolidityAgainstCpp(0, small_signed_types_cpp);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(strings)
|
||||
{
|
||||
char const* sourceCode = "contract test {\n"
|
||||
" function fixed() returns(string32 ret) {\n"
|
||||
" return \"abc\\x00\\xff__\";\n"
|
||||
" }\n"
|
||||
" function pipeThrough(string2 small, bool one) returns(string16 large, bool oneRet) {\n"
|
||||
" oneRet = one;\n"
|
||||
" large = small;\n"
|
||||
" }\n"
|
||||
"}\n";
|
||||
compileAndRun(sourceCode);
|
||||
bytes expectation(32, 0);
|
||||
expectation[0] = byte('a');
|
||||
expectation[1] = byte('b');
|
||||
expectation[2] = byte('c');
|
||||
expectation[3] = byte(0);
|
||||
expectation[4] = byte(0xff);
|
||||
expectation[5] = byte('_');
|
||||
expectation[6] = byte('_');
|
||||
BOOST_CHECK(callContractFunction(0, bytes()) == expectation);
|
||||
expectation = bytes(17, 0);
|
||||
expectation[0] = 0;
|
||||
expectation[1] = 2;
|
||||
expectation[16] = 1;
|
||||
BOOST_CHECK(callContractFunction(1, bytes({0x00, 0x02, 0x01})) == expectation);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(empty_string_on_stack)
|
||||
{
|
||||
char const* sourceCode = "contract test {\n"
|
||||
" function run(string0 empty, uint8 inp) returns(uint16 a, string0 b, string4 c) {\n"
|
||||
" var x = \"abc\";\n"
|
||||
" var y = \"\";\n"
|
||||
" var z = inp;\n"
|
||||
" a = z; b = y; c = x;"
|
||||
" }\n"
|
||||
"}\n";
|
||||
compileAndRun(sourceCode);
|
||||
BOOST_CHECK(callContractFunction(0, bytes({0x02})) == bytes({0x00, 0x02, 'a', 'b', 'c', 0x00}));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(state_smoke_test)
|
||||
{
|
||||
char const* sourceCode = "contract test {\n"
|
||||
@ -898,6 +826,191 @@ BOOST_AUTO_TEST_CASE(ecrecover)
|
||||
BOOST_CHECK(callContractFunction(0, h, v, r, s) == toBigEndian(addr));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(inter_contract_calls)
|
||||
{
|
||||
char const* sourceCode = R"(
|
||||
contract Helper {
|
||||
function multiply(uint a, uint b) returns (uint c) {
|
||||
return a * b;
|
||||
}
|
||||
}
|
||||
contract Main {
|
||||
Helper h;
|
||||
function callHelper(uint a, uint b) returns (uint c) {
|
||||
return h.multiply(a, b);
|
||||
}
|
||||
function getHelper() returns (address haddress) {
|
||||
return address(h);
|
||||
}
|
||||
function setHelper(address haddress) {
|
||||
h = Helper(haddress);
|
||||
}
|
||||
})";
|
||||
compileAndRun(sourceCode, 0, "Helper");
|
||||
u160 const helperAddress = m_contractAddress;
|
||||
compileAndRun(sourceCode, 0, "Main");
|
||||
BOOST_REQUIRE(callContractFunction(2, helperAddress) == bytes());
|
||||
BOOST_REQUIRE(callContractFunction(1, helperAddress) == toBigEndian(helperAddress));
|
||||
u256 a(3456789);
|
||||
u256 b("0x282837623374623234aa74");
|
||||
BOOST_REQUIRE(callContractFunction(0, a, b) == toBigEndian(a * b));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(inter_contract_calls_with_complex_parameters)
|
||||
{
|
||||
char const* sourceCode = R"(
|
||||
contract Helper {
|
||||
function sel(uint a, bool select, uint b) returns (uint c) {
|
||||
if (select) return a; else return b;
|
||||
}
|
||||
}
|
||||
contract Main {
|
||||
Helper h;
|
||||
function callHelper(uint a, bool select, uint b) returns (uint c) {
|
||||
return h.sel(a, select, b) * 3;
|
||||
}
|
||||
function getHelper() returns (address haddress) {
|
||||
return address(h);
|
||||
}
|
||||
function setHelper(address haddress) {
|
||||
h = Helper(haddress);
|
||||
}
|
||||
})";
|
||||
compileAndRun(sourceCode, 0, "Helper");
|
||||
u160 const helperAddress = m_contractAddress;
|
||||
compileAndRun(sourceCode, 0, "Main");
|
||||
BOOST_REQUIRE(callContractFunction(2, helperAddress) == bytes());
|
||||
BOOST_REQUIRE(callContractFunction(1, helperAddress) == toBigEndian(helperAddress));
|
||||
u256 a(3456789);
|
||||
u256 b("0x282837623374623234aa74");
|
||||
BOOST_REQUIRE(callContractFunction(0, a, true, b) == toBigEndian(a * 3));
|
||||
BOOST_REQUIRE(callContractFunction(0, a, false, b) == toBigEndian(b * 3));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(inter_contract_calls_accessing_this)
|
||||
{
|
||||
char const* sourceCode = R"(
|
||||
contract Helper {
|
||||
function getAddress() returns (address addr) {
|
||||
return address(this);
|
||||
}
|
||||
}
|
||||
contract Main {
|
||||
Helper h;
|
||||
function callHelper() returns (address addr) {
|
||||
return h.getAddress();
|
||||
}
|
||||
function getHelper() returns (address addr) {
|
||||
return address(h);
|
||||
}
|
||||
function setHelper(address addr) {
|
||||
h = Helper(addr);
|
||||
}
|
||||
})";
|
||||
compileAndRun(sourceCode, 0, "Helper");
|
||||
u160 const helperAddress = m_contractAddress;
|
||||
compileAndRun(sourceCode, 0, "Main");
|
||||
BOOST_REQUIRE(callContractFunction(2, helperAddress) == bytes());
|
||||
BOOST_REQUIRE(callContractFunction(1, helperAddress) == toBigEndian(helperAddress));
|
||||
BOOST_REQUIRE(callContractFunction(0) == toBigEndian(helperAddress));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(calls_to_this)
|
||||
{
|
||||
char const* sourceCode = R"(
|
||||
contract Helper {
|
||||
function invoke(uint a, uint b) returns (uint c) {
|
||||
return this.multiply(a, b, 10);
|
||||
}
|
||||
function multiply(uint a, uint b, uint8 c) returns (uint ret) {
|
||||
return a * b + c;
|
||||
}
|
||||
}
|
||||
contract Main {
|
||||
Helper h;
|
||||
function callHelper(uint a, uint b) returns (uint ret) {
|
||||
return h.invoke(a, b);
|
||||
}
|
||||
function getHelper() returns (address addr) {
|
||||
return address(h);
|
||||
}
|
||||
function setHelper(address addr) {
|
||||
h = Helper(addr);
|
||||
}
|
||||
})";
|
||||
compileAndRun(sourceCode, 0, "Helper");
|
||||
u160 const helperAddress = m_contractAddress;
|
||||
compileAndRun(sourceCode, 0, "Main");
|
||||
BOOST_REQUIRE(callContractFunction(2, helperAddress) == bytes());
|
||||
BOOST_REQUIRE(callContractFunction(1, helperAddress) == toBigEndian(helperAddress));
|
||||
u256 a(3456789);
|
||||
u256 b("0x282837623374623234aa74");
|
||||
BOOST_REQUIRE(callContractFunction(0, a, b) == toBigEndian(a * b + 10));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(inter_contract_calls_with_local_vars)
|
||||
{
|
||||
// note that a reference to another contract's function occupies two stack slots,
|
||||
// so this tests correct stack slot allocation
|
||||
char const* sourceCode = R"(
|
||||
contract Helper {
|
||||
function multiply(uint a, uint b) returns (uint c) {
|
||||
return a * b;
|
||||
}
|
||||
}
|
||||
contract Main {
|
||||
Helper h;
|
||||
function callHelper(uint a, uint b) returns (uint c) {
|
||||
var fu = h.multiply;
|
||||
var y = 9;
|
||||
var ret = fu(a, b);
|
||||
return ret + y;
|
||||
}
|
||||
function getHelper() returns (address haddress) {
|
||||
return address(h);
|
||||
}
|
||||
function setHelper(address haddress) {
|
||||
h = Helper(haddress);
|
||||
}
|
||||
})";
|
||||
compileAndRun(sourceCode, 0, "Helper");
|
||||
u160 const helperAddress = m_contractAddress;
|
||||
compileAndRun(sourceCode, 0, "Main");
|
||||
BOOST_REQUIRE(callContractFunction(2, helperAddress) == bytes());
|
||||
BOOST_REQUIRE(callContractFunction(1, helperAddress) == toBigEndian(helperAddress));
|
||||
u256 a(3456789);
|
||||
u256 b("0x282837623374623234aa74");
|
||||
BOOST_REQUIRE(callContractFunction(0, a, b) == toBigEndian(a * b + 9));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(strings_in_calls)
|
||||
{
|
||||
char const* sourceCode = R"(
|
||||
contract Helper {
|
||||
function invoke(string3 x, bool stop) returns (string4 ret) {
|
||||
return x;
|
||||
}
|
||||
}
|
||||
contract Main {
|
||||
Helper h;
|
||||
function callHelper(string2 x, bool stop) returns (string5 ret) {
|
||||
return h.invoke(x, stop);
|
||||
}
|
||||
function getHelper() returns (address addr) {
|
||||
return address(h);
|
||||
}
|
||||
function setHelper(address addr) {
|
||||
h = Helper(addr);
|
||||
}
|
||||
})";
|
||||
compileAndRun(sourceCode, 0, "Helper");
|
||||
u160 const helperAddress = m_contractAddress;
|
||||
compileAndRun(sourceCode, 0, "Main");
|
||||
BOOST_REQUIRE(callContractFunction(2, helperAddress) == bytes());
|
||||
BOOST_REQUIRE(callContractFunction(1, helperAddress) == toBigEndian(helperAddress));
|
||||
BOOST_CHECK(callContractFunction(0, bytes({0, 'a', 1})) == bytes({0, 'a', 0, 0, 0}));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
||||
}
|
||||
|
161
solidityExecutionFramework.h
Normal file
161
solidityExecutionFramework.h
Normal file
@ -0,0 +1,161 @@
|
||||
|
||||
/*
|
||||
This file is part of cpp-ethereum.
|
||||
|
||||
cpp-ethereum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
cpp-ethereum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
/**
|
||||
* @author Christian <c@ethdev.com>
|
||||
* @date 2014
|
||||
* Framework for executing Solidity contracts and testing them against C++ implementation.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <tuple>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
#include <libethereum/State.h>
|
||||
#include <libethereum/Executive.h>
|
||||
#include <libsolidity/CompilerStack.h>
|
||||
|
||||
namespace dev
|
||||
{
|
||||
/// Provides additional overloads for toBigEndian to encode arguments and return values.
|
||||
inline bytes toBigEndian(byte _value) { return bytes({_value}); }
|
||||
inline bytes toBigEndian(bool _value) { return bytes({byte(_value)}); }
|
||||
|
||||
namespace solidity
|
||||
{
|
||||
namespace test
|
||||
{
|
||||
|
||||
class ExecutionFramework
|
||||
{
|
||||
public:
|
||||
ExecutionFramework() { g_logVerbosity = 0; }
|
||||
|
||||
bytes const& compileAndRun(std::string const& _sourceCode, u256 const& _value = 0, std::string const& _contractName = "")
|
||||
{
|
||||
dev::solidity::CompilerStack compiler;
|
||||
compiler.compile(_sourceCode, m_optimize);
|
||||
bytes code = compiler.getBytecode(_contractName);
|
||||
sendMessage(code, true, _value);
|
||||
BOOST_REQUIRE(!m_output.empty());
|
||||
return m_output;
|
||||
}
|
||||
|
||||
bytes const& callContractFunction(byte _index, bytes const& _data = bytes(), u256 const& _value = 0)
|
||||
{
|
||||
sendMessage(bytes(1, _index) + _data, false, _value);
|
||||
return m_output;
|
||||
}
|
||||
|
||||
template <class... Args>
|
||||
bytes const& callContractFunction(byte _index, Args const&... _arguments)
|
||||
{
|
||||
return callContractFunction(_index, argsToBigEndian(_arguments...));
|
||||
}
|
||||
|
||||
template <class CppFunction, class... Args>
|
||||
void testSolidityAgainstCpp(byte _index, CppFunction const& _cppFunction, Args const&... _arguments)
|
||||
{
|
||||
bytes solidityResult = callContractFunction(_index, _arguments...);
|
||||
bytes cppResult = callCppAndEncodeResult(_cppFunction, _arguments...);
|
||||
BOOST_CHECK_MESSAGE(solidityResult == cppResult, "Computed values do not match."
|
||||
"\nSolidity: " + toHex(solidityResult) + "\nC++: " + toHex(cppResult));
|
||||
}
|
||||
|
||||
template <class CppFunction, class... Args>
|
||||
void testSolidityAgainstCppOnRange(byte _index, CppFunction const& _cppFunction,
|
||||
u256 const& _rangeStart, u256 const& _rangeEnd)
|
||||
{
|
||||
for (u256 argument = _rangeStart; argument < _rangeEnd; ++argument)
|
||||
{
|
||||
bytes solidityResult = callContractFunction(_index, argument);
|
||||
bytes cppResult = callCppAndEncodeResult(_cppFunction, argument);
|
||||
BOOST_CHECK_MESSAGE(solidityResult == cppResult, "Computed values do not match."
|
||||
"\nSolidity: " + toHex(solidityResult) + "\nC++: " + toHex(cppResult) +
|
||||
"\nArgument: " + toHex(toBigEndian(argument)));
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
template <class FirstArg, class... Args>
|
||||
bytes argsToBigEndian(FirstArg const& _firstArg, Args const&... _followingArgs) const
|
||||
{
|
||||
return toBigEndian(_firstArg) + argsToBigEndian(_followingArgs...);
|
||||
}
|
||||
|
||||
bytes argsToBigEndian() const { return bytes(); }
|
||||
|
||||
template <class CppFunction, class... Args>
|
||||
auto callCppAndEncodeResult(CppFunction const& _cppFunction, Args const&... _arguments)
|
||||
-> typename std::enable_if<std::is_void<decltype(_cppFunction(_arguments...))>::value, bytes>::type
|
||||
{
|
||||
_cppFunction(_arguments...);
|
||||
return bytes();
|
||||
}
|
||||
template <class CppFunction, class... Args>
|
||||
auto callCppAndEncodeResult(CppFunction const& _cppFunction, Args const&... _arguments)
|
||||
-> typename std::enable_if<!std::is_void<decltype(_cppFunction(_arguments...))>::value, bytes>::type
|
||||
{
|
||||
return toBigEndian(_cppFunction(_arguments...));
|
||||
}
|
||||
|
||||
void sendMessage(bytes const& _data, bool _isCreation, u256 const& _value = 0)
|
||||
{
|
||||
m_state.addBalance(m_sender, _value); // just in case
|
||||
eth::Executive executive(m_state, 0);
|
||||
eth::Transaction t = _isCreation ? eth::Transaction(_value, m_gasPrice, m_gas, _data, 0, KeyPair::create().sec())
|
||||
: eth::Transaction(_value, m_gasPrice, m_gas, m_contractAddress, _data, 0, KeyPair::create().sec());
|
||||
bytes transactionRLP = t.rlp();
|
||||
try
|
||||
{
|
||||
// this will throw since the transaction is invalid, but it should nevertheless store the transaction
|
||||
executive.setup(&transactionRLP);
|
||||
}
|
||||
catch (...) {}
|
||||
if (_isCreation)
|
||||
{
|
||||
BOOST_REQUIRE(!executive.create(m_sender, _value, m_gasPrice, m_gas, &_data, m_sender));
|
||||
m_contractAddress = executive.newAddress();
|
||||
BOOST_REQUIRE(m_contractAddress);
|
||||
BOOST_REQUIRE(m_state.addressHasCode(m_contractAddress));
|
||||
}
|
||||
else
|
||||
{
|
||||
BOOST_REQUIRE(m_state.addressHasCode(m_contractAddress));
|
||||
BOOST_REQUIRE(!executive.call(m_contractAddress, m_contractAddress, m_sender, _value, m_gasPrice, &_data, m_gas, m_sender));
|
||||
}
|
||||
BOOST_REQUIRE(executive.go());
|
||||
m_state.noteSending(m_sender);
|
||||
executive.finalize();
|
||||
m_output = executive.out().toVector();
|
||||
}
|
||||
|
||||
protected:
|
||||
bool m_optimize = false;
|
||||
Address m_sender;
|
||||
Address m_contractAddress;
|
||||
eth::State m_state;
|
||||
u256 const m_gasPrice = 100 * eth::szabo;
|
||||
u256 const m_gas = 1000000;
|
||||
bytes m_output;
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
} // end namespaces
|
||||
|
@ -86,27 +86,34 @@ bytes compileFirstExpression(const string& _sourceCode, vector<vector<string>> _
|
||||
vector<vector<string>> _localVariables = {})
|
||||
{
|
||||
Parser parser;
|
||||
ASTPointer<ContractDefinition> contract;
|
||||
BOOST_REQUIRE_NO_THROW(contract = parser.parse(make_shared<Scanner>(CharStream(_sourceCode))));
|
||||
ASTPointer<SourceUnit> sourceUnit;
|
||||
BOOST_REQUIRE_NO_THROW(sourceUnit = parser.parse(make_shared<Scanner>(CharStream(_sourceCode))));
|
||||
NameAndTypeResolver resolver({});
|
||||
BOOST_REQUIRE_NO_THROW(resolver.resolveNamesAndTypes(*contract));
|
||||
FirstExpressionExtractor extractor(*contract);
|
||||
BOOST_REQUIRE(extractor.getExpression() != nullptr);
|
||||
resolver.registerDeclarations(*sourceUnit);
|
||||
for (ASTPointer<ASTNode> const& node: sourceUnit->getNodes())
|
||||
if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
|
||||
{
|
||||
BOOST_REQUIRE_NO_THROW(resolver.resolveNamesAndTypes(*contract));
|
||||
FirstExpressionExtractor extractor(*contract);
|
||||
BOOST_REQUIRE(extractor.getExpression() != nullptr);
|
||||
|
||||
CompilerContext context;
|
||||
for (vector<string> const& function: _functions)
|
||||
context.addFunction(dynamic_cast<FunctionDefinition const&>(resolveDeclaration(function, resolver)));
|
||||
for (vector<string> const& variable: _localVariables)
|
||||
context.addVariable(dynamic_cast<VariableDeclaration const&>(resolveDeclaration(variable, resolver)));
|
||||
CompilerContext context;
|
||||
for (vector<string> const& function: _functions)
|
||||
context.addFunction(dynamic_cast<FunctionDefinition const&>(resolveDeclaration(function, resolver)));
|
||||
for (vector<string> const& variable: _localVariables)
|
||||
context.addVariable(dynamic_cast<VariableDeclaration const&>(resolveDeclaration(variable, resolver)));
|
||||
|
||||
ExpressionCompiler::compileExpression(context, *extractor.getExpression());
|
||||
ExpressionCompiler::compileExpression(context, *extractor.getExpression());
|
||||
|
||||
for (vector<string> const& function: _functions)
|
||||
context << context.getFunctionEntryLabel(dynamic_cast<FunctionDefinition const&>(resolveDeclaration(function, resolver)));
|
||||
bytes instructions = context.getAssembledBytecode();
|
||||
// debug
|
||||
// cout << eth::disassemble(instructions) << endl;
|
||||
return instructions;
|
||||
for (vector<string> const& function: _functions)
|
||||
context << context.getFunctionEntryLabel(dynamic_cast<FunctionDefinition const&>(resolveDeclaration(function, resolver)));
|
||||
bytes instructions = context.getAssembledBytecode();
|
||||
// debug
|
||||
// cout << eth::disassemble(instructions) << endl;
|
||||
return instructions;
|
||||
}
|
||||
BOOST_FAIL("No contract found in source.");
|
||||
return bytes();
|
||||
}
|
||||
|
||||
} // end anonymous namespace
|
||||
|
@ -23,6 +23,7 @@
|
||||
#include <boost/test/unit_test.hpp>
|
||||
#include <libsolidity/CompilerStack.h>
|
||||
#include <jsonrpc/json/json.h>
|
||||
#include <libdevcore/Exceptions.h>
|
||||
|
||||
namespace dev
|
||||
{
|
||||
@ -34,23 +35,37 @@ namespace test
|
||||
class InterfaceChecker
|
||||
{
|
||||
public:
|
||||
bool checkInterface(std::string const& _code, std::string const& _expectedInterfaceString)
|
||||
void checkInterface(std::string const& _code, std::string const& _expectedInterfaceString)
|
||||
{
|
||||
m_compilerStack.parse(_code);
|
||||
std::string generatedInterfaceString = m_compilerStack.getInterface();
|
||||
try
|
||||
{
|
||||
m_compilerStack.parse(_code);
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
std::string const* extra = boost::get_error_info<errinfo_comment>(e);
|
||||
std::string msg = std::string("Parsing contract failed with: ") +
|
||||
e.what() + std::string("\n");
|
||||
if (extra)
|
||||
msg += *extra;
|
||||
BOOST_FAIL(msg);
|
||||
}
|
||||
std::string generatedInterfaceString = m_compilerStack.getJsonDocumentation("", DocumentationType::ABI_INTERFACE);
|
||||
Json::Value generatedInterface;
|
||||
m_reader.parse(generatedInterfaceString, generatedInterface);
|
||||
Json::Value expectedInterface;
|
||||
m_reader.parse(_expectedInterfaceString, expectedInterface);
|
||||
return expectedInterface == generatedInterface;
|
||||
BOOST_CHECK_MESSAGE(expectedInterface == generatedInterface,
|
||||
"Expected " << _expectedInterfaceString <<
|
||||
"\n but got:\n" << generatedInterfaceString);
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
CompilerStack m_compilerStack;
|
||||
Json::Reader m_reader;
|
||||
};
|
||||
|
||||
BOOST_FIXTURE_TEST_SUITE(SolidityCompilerJSONInterfaceOutput, InterfaceChecker)
|
||||
BOOST_FIXTURE_TEST_SUITE(SolidityABIJSON, InterfaceChecker)
|
||||
|
||||
BOOST_AUTO_TEST_CASE(basic_test)
|
||||
{
|
||||
@ -76,7 +91,7 @@ BOOST_AUTO_TEST_CASE(basic_test)
|
||||
}
|
||||
])";
|
||||
|
||||
BOOST_CHECK(checkInterface(sourceCode, interface));
|
||||
checkInterface(sourceCode, interface);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(empty_contract)
|
||||
@ -86,7 +101,7 @@ BOOST_AUTO_TEST_CASE(empty_contract)
|
||||
|
||||
char const* interface = "[]";
|
||||
|
||||
BOOST_CHECK(checkInterface(sourceCode, interface));
|
||||
checkInterface(sourceCode, interface);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(multiple_methods)
|
||||
@ -95,7 +110,7 @@ BOOST_AUTO_TEST_CASE(multiple_methods)
|
||||
" function f(uint a) returns(uint d) { return a * 7; }\n"
|
||||
" function g(uint b) returns(uint e) { return b * 8; }\n"
|
||||
"}\n";
|
||||
|
||||
|
||||
char const* interface = R"([
|
||||
{
|
||||
"name": "f",
|
||||
@ -129,7 +144,7 @@ BOOST_AUTO_TEST_CASE(multiple_methods)
|
||||
}
|
||||
])";
|
||||
|
||||
BOOST_CHECK(checkInterface(sourceCode, interface));
|
||||
checkInterface(sourceCode, interface);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(multiple_params)
|
||||
@ -160,7 +175,7 @@ BOOST_AUTO_TEST_CASE(multiple_params)
|
||||
}
|
||||
])";
|
||||
|
||||
BOOST_CHECK(checkInterface(sourceCode, interface));
|
||||
checkInterface(sourceCode, interface);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(multiple_methods_order)
|
||||
@ -170,7 +185,7 @@ BOOST_AUTO_TEST_CASE(multiple_methods_order)
|
||||
" function f(uint a) returns(uint d) { return a * 7; }\n"
|
||||
" function c(uint b) returns(uint e) { return b * 8; }\n"
|
||||
"}\n";
|
||||
|
||||
|
||||
char const* interface = R"([
|
||||
{
|
||||
"name": "c",
|
||||
@ -203,8 +218,8 @@ BOOST_AUTO_TEST_CASE(multiple_methods_order)
|
||||
]
|
||||
}
|
||||
])";
|
||||
|
||||
BOOST_CHECK(checkInterface(sourceCode, interface));
|
||||
|
||||
checkInterface(sourceCode, interface);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
@ -41,10 +41,12 @@ namespace
|
||||
void parseTextAndResolveNames(std::string const& _source)
|
||||
{
|
||||
Parser parser;
|
||||
ASTPointer<ContractDefinition> contract = parser.parse(
|
||||
std::make_shared<Scanner>(CharStream(_source)));
|
||||
ASTPointer<SourceUnit> sourceUnit = parser.parse(std::make_shared<Scanner>(CharStream(_source)));
|
||||
NameAndTypeResolver resolver({});
|
||||
resolver.resolveNamesAndTypes(*contract);
|
||||
resolver.registerDeclarations(*sourceUnit);
|
||||
for (ASTPointer<ASTNode> const& node: sourceUnit->getNodes())
|
||||
if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
|
||||
resolver.resolveNamesAndTypes(*contract);
|
||||
}
|
||||
}
|
||||
|
||||
@ -224,6 +226,14 @@ BOOST_AUTO_TEST_CASE(type_inference_explicit_conversion)
|
||||
BOOST_CHECK_NO_THROW(parseTextAndResolveNames(text));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(large_string_literal)
|
||||
{
|
||||
char const* text = "contract test {\n"
|
||||
" function f() { var x = \"123456789012345678901234567890123\"; }"
|
||||
"}\n";
|
||||
BOOST_CHECK_THROW(parseTextAndResolveNames(text), TypeError);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(balance)
|
||||
{
|
||||
char const* text = "contract test {\n"
|
||||
|
488
solidityNatspecJSON.cpp
Normal file
488
solidityNatspecJSON.cpp
Normal file
@ -0,0 +1,488 @@
|
||||
/*
|
||||
This file is part of cpp-ethereum.
|
||||
|
||||
cpp-ethereum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
cpp-ethereum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
/**
|
||||
* @author Lefteris Karapetsas <lefteris@ethdev.com>
|
||||
* @date 2014
|
||||
* Unit tests for the solidity compiler JSON Interface output.
|
||||
*/
|
||||
|
||||
#include <boost/test/unit_test.hpp>
|
||||
#include <libsolidity/CompilerStack.h>
|
||||
#include <libsolidity/Exceptions.h>
|
||||
#include <jsonrpc/json/json.h>
|
||||
#include <libdevcore/Exceptions.h>
|
||||
|
||||
namespace dev
|
||||
{
|
||||
namespace solidity
|
||||
{
|
||||
namespace test
|
||||
{
|
||||
|
||||
class DocumentationChecker
|
||||
{
|
||||
public:
|
||||
void checkNatspec(std::string const& _code,
|
||||
std::string const& _expectedDocumentationString,
|
||||
bool _userDocumentation)
|
||||
{
|
||||
std::string generatedDocumentationString;
|
||||
try
|
||||
{
|
||||
m_compilerStack.parse(_code);
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
std::string const* extra = boost::get_error_info<errinfo_comment>(e);
|
||||
std::string msg = std::string("Parsing contract failed with: ") +
|
||||
e.what() + std::string("\n");
|
||||
if (extra)
|
||||
msg += *extra;
|
||||
BOOST_FAIL(msg);
|
||||
}
|
||||
|
||||
if (_userDocumentation)
|
||||
generatedDocumentationString = m_compilerStack.getJsonDocumentation("", DocumentationType::NATSPEC_USER);
|
||||
else
|
||||
generatedDocumentationString = m_compilerStack.getJsonDocumentation("", DocumentationType::NATSPEC_DEV);
|
||||
Json::Value generatedDocumentation;
|
||||
m_reader.parse(generatedDocumentationString, generatedDocumentation);
|
||||
Json::Value expectedDocumentation;
|
||||
m_reader.parse(_expectedDocumentationString, expectedDocumentation);
|
||||
BOOST_CHECK_MESSAGE(expectedDocumentation == generatedDocumentation,
|
||||
"Expected " << _expectedDocumentationString <<
|
||||
"\n but got:\n" << generatedDocumentationString);
|
||||
}
|
||||
|
||||
private:
|
||||
CompilerStack m_compilerStack;
|
||||
Json::Reader m_reader;
|
||||
};
|
||||
|
||||
BOOST_FIXTURE_TEST_SUITE(SolidityNatspecJSON, DocumentationChecker)
|
||||
|
||||
BOOST_AUTO_TEST_CASE(user_basic_test)
|
||||
{
|
||||
char const* sourceCode = "contract test {\n"
|
||||
" /// @notice Multiplies `a` by 7\n"
|
||||
" function mul(uint a) returns(uint d) { return a * 7; }\n"
|
||||
"}\n";
|
||||
|
||||
char const* natspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul\":{ \"notice\": \"Multiplies `a` by 7\"}"
|
||||
"}}";
|
||||
|
||||
checkNatspec(sourceCode, natspec, true);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(dev_and_user_basic_test)
|
||||
{
|
||||
char const* sourceCode = "contract test {\n"
|
||||
" /// @notice Multiplies `a` by 7\n"
|
||||
" /// @dev Multiplies a number by 7\n"
|
||||
" function mul(uint a) returns(uint d) { return a * 7; }\n"
|
||||
"}\n";
|
||||
|
||||
char const* devNatspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul\":{ \n"
|
||||
" \"details\": \"Multiplies a number by 7\"\n"
|
||||
" }\n"
|
||||
" }\n"
|
||||
"}}";
|
||||
|
||||
char const* userNatspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul\":{ \"notice\": \"Multiplies `a` by 7\"}"
|
||||
"}}";
|
||||
|
||||
checkNatspec(sourceCode, devNatspec, false);
|
||||
checkNatspec(sourceCode, userNatspec, true);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(user_multiline_comment)
|
||||
{
|
||||
char const* sourceCode = "contract test {\n"
|
||||
" /// @notice Multiplies `a` by 7\n"
|
||||
" /// and then adds `b`\n"
|
||||
" function mul_and_add(uint a, uint256 b) returns(uint256 d)\n"
|
||||
" {\n"
|
||||
" return (a * 7) + b;\n"
|
||||
" }\n"
|
||||
"}\n";
|
||||
|
||||
char const* natspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul_and_add\":{ \"notice\": \"Multiplies `a` by 7 and then adds `b`\"}"
|
||||
"}}";
|
||||
|
||||
checkNatspec(sourceCode, natspec, true);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(user_multiple_functions)
|
||||
{
|
||||
char const* sourceCode = "contract test {\n"
|
||||
" /// @notice Multiplies `a` by 7 and then adds `b`\n"
|
||||
" function mul_and_add(uint a, uint256 b) returns(uint256 d)\n"
|
||||
" {\n"
|
||||
" return (a * 7) + b;\n"
|
||||
" }\n"
|
||||
"\n"
|
||||
" /// @notice Divides `input` by `div`\n"
|
||||
" function divide(uint input, uint div) returns(uint d)\n"
|
||||
" {\n"
|
||||
" return input / div;\n"
|
||||
" }\n"
|
||||
" /// @notice Subtracts 3 from `input`\n"
|
||||
" function sub(int input) returns(int d)\n"
|
||||
" {\n"
|
||||
" return input - 3;\n"
|
||||
" }\n"
|
||||
"}\n";
|
||||
|
||||
char const* natspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul_and_add\":{ \"notice\": \"Multiplies `a` by 7 and then adds `b`\"},"
|
||||
" \"divide\":{ \"notice\": \"Divides `input` by `div`\"},"
|
||||
" \"sub\":{ \"notice\": \"Subtracts 3 from `input`\"}"
|
||||
"}}";
|
||||
|
||||
checkNatspec(sourceCode, natspec, true);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(user_empty_contract)
|
||||
{
|
||||
char const* sourceCode = "contract test {\n"
|
||||
"}\n";
|
||||
|
||||
char const* natspec = "{\"methods\":{} }";
|
||||
|
||||
checkNatspec(sourceCode, natspec, true);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(dev_and_user_no_doc)
|
||||
{
|
||||
char const* sourceCode = "contract test {\n"
|
||||
" function mul(uint a) returns(uint d) { return a * 7; }\n"
|
||||
" function sub(int input) returns(int d)\n"
|
||||
" {\n"
|
||||
" return input - 3;\n"
|
||||
" }\n"
|
||||
"}\n";
|
||||
|
||||
char const* devNatspec = "{\"methods\":{}}";
|
||||
|
||||
char const* userNatspec = "{\"methods\":{}}";
|
||||
|
||||
checkNatspec(sourceCode, devNatspec, false);
|
||||
checkNatspec(sourceCode, userNatspec, true);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(dev_desc_after_nl)
|
||||
{
|
||||
char const* sourceCode = "contract test {\n"
|
||||
" /// @dev\n"
|
||||
" /// Multiplies a number by 7 and adds second parameter\n"
|
||||
" /// @param a Documentation for the first parameter\n"
|
||||
" /// @param second Documentation for the second parameter\n"
|
||||
" function mul(uint a, uint second) returns(uint d) { return a * 7 + second; }\n"
|
||||
"}\n";
|
||||
|
||||
char const* natspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul\":{ \n"
|
||||
" \"details\": \" Multiplies a number by 7 and adds second parameter\",\n"
|
||||
" \"params\": {\n"
|
||||
" \"a\": \"Documentation for the first parameter\",\n"
|
||||
" \"second\": \"Documentation for the second parameter\"\n"
|
||||
" }\n"
|
||||
" }\n"
|
||||
"}}";
|
||||
|
||||
checkNatspec(sourceCode, natspec, false);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(dev_multiple_params)
|
||||
{
|
||||
char const* sourceCode = "contract test {\n"
|
||||
" /// @dev Multiplies a number by 7 and adds second parameter\n"
|
||||
" /// @param a Documentation for the first parameter\n"
|
||||
" /// @param second Documentation for the second parameter\n"
|
||||
" function mul(uint a, uint second) returns(uint d) { return a * 7 + second; }\n"
|
||||
"}\n";
|
||||
|
||||
char const* natspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul\":{ \n"
|
||||
" \"details\": \"Multiplies a number by 7 and adds second parameter\",\n"
|
||||
" \"params\": {\n"
|
||||
" \"a\": \"Documentation for the first parameter\",\n"
|
||||
" \"second\": \"Documentation for the second parameter\"\n"
|
||||
" }\n"
|
||||
" }\n"
|
||||
"}}";
|
||||
|
||||
checkNatspec(sourceCode, natspec, false);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(dev_mutiline_param_description)
|
||||
{
|
||||
char const* sourceCode = "contract test {\n"
|
||||
" /// @dev Multiplies a number by 7 and adds second parameter\n"
|
||||
" /// @param a Documentation for the first parameter starts here.\n"
|
||||
" /// Since it's a really complicated parameter we need 2 lines\n"
|
||||
" /// @param second Documentation for the second parameter\n"
|
||||
" function mul(uint a, uint second) returns(uint d) { return a * 7 + second; }\n"
|
||||
"}\n";
|
||||
|
||||
char const* natspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul\":{ \n"
|
||||
" \"details\": \"Multiplies a number by 7 and adds second parameter\",\n"
|
||||
" \"params\": {\n"
|
||||
" \"a\": \"Documentation for the first parameter starts here. Since it's a really complicated parameter we need 2 lines\",\n"
|
||||
" \"second\": \"Documentation for the second parameter\"\n"
|
||||
" }\n"
|
||||
" }\n"
|
||||
"}}";
|
||||
|
||||
checkNatspec(sourceCode, natspec, false);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(dev_multiple_functions)
|
||||
{
|
||||
char const* sourceCode = "contract test {\n"
|
||||
" /// @dev Multiplies a number by 7 and adds second parameter\n"
|
||||
" /// @param a Documentation for the first parameter\n"
|
||||
" /// @param second Documentation for the second parameter\n"
|
||||
" function mul(uint a, uint second) returns(uint d) { return a * 7 + second; }\n"
|
||||
" \n"
|
||||
" /// @dev Divides 2 numbers\n"
|
||||
" /// @param input Documentation for the input parameter\n"
|
||||
" /// @param div Documentation for the div parameter\n"
|
||||
" function divide(uint input, uint div) returns(uint d)\n"
|
||||
" {\n"
|
||||
" return input / div;\n"
|
||||
" }\n"
|
||||
" /// @dev Subtracts 3 from `input`\n"
|
||||
" /// @param input Documentation for the input parameter\n"
|
||||
" function sub(int input) returns(int d)\n"
|
||||
" {\n"
|
||||
" return input - 3;\n"
|
||||
" }\n"
|
||||
"}\n";
|
||||
|
||||
char const* natspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul\":{ \n"
|
||||
" \"details\": \"Multiplies a number by 7 and adds second parameter\",\n"
|
||||
" \"params\": {\n"
|
||||
" \"a\": \"Documentation for the first parameter\",\n"
|
||||
" \"second\": \"Documentation for the second parameter\"\n"
|
||||
" }\n"
|
||||
" },\n"
|
||||
" \"divide\":{ \n"
|
||||
" \"details\": \"Divides 2 numbers\",\n"
|
||||
" \"params\": {\n"
|
||||
" \"input\": \"Documentation for the input parameter\",\n"
|
||||
" \"div\": \"Documentation for the div parameter\"\n"
|
||||
" }\n"
|
||||
" },\n"
|
||||
" \"sub\":{ \n"
|
||||
" \"details\": \"Subtracts 3 from `input`\",\n"
|
||||
" \"params\": {\n"
|
||||
" \"input\": \"Documentation for the input parameter\"\n"
|
||||
" }\n"
|
||||
" }\n"
|
||||
"}}";
|
||||
|
||||
checkNatspec(sourceCode, natspec, false);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(dev_return)
|
||||
{
|
||||
char const* sourceCode = "contract test {\n"
|
||||
" /// @dev Multiplies a number by 7 and adds second parameter\n"
|
||||
" /// @param a Documentation for the first parameter starts here.\n"
|
||||
" /// Since it's a really complicated parameter we need 2 lines\n"
|
||||
" /// @param second Documentation for the second parameter\n"
|
||||
" /// @return The result of the multiplication\n"
|
||||
" function mul(uint a, uint second) returns(uint d) { return a * 7 + second; }\n"
|
||||
"}\n";
|
||||
|
||||
char const* natspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul\":{ \n"
|
||||
" \"details\": \"Multiplies a number by 7 and adds second parameter\",\n"
|
||||
" \"params\": {\n"
|
||||
" \"a\": \"Documentation for the first parameter starts here. Since it's a really complicated parameter we need 2 lines\",\n"
|
||||
" \"second\": \"Documentation for the second parameter\"\n"
|
||||
" },\n"
|
||||
" \"return\": \"The result of the multiplication\"\n"
|
||||
" }\n"
|
||||
"}}";
|
||||
|
||||
checkNatspec(sourceCode, natspec, false);
|
||||
}
|
||||
BOOST_AUTO_TEST_CASE(dev_return_desc_after_nl)
|
||||
{
|
||||
char const* sourceCode = "contract test {\n"
|
||||
" /// @dev Multiplies a number by 7 and adds second parameter\n"
|
||||
" /// @param a Documentation for the first parameter starts here.\n"
|
||||
" /// Since it's a really complicated parameter we need 2 lines\n"
|
||||
" /// @param second Documentation for the second parameter\n"
|
||||
" /// @return\n"
|
||||
" /// The result of the multiplication\n"
|
||||
" function mul(uint a, uint second) returns(uint d) { return a * 7 + second; }\n"
|
||||
"}\n";
|
||||
|
||||
char const* natspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul\":{ \n"
|
||||
" \"details\": \"Multiplies a number by 7 and adds second parameter\",\n"
|
||||
" \"params\": {\n"
|
||||
" \"a\": \"Documentation for the first parameter starts here. Since it's a really complicated parameter we need 2 lines\",\n"
|
||||
" \"second\": \"Documentation for the second parameter\"\n"
|
||||
" },\n"
|
||||
" \"return\": \" The result of the multiplication\"\n"
|
||||
" }\n"
|
||||
"}}";
|
||||
|
||||
checkNatspec(sourceCode, natspec, false);
|
||||
}
|
||||
|
||||
|
||||
BOOST_AUTO_TEST_CASE(dev_multiline_return)
|
||||
{
|
||||
char const* sourceCode = "contract test {\n"
|
||||
" /// @dev Multiplies a number by 7 and adds second parameter\n"
|
||||
" /// @param a Documentation for the first parameter starts here.\n"
|
||||
" /// Since it's a really complicated parameter we need 2 lines\n"
|
||||
" /// @param second Documentation for the second parameter\n"
|
||||
" /// @return The result of the multiplication\n"
|
||||
" /// and cookies with nutella\n"
|
||||
" function mul(uint a, uint second) returns(uint d) { return a * 7 + second; }\n"
|
||||
"}\n";
|
||||
|
||||
char const* natspec = "{"
|
||||
"\"methods\":{"
|
||||
" \"mul\":{ \n"
|
||||
" \"details\": \"Multiplies a number by 7 and adds second parameter\",\n"
|
||||
" \"params\": {\n"
|
||||
" \"a\": \"Documentation for the first parameter starts here. Since it's a really complicated parameter we need 2 lines\",\n"
|
||||
" \"second\": \"Documentation for the second parameter\"\n"
|
||||
" },\n"
|
||||
" \"return\": \"The result of the multiplication and cookies with nutella\"\n"
|
||||
" }\n"
|
||||
"}}";
|
||||
|
||||
checkNatspec(sourceCode, natspec, false);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(dev_contract_no_doc)
|
||||
{
|
||||
char const* sourceCode = "contract test {\n"
|
||||
" /// @dev Mul function\n"
|
||||
" function mul(uint a, uint second) returns(uint d) { return a * 7 + second; }\n"
|
||||
"}\n";
|
||||
|
||||
char const* natspec = "{"
|
||||
" \"methods\":{"
|
||||
" \"mul\":{ \n"
|
||||
" \"details\": \"Mul function\"\n"
|
||||
" }\n"
|
||||
" }\n"
|
||||
"}";
|
||||
|
||||
checkNatspec(sourceCode, natspec, false);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(dev_contract_doc)
|
||||
{
|
||||
char const* sourceCode = " /// @author Lefteris\n"
|
||||
" /// @title Just a test contract\n"
|
||||
"contract test {\n"
|
||||
" /// @dev Mul function\n"
|
||||
" function mul(uint a, uint second) returns(uint d) { return a * 7 + second; }\n"
|
||||
"}\n";
|
||||
|
||||
char const* natspec = "{"
|
||||
" \"author\": \"Lefteris\","
|
||||
" \"title\": \"Just a test contract\","
|
||||
" \"methods\":{"
|
||||
" \"mul\":{ \n"
|
||||
" \"details\": \"Mul function\"\n"
|
||||
" }\n"
|
||||
" }\n"
|
||||
"}";
|
||||
|
||||
checkNatspec(sourceCode, natspec, false);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(dev_author_at_function)
|
||||
{
|
||||
char const* sourceCode = " /// @author Lefteris\n"
|
||||
" /// @title Just a test contract\n"
|
||||
"contract test {\n"
|
||||
" /// @dev Mul function\n"
|
||||
" /// @author John Doe\n"
|
||||
" function mul(uint a, uint second) returns(uint d) { return a * 7 + second; }\n"
|
||||
"}\n";
|
||||
|
||||
char const* natspec = "{"
|
||||
" \"author\": \"Lefteris\","
|
||||
" \"title\": \"Just a test contract\","
|
||||
" \"methods\":{"
|
||||
" \"mul\":{ \n"
|
||||
" \"details\": \"Mul function\",\n"
|
||||
" \"author\": \"John Doe\",\n"
|
||||
" }\n"
|
||||
" }\n"
|
||||
"}";
|
||||
|
||||
checkNatspec(sourceCode, natspec, false);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(dev_title_at_function_error)
|
||||
{
|
||||
char const* sourceCode = " /// @author Lefteris\n"
|
||||
" /// @title Just a test contract\n"
|
||||
"contract test {\n"
|
||||
" /// @dev Mul function\n"
|
||||
" /// @title I really should not be here\n"
|
||||
" function mul(uint a, uint second) returns(uint d) { return a * 7 + second; }\n"
|
||||
"}\n";
|
||||
|
||||
char const* natspec = "{"
|
||||
" \"author\": \"Lefteris\","
|
||||
" \"title\": \"Just a test contract\","
|
||||
" \"methods\":{"
|
||||
" \"mul\":{ \n"
|
||||
" \"details\": \"Mul function\"\n"
|
||||
" }\n"
|
||||
" }\n"
|
||||
"}";
|
||||
|
||||
BOOST_CHECK_THROW(checkNatspec(sourceCode, natspec, false), DocstringParsingError);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
||||
}
|
||||
}
|
||||
}
|
146
solidityOptimizerTest.cpp
Normal file
146
solidityOptimizerTest.cpp
Normal file
@ -0,0 +1,146 @@
|
||||
|
||||
/*
|
||||
This file is part of cpp-ethereum.
|
||||
|
||||
cpp-ethereum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
cpp-ethereum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
/**
|
||||
* @author Christian <c@ethdev.com>
|
||||
* @date 2014
|
||||
* Tests for the Solidity optimizer.
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <tuple>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
#include <boost/lexical_cast.hpp>
|
||||
#include <test/solidityExecutionFramework.h>
|
||||
|
||||
using namespace std;
|
||||
|
||||
namespace dev
|
||||
{
|
||||
namespace solidity
|
||||
{
|
||||
namespace test
|
||||
{
|
||||
|
||||
class OptimizerTestFramework: public ExecutionFramework
|
||||
{
|
||||
public:
|
||||
OptimizerTestFramework() { }
|
||||
/// Compiles the source code with and without optimizing.
|
||||
void compileBothVersions(unsigned _expectedSizeDecrease, std::string const& _sourceCode, u256 const& _value = 0, std::string const& _contractName = "") {
|
||||
m_optimize = false;
|
||||
bytes nonOptimizedBytecode = compileAndRun(_sourceCode, _value, _contractName);
|
||||
m_nonOptimizedContract = m_contractAddress;
|
||||
m_optimize = true;
|
||||
bytes optimizedBytecode = compileAndRun(_sourceCode, _value, _contractName);
|
||||
int sizeDiff = nonOptimizedBytecode.size() - optimizedBytecode.size();
|
||||
BOOST_CHECK_MESSAGE(sizeDiff == int(_expectedSizeDecrease), "Bytecode did only shrink by "
|
||||
+ boost::lexical_cast<string>(sizeDiff) + " bytes, expected: "
|
||||
+ boost::lexical_cast<string>(_expectedSizeDecrease));
|
||||
m_optimizedContract = m_contractAddress;
|
||||
}
|
||||
|
||||
template <class... Args>
|
||||
void compareVersions(byte _index, Args const&... _arguments)
|
||||
{
|
||||
m_contractAddress = m_nonOptimizedContract;
|
||||
bytes nonOptimizedOutput = callContractFunction(_index, _arguments...);
|
||||
m_contractAddress = m_optimizedContract;
|
||||
bytes optimizedOutput = callContractFunction(_index, _arguments...);
|
||||
BOOST_CHECK_MESSAGE(nonOptimizedOutput == optimizedOutput, "Computed values do not match."
|
||||
"\nNon-Optimized: " + toHex(nonOptimizedOutput) +
|
||||
"\nOptimized: " + toHex(optimizedOutput));
|
||||
}
|
||||
|
||||
protected:
|
||||
Address m_optimizedContract;
|
||||
Address m_nonOptimizedContract;
|
||||
};
|
||||
|
||||
BOOST_FIXTURE_TEST_SUITE(SolidityOptimizerTest, OptimizerTestFramework)
|
||||
|
||||
BOOST_AUTO_TEST_CASE(smoke_test)
|
||||
{
|
||||
char const* sourceCode = R"(
|
||||
contract test {
|
||||
function f(uint a) returns (uint b) {
|
||||
return a;
|
||||
}
|
||||
})";
|
||||
compileBothVersions(4, sourceCode);
|
||||
compareVersions(0, u256(7));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(large_integers)
|
||||
{
|
||||
char const* sourceCode = R"(
|
||||
contract test {
|
||||
function f() returns (uint a, uint b) {
|
||||
a = 0x234234872642837426347000000;
|
||||
b = 0x110000000000000000000000002;
|
||||
}
|
||||
})";
|
||||
compileBothVersions(28, sourceCode);
|
||||
compareVersions(0);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(invariants)
|
||||
{
|
||||
char const* sourceCode = R"(
|
||||
contract test {
|
||||
function f(uint a) returns (uint b) {
|
||||
return (((a + (1 - 1)) ^ 0) | 0) & (uint(0) - 1);
|
||||
}
|
||||
})";
|
||||
compileBothVersions(28, sourceCode);
|
||||
compareVersions(0, u256(0x12334664));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(unused_expressions)
|
||||
{
|
||||
char const* sourceCode = R"(
|
||||
contract test {
|
||||
uint data;
|
||||
function f() returns (uint a, uint b) {
|
||||
10 + 20;
|
||||
data;
|
||||
}
|
||||
})";
|
||||
compileBothVersions(11, sourceCode);
|
||||
compareVersions(0);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(constant_folding_both_sides)
|
||||
{
|
||||
// if constants involving the same associative and commutative operator are applied from both
|
||||
// sides, the operator should be applied only once, because the expression compiler
|
||||
// (even in non-optimized mode) pushes literals as late as possible
|
||||
char const* sourceCode = R"(
|
||||
contract test {
|
||||
function f(uint x) returns (uint y) {
|
||||
return 98 ^ (7 * ((1 | (x | 1000)) * 40) ^ 102);
|
||||
}
|
||||
})";
|
||||
compileBothVersions(31, sourceCode);
|
||||
compareVersions(0);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
||||
}
|
||||
}
|
||||
} // end namespaces
|
@ -21,13 +21,15 @@
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
|
||||
#include <memory>
|
||||
#include <libdevcore/Log.h>
|
||||
#include <libsolidity/Scanner.h>
|
||||
#include <libsolidity/Parser.h>
|
||||
#include <libsolidity/Exceptions.h>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
namespace dev
|
||||
{
|
||||
namespace solidity
|
||||
@ -40,7 +42,12 @@ namespace
|
||||
ASTPointer<ContractDefinition> parseText(std::string const& _source)
|
||||
{
|
||||
Parser parser;
|
||||
return parser.parse(std::make_shared<Scanner>(CharStream(_source)));
|
||||
ASTPointer<SourceUnit> sourceUnit = parser.parse(std::make_shared<Scanner>(CharStream(_source)));
|
||||
for (ASTPointer<ASTNode> const& node: sourceUnit->getNodes())
|
||||
if (ASTPointer<ContractDefinition> contract = dynamic_pointer_cast<ContractDefinition>(node))
|
||||
return contract;
|
||||
BOOST_FAIL("No contract found in source.");
|
||||
return ASTPointer<ContractDefinition>();
|
||||
}
|
||||
}
|
||||
|
||||
@ -380,6 +387,50 @@ BOOST_AUTO_TEST_CASE(statement_starting_with_type_conversion)
|
||||
BOOST_CHECK_NO_THROW(parseText(text));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(import_directive)
|
||||
{
|
||||
char const* text = "import \"abc\";\n"
|
||||
"contract test {\n"
|
||||
" function fun() {\n"
|
||||
" uint64(2);\n"
|
||||
" }\n"
|
||||
"}\n";
|
||||
BOOST_CHECK_NO_THROW(parseText(text));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(multiple_contracts)
|
||||
{
|
||||
char const* text = "contract test {\n"
|
||||
" function fun() {\n"
|
||||
" uint64(2);\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"contract test2 {\n"
|
||||
" function fun() {\n"
|
||||
" uint64(2);\n"
|
||||
" }\n"
|
||||
"}\n";
|
||||
BOOST_CHECK_NO_THROW(parseText(text));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(multiple_contracts_and_imports)
|
||||
{
|
||||
char const* text = "import \"abc\";\n"
|
||||
"contract test {\n"
|
||||
" function fun() {\n"
|
||||
" uint64(2);\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"import \"def\";\n"
|
||||
"contract test2 {\n"
|
||||
" function fun() {\n"
|
||||
" uint64(2);\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"import \"ghi\";\n";
|
||||
BOOST_CHECK_NO_THROW(parseText(text));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
||||
}
|
||||
|
1851
stLogTestsFiller.json
Normal file
1851
stLogTestsFiller.json
Normal file
File diff suppressed because it is too large
Load Diff
@ -634,6 +634,86 @@
|
||||
}
|
||||
},
|
||||
|
||||
"CallRecursiveBombLog": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "10000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "20000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (CALL 100000 0x945304eb96065b2a98b57a48a06ae28d285a71b5 23 0 0 0 0) }",
|
||||
"storage": {}
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (MSTORE 0 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) (LOG0 0 32) [[ 0 ]] (+ (SLOAD 0) 1) [[ 1 ]] (CALL (- (GAS) 224) (ADDRESS) 0 0 0 0 0) } ",
|
||||
"storage": {}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"transaction" : {
|
||||
"nonce" : "0",
|
||||
"gasPrice" : "1",
|
||||
"gasLimit" : "1000000",
|
||||
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
|
||||
"value" : "100000",
|
||||
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
|
||||
"data" : ""
|
||||
}
|
||||
},
|
||||
|
||||
"CallRecursiveBombLog2": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "10000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
|
||||
"balance" : "20000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (CALL 100000 0x945304eb96065b2a98b57a48a06ae28d285a71b5 23 0 0 0 0) }",
|
||||
"storage": {}
|
||||
},
|
||||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (MSTORE 0 (GAS)) (LOG0 0 32) [[ 0 ]] (+ (SLOAD 0) 1) [[ 1 ]] (CALL (- (GAS) 224) (ADDRESS) 0 0 0 0 0) } ",
|
||||
"storage": {}
|
||||
},
|
||||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"transaction" : {
|
||||
"nonce" : "0",
|
||||
"gasPrice" : "1",
|
||||
"gasLimit" : "1000000",
|
||||
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
|
||||
"value" : "100000",
|
||||
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
|
||||
"data" : ""
|
||||
}
|
||||
},
|
||||
|
||||
"CallRecursiveBomb1": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
|
@ -45,7 +45,7 @@ void doStateTests(json_spirit::mValue& v, bool _fillin)
|
||||
{
|
||||
for (auto& i: v.get_obj())
|
||||
{
|
||||
cnote << i.first;
|
||||
cerr << i.first << endl;
|
||||
mObject& o = i.second.get_obj();
|
||||
|
||||
BOOST_REQUIRE(o.count("env") > 0);
|
||||
@ -125,6 +125,11 @@ BOOST_AUTO_TEST_CASE(stPreCompiledContracts)
|
||||
dev::test::executeTests("stPreCompiledContracts", "/StateTests", dev::test::doStateTests);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(stLogTests)
|
||||
{
|
||||
dev::test::executeTests("stLogTests", "/StateTests", dev::test::doStateTests);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(stSpecialTest)
|
||||
{
|
||||
dev::test::executeTests("stSpecialTest", "/StateTests", dev::test::doStateTests);
|
||||
|
10
trie.cpp
10
trie.cpp
@ -54,13 +54,12 @@ BOOST_AUTO_TEST_CASE(trie_tests)
|
||||
{
|
||||
string testPath = test::getTestPath();
|
||||
|
||||
|
||||
testPath += "/TrieTests";
|
||||
|
||||
cnote << "Testing Trie...";
|
||||
js::mValue v;
|
||||
string s = asString(contents(testPath + "/trietest.json"));
|
||||
BOOST_REQUIRE_MESSAGE(s.length() > 0, "Contents of 'trietest.json' is empty. Have you cloned the 'tests' repo branch develop?");
|
||||
string s = asString(contents(testPath + "/trieanyorder.json"));
|
||||
BOOST_REQUIRE_MESSAGE(s.length() > 0, "Contents of 'trieanyorder.json' is empty. Have you cloned the 'tests' repo branch develop?");
|
||||
js::read_string(s, v);
|
||||
for (auto& i: v.get_obj())
|
||||
{
|
||||
@ -88,12 +87,11 @@ BOOST_AUTO_TEST_CASE(trie_tests)
|
||||
BOOST_REQUIRE(t.check(true));
|
||||
}
|
||||
BOOST_REQUIRE(!o["root"].is_null());
|
||||
BOOST_CHECK_EQUAL(o["root"].get_str(), toHex(t.root().asArray()));
|
||||
BOOST_CHECK_EQUAL(o["root"].get_str(), "0x" + toHex(t.root().asArray()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
inline h256 stringMapHash256(StringMap const& _s)
|
||||
{
|
||||
return hash256(_s);
|
||||
@ -246,6 +244,7 @@ BOOST_AUTO_TEST_CASE(moreTrieTests)
|
||||
BOOST_AUTO_TEST_CASE(trieLowerBound)
|
||||
{
|
||||
cnote << "Stress-testing Trie.lower_bound...";
|
||||
if (0)
|
||||
{
|
||||
MemoryDB dm;
|
||||
EnforceRefs e(dm, true);
|
||||
@ -291,6 +290,7 @@ BOOST_AUTO_TEST_CASE(trieLowerBound)
|
||||
BOOST_AUTO_TEST_CASE(trieStess)
|
||||
{
|
||||
cnote << "Stress-testing Trie...";
|
||||
if (0)
|
||||
{
|
||||
MemoryDB m;
|
||||
MemoryDB dm;
|
||||
|
62
vm.cpp
62
vm.cpp
@ -21,6 +21,8 @@
|
||||
*/
|
||||
|
||||
#include <boost/filesystem.hpp>
|
||||
#include <libethereum/Executive.h>
|
||||
#include <libevm/VMFactory.h>
|
||||
#include "vm.h"
|
||||
|
||||
using namespace std;
|
||||
@ -32,18 +34,18 @@ using namespace dev::test;
|
||||
FakeExtVM::FakeExtVM(eth::BlockInfo const& _previousBlock, eth::BlockInfo const& _currentBlock, unsigned _depth): /// TODO: XXX: remove the default argument & fix.
|
||||
ExtVMFace(Address(), Address(), Address(), 0, 1, bytesConstRef(), bytes(), _previousBlock, _currentBlock, _depth) {}
|
||||
|
||||
h160 FakeExtVM::create(u256 _endowment, u256* _gas, bytesConstRef _init, OnOpFunc const&)
|
||||
h160 FakeExtVM::create(u256 _endowment, u256& io_gas, bytesConstRef _init, OnOpFunc const&)
|
||||
{
|
||||
Address na = right160(sha3(rlpList(myAddress, get<1>(addresses[myAddress]))));
|
||||
|
||||
Transaction t(_endowment, gasPrice, *_gas, _init.toBytes());
|
||||
Transaction t(_endowment, gasPrice, io_gas, _init.toBytes());
|
||||
callcreates.push_back(t);
|
||||
return na;
|
||||
}
|
||||
|
||||
bool FakeExtVM::call(Address _receiveAddress, u256 _value, bytesConstRef _data, u256* _gas, bytesRef _out, OnOpFunc const&, Address _myAddressOverride, Address _codeAddressOverride)
|
||||
bool FakeExtVM::call(Address _receiveAddress, u256 _value, bytesConstRef _data, u256& io_gas, bytesRef _out, OnOpFunc const&, Address _myAddressOverride, Address _codeAddressOverride)
|
||||
{
|
||||
Transaction t(_value, gasPrice, *_gas, _receiveAddress, _data.toVector());
|
||||
Transaction t(_value, gasPrice, io_gas, _receiveAddress, _data.toVector());
|
||||
callcreates.push_back(t);
|
||||
(void)_out;
|
||||
(void)_myAddressOverride;
|
||||
@ -120,41 +122,6 @@ void FakeExtVM::importEnv(mObject& _o)
|
||||
currentBlock.coinbaseAddress = Address(_o["currentCoinbase"].get_str());
|
||||
}
|
||||
|
||||
mObject FakeExtVM::exportLog()
|
||||
{
|
||||
mObject ret;
|
||||
for (LogEntry const& l: sub.logs)
|
||||
{
|
||||
mObject o;
|
||||
o["address"] = toString(l.address);
|
||||
mArray topics;
|
||||
for (auto const& t: l.topics)
|
||||
topics.push_back(toString(t));
|
||||
o["topics"] = topics;
|
||||
o["data"] = "0x" + toHex(l.data);
|
||||
ret[toString(l.bloom())] = o;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void FakeExtVM::importLog(mObject& _o)
|
||||
{
|
||||
for (auto const& l: _o)
|
||||
{
|
||||
mObject o = l.second.get_obj();
|
||||
// cant use BOOST_REQUIRE, because this function is used outside boost test (createRandomTest)
|
||||
assert(o.count("address") > 0);
|
||||
assert(o.count("topics") > 0);
|
||||
assert(o.count("data") > 0);
|
||||
LogEntry log;
|
||||
log.address = Address(o["address"].get_str());
|
||||
for (auto const& t: o["topics"].get_array())
|
||||
log.topics.push_back(h256(t.get_str()));
|
||||
log.data = importData(o);
|
||||
sub.logs.push_back(log);
|
||||
}
|
||||
}
|
||||
|
||||
mObject FakeExtVM::exportState()
|
||||
{
|
||||
mObject ret;
|
||||
@ -276,10 +243,11 @@ void FakeExtVM::importCallCreates(mArray& _callcreates)
|
||||
|
||||
eth::OnOpFunc FakeExtVM::simpleTrace()
|
||||
{
|
||||
return [](uint64_t steps, eth::Instruction inst, bigint newMemSize, bigint gasCost, void* voidVM, void const* voidExt)
|
||||
|
||||
return [](uint64_t steps, eth::Instruction inst, bigint newMemSize, bigint gasCost, dev::eth::VM* voidVM, dev::eth::ExtVMFace const* voidExt)
|
||||
{
|
||||
FakeExtVM const& ext = *(FakeExtVM const*)voidExt;
|
||||
eth::VM& vm = *(eth::VM*)voidVM;
|
||||
FakeExtVM const& ext = *static_cast<FakeExtVM const*>(voidExt);
|
||||
eth::VM& vm = *voidVM;
|
||||
|
||||
std::ostringstream o;
|
||||
o << std::endl << " STACK" << std::endl;
|
||||
@ -332,14 +300,14 @@ void doVMTests(json_spirit::mValue& v, bool _fillin)
|
||||
}
|
||||
|
||||
bytes output;
|
||||
VM vm(fev.gas);
|
||||
auto vm = eth::VMFactory::create(fev.gas);
|
||||
|
||||
u256 gas;
|
||||
bool vmExceptionOccured = false;
|
||||
try
|
||||
{
|
||||
output = vm.go(fev, fev.simpleTrace()).toBytes();
|
||||
gas = vm.gas();
|
||||
output = vm->go(fev, fev.simpleTrace()).toBytes();
|
||||
gas = vm->gas();
|
||||
}
|
||||
catch (VMException const& _e)
|
||||
{
|
||||
@ -384,7 +352,7 @@ void doVMTests(json_spirit::mValue& v, bool _fillin)
|
||||
o["callcreates"] = fev.exportCallCreates();
|
||||
o["out"] = "0x" + toHex(output);
|
||||
fev.push(o, "gas", gas);
|
||||
o["logs"] = mValue(exportLog(fev.sub.logs));
|
||||
o["logs"] = exportLog(fev.sub.logs);
|
||||
}
|
||||
}
|
||||
else
|
||||
@ -402,7 +370,7 @@ void doVMTests(json_spirit::mValue& v, bool _fillin)
|
||||
dev::test::FakeExtVM test;
|
||||
test.importState(o["post"].get_obj());
|
||||
test.importCallCreates(o["callcreates"].get_array());
|
||||
test.sub.logs = importLog(o["logs"].get_obj());
|
||||
test.sub.logs = importLog(o["logs"].get_array());
|
||||
|
||||
checkOutput(output, o);
|
||||
|
||||
|
9
vm.h
9
vm.h
@ -55,8 +55,8 @@ public:
|
||||
virtual u256 txCount(Address _a) override { return std::get<1>(addresses[_a]); }
|
||||
virtual void suicide(Address _a) override { std::get<0>(addresses[_a]) += std::get<0>(addresses[myAddress]); addresses.erase(myAddress); }
|
||||
virtual bytes const& codeAt(Address _a) override { return std::get<3>(addresses[_a]); }
|
||||
virtual h160 create(u256 _endowment, u256* _gas, bytesConstRef _init, eth::OnOpFunc const&) override;
|
||||
virtual bool call(Address _receiveAddress, u256 _value, bytesConstRef _data, u256* _gas, bytesRef _out, eth::OnOpFunc const&, Address, Address) override;
|
||||
virtual h160 create(u256 _endowment, u256& io_gas, bytesConstRef _init, eth::OnOpFunc const&) override;
|
||||
virtual bool call(Address _receiveAddress, u256 _value, bytesConstRef _data, u256& io_gas, bytesRef _out, eth::OnOpFunc const&, Address, Address) override;
|
||||
void setTransaction(Address _caller, u256 _value, u256 _gasPrice, bytes const& _data);
|
||||
void setContract(Address _myAddress, u256 _myBalance, u256 _myNonce, std::map<u256, u256> const& _storage, bytes const& _code);
|
||||
void set(Address _a, u256 _myBalance, u256 _myNonce, std::map<u256, u256> const& _storage, bytes const& _code);
|
||||
@ -72,8 +72,6 @@ public:
|
||||
void importExec(json_spirit::mObject& _o);
|
||||
json_spirit::mArray exportCallCreates();
|
||||
void importCallCreates(json_spirit::mArray& _callcreates);
|
||||
json_spirit::mObject exportLog();
|
||||
void importLog(json_spirit::mObject& _o);
|
||||
|
||||
eth::OnOpFunc simpleTrace();
|
||||
|
||||
@ -82,9 +80,6 @@ public:
|
||||
bytes thisTxData;
|
||||
bytes thisTxCode;
|
||||
u256 gas;
|
||||
|
||||
private:
|
||||
eth::Manifest m_ms;
|
||||
};
|
||||
|
||||
|
||||
|
@ -55,6 +55,34 @@
|
||||
}
|
||||
},
|
||||
|
||||
"log_2logs": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
"currentNumber" : "0",
|
||||
"currentGasLimit" : "1000000",
|
||||
"currentDifficulty" : "256",
|
||||
"currentTimestamp" : 1,
|
||||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
|
||||
},
|
||||
"pre" : {
|
||||
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
|
||||
"balance" : "1000000000000000000",
|
||||
"nonce" : 0,
|
||||
"code" : "{ (MSTORE 0 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) (LOG0 0 32) (LOG0 2 16) }",
|
||||
"storage": {}
|
||||
}
|
||||
},
|
||||
"exec" : {
|
||||
"address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
|
||||
"origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
|
||||
"value" : "1000000000000000000",
|
||||
"data" : "",
|
||||
"gasPrice" : "100000000000000",
|
||||
"gas" : "10000"
|
||||
}
|
||||
},
|
||||
|
||||
"log0_nonEmptyMem_logMemSize1": {
|
||||
"env" : {
|
||||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
|
||||
|
@ -32,6 +32,8 @@ BOOST_AUTO_TEST_SUITE(whisper)
|
||||
|
||||
BOOST_AUTO_TEST_CASE(topic)
|
||||
{
|
||||
cnote << "Testing Whisper...";
|
||||
auto oldLogVerbosity = g_logVerbosity;
|
||||
g_logVerbosity = 0;
|
||||
|
||||
bool started = false;
|
||||
@ -40,16 +42,16 @@ BOOST_AUTO_TEST_CASE(topic)
|
||||
{
|
||||
setThreadName("other");
|
||||
|
||||
Host ph("Test", NetworkPreferences(30303, "", false, true));
|
||||
Host ph("Test", NetworkPreferences(50303, "", false, true));
|
||||
auto wh = ph.registerCapability(new WhisperHost());
|
||||
ph.start();
|
||||
|
||||
started = true;
|
||||
|
||||
/// Only interested in odd packets
|
||||
auto w = wh->installWatch(BuildTopicMask()("odd"));
|
||||
auto w = wh->installWatch(BuildTopicMask("odd"));
|
||||
|
||||
for (int i = 0, last = 0; i < 100 && last < 81; ++i)
|
||||
for (int i = 0, last = 0; i < 200 && last < 81; ++i)
|
||||
{
|
||||
for (auto i: wh->checkWatch(w))
|
||||
{
|
||||
@ -65,10 +67,12 @@ BOOST_AUTO_TEST_CASE(topic)
|
||||
while (!started)
|
||||
this_thread::sleep_for(chrono::milliseconds(50));
|
||||
|
||||
Host ph("Test", NetworkPreferences(30300, "", false, true));
|
||||
Host ph("Test", NetworkPreferences(50300, "", false, true));
|
||||
auto wh = ph.registerCapability(new WhisperHost());
|
||||
this_thread::sleep_for(chrono::milliseconds(500));
|
||||
ph.start();
|
||||
ph.connect("127.0.0.1", 30303);
|
||||
this_thread::sleep_for(chrono::milliseconds(500));
|
||||
ph.connect("127.0.0.1", 50303);
|
||||
|
||||
KeyPair us = KeyPair::create();
|
||||
for (int i = 0; i < 10; ++i)
|
||||
@ -78,6 +82,8 @@ BOOST_AUTO_TEST_CASE(topic)
|
||||
}
|
||||
|
||||
listener.join();
|
||||
g_logVerbosity = oldLogVerbosity;
|
||||
|
||||
BOOST_REQUIRE_EQUAL(result, 1 + 9 + 25 + 49 + 81);
|
||||
}
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user