From 3ec0bb5bfa986bb38c9a3d7a5a2dc43f3a3a9c15 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Mon, 21 Nov 2016 22:20:13 +0000 Subject: [PATCH 01/12] LLL: parseLLL to return empty string on failure --- liblll/Compiler.cpp | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/liblll/Compiler.cpp b/liblll/Compiler.cpp index 4008022f8..0cec7bc8f 100644 --- a/liblll/Compiler.cpp +++ b/liblll/Compiler.cpp @@ -99,14 +99,15 @@ std::string dev::eth::compileLLLToAsm(std::string const& _src, bool _opt, std::v string dev::eth::parseLLL(string const& _src) { - sp::utree o; try { + sp::utree o; parseTreeLLL(_src, o); + ostringstream ret; + debugOutAST(ret, o); + killBigints(o); + return ret.str(); } catch (...) {} - ostringstream ret; - debugOutAST(ret, o); - killBigints(o); - return ret.str(); + return string(); } From 69eb0ab5e3975e039c42a01bc6dd6657d4706022 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Mon, 21 Nov 2016 22:21:13 +0000 Subject: [PATCH 02/12] LLL: add parser tests --- test/liblll/Parser.cpp | 179 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 179 insertions(+) create mode 100644 test/liblll/Parser.cpp diff --git a/test/liblll/Parser.cpp b/test/liblll/Parser.cpp new file mode 100644 index 000000000..fc91f3c54 --- /dev/null +++ b/test/liblll/Parser.cpp @@ -0,0 +1,179 @@ +/* + This file is part of solidity. + + solidity 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. + + solidity 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 solidity. If not, see . +*/ +/** + * @author Alex Beregszaszi + * @date 2016 + * Unit tests for the LLL parser. + */ + +#include +#include +#include +#include + +using namespace std; + +namespace dev +{ +namespace lll +{ +namespace test +{ + +namespace +{ + +bool successParse(std::string const& _source) +{ + std::string ret = eth::parseLLL(_source); + return ret.size() != 0; +} + +std::string parse(std::string const& _source) +{ + return eth::parseLLL(_source); +} + +} + +BOOST_AUTO_TEST_SUITE(LLLParser) + +BOOST_AUTO_TEST_CASE(smoke_test) +{ + char const* text = "1"; + BOOST_CHECK(successParse(text)); +} + +BOOST_AUTO_TEST_CASE(string) +{ + char const* text = "\"string\""; + BOOST_CHECK(successParse(text)); + BOOST_CHECK_EQUAL(parse(text), R"("string")"); +} + +BOOST_AUTO_TEST_CASE(symbol) +{ + char const* text = "symbol"; + BOOST_CHECK(successParse(text)); + BOOST_CHECK_EQUAL(parse(text), R"(symbol)"); + + BOOST_CHECK(successParse("'symbol")); + BOOST_CHECK_EQUAL(parse(text), R"(symbol)"); +} + +BOOST_AUTO_TEST_CASE(decimals) +{ + char const* text = "1234"; + BOOST_CHECK(successParse(text)); + BOOST_CHECK_EQUAL(parse(text), R"(1234)"); +} + +BOOST_AUTO_TEST_CASE(hexadecimals) +{ + char const* text = "0x1234"; + BOOST_CHECK(successParse(text)); + BOOST_CHECK_EQUAL(parse(text), R"(4660)"); +} + +BOOST_AUTO_TEST_CASE(sequence) +{ + char const* text = "{ 1234 }"; + BOOST_CHECK(successParse(text)); + BOOST_CHECK_EQUAL(parse(text), R"({ 1234 })"); +} + +BOOST_AUTO_TEST_CASE(empty_sequence) +{ + char const* text = "{}"; + BOOST_CHECK(successParse(text)); + BOOST_CHECK_EQUAL(parse(text), R"({ })"); +} + +BOOST_AUTO_TEST_CASE(mload) +{ + char const* text = "@0"; + BOOST_CHECK(successParse(text)); + BOOST_CHECK_EQUAL(parse(text), R"(@ 0)"); + + BOOST_CHECK(successParse("@0x0")); + BOOST_CHECK(successParse("@symbol")); + BOOST_CHECK(!successParse("@")); +} + +BOOST_AUTO_TEST_CASE(sload) +{ + char const* text = "@@0"; + BOOST_CHECK(successParse(text)); + BOOST_CHECK_EQUAL(parse(text), R"(@@ 0)"); + + BOOST_CHECK(successParse("@@0x0")); + BOOST_CHECK(successParse("@@symbol")); + BOOST_CHECK(!successParse("@@")); +} + +BOOST_AUTO_TEST_CASE(mstore) +{ + char const* text = "[0]:0"; + BOOST_CHECK(successParse(text)); + BOOST_CHECK_EQUAL(parse(text), R"([ 0 ] 0)"); + + BOOST_CHECK(successParse("[0] 0")); + BOOST_CHECK(successParse("[0x0]:0x0")); + BOOST_CHECK(successParse("[symbol]:symbol")); + BOOST_CHECK(!successParse("[]")); + BOOST_CHECK(!successParse("[0]")); +} + +BOOST_AUTO_TEST_CASE(sstore) +{ + char const* text = "[[0]]:0"; + BOOST_CHECK(successParse(text)); + BOOST_CHECK_EQUAL(parse(text), R"([[ 0 ]] 0)"); + + BOOST_CHECK(successParse("[[0]] 0")); + BOOST_CHECK(successParse("[[0x0]]:0x0")); + BOOST_CHECK(successParse("[[symbol]]:symbol")); + BOOST_CHECK(!successParse("[[]]")); + BOOST_CHECK(!successParse("[[0x0]]")); +} + +BOOST_AUTO_TEST_CASE(calldataload) +{ + char const* text = "$0"; + BOOST_CHECK(successParse(text)); + BOOST_CHECK_EQUAL(parse(text), R"($ 0)"); + + BOOST_CHECK(successParse("$0x0")); + BOOST_CHECK(successParse("$symbol")); + BOOST_CHECK(!successParse("$")); +} + +BOOST_AUTO_TEST_CASE(list) +{ + char const* text = "( 1234 )"; + BOOST_CHECK(successParse(text)); + BOOST_CHECK_EQUAL(parse(text), R"(( 1234 ))"); + + BOOST_CHECK(successParse("( 1234 5467 )")); + BOOST_CHECK(successParse("()")); +} + +BOOST_AUTO_TEST_SUITE_END() + +} +} +} // end namespaces From 4af30cc5183d83afd8a112bbc29e5c7beb3b7c1a Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Sun, 27 Nov 2016 23:19:10 +0000 Subject: [PATCH 03/12] Add test/liblll to cmake --- test/CMakeLists.txt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 33af9981e..609aaab36 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -5,6 +5,7 @@ aux_source_directory(libdevcore SRC_LIST) aux_source_directory(libevmasm SRC_LIST) aux_source_directory(libsolidity SRC_LIST) aux_source_directory(contracts SRC_LIST) +aux_source_directory(liblll SRC_LIST) get_filename_component(TESTS_DIR "${CMAKE_CURRENT_SOURCE_DIR}" ABSOLUTE) @@ -28,7 +29,7 @@ file(GLOB HEADERS "*.h" "*/*.h") set(EXECUTABLE soltest) eth_simple_add_executable(${EXECUTABLE} ${SRC_LIST} ${HEADERS}) -eth_use(${EXECUTABLE} REQUIRED Solidity::solidity) +eth_use(${EXECUTABLE} REQUIRED Solidity::solidity Solidity::lll) include_directories(BEFORE ..) target_link_libraries(${EXECUTABLE} ${Boost_UNIT_TEST_FRAMEWORK_LIBRARIES}) From a226db73384ac1b588e07a28dd8f1ff92cbdf6f7 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Mon, 28 Nov 2016 00:21:01 +0000 Subject: [PATCH 04/12] Split out Solidity-specific part of ExecutionFramework --- test/ExecutionFramework.cpp | 137 +++++++++ test/ExecutionFramework.h | 288 ++++++++++++++++++ test/contracts/AuctionRegistrar.cpp | 6 +- test/contracts/FixedFeeRegistrar.cpp | 2 +- test/contracts/Wallet.cpp | 2 +- test/libsolidity/GasMeter.cpp | 2 +- test/libsolidity/SolidityEndToEndTest.cpp | 3 +- .../SolidityExecutionFramework.cpp | 106 +------ test/libsolidity/SolidityExecutionFramework.h | 242 +-------------- test/libsolidity/SolidityOptimizer.cpp | 2 +- 10 files changed, 441 insertions(+), 349 deletions(-) create mode 100644 test/ExecutionFramework.cpp create mode 100644 test/ExecutionFramework.h diff --git a/test/ExecutionFramework.cpp b/test/ExecutionFramework.cpp new file mode 100644 index 000000000..4ae504626 --- /dev/null +++ b/test/ExecutionFramework.cpp @@ -0,0 +1,137 @@ +/* + This file is part of solidity. + + solidity 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. + + solidity 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 solidity. If not, see . +*/ +/** + * @author Christian + * @date 2016 + * Framework for executing contracts and testing them using RPC. + */ + +#include +#include +#include +#include + +using namespace std; +using namespace dev; +using namespace dev::solidity; +using namespace dev::solidity::test; + +namespace // anonymous +{ + h256 const EmptyTrie("0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"); +} + +string getIPCSocketPath() +{ + string ipcPath = dev::test::Options::get().ipcPath; + if (ipcPath.empty()) + BOOST_FAIL("ERROR: ipcPath not set! (use --ipcpath or the environment variable ETH_TEST_IPC)"); + + return ipcPath; +} + +ExecutionFramework::ExecutionFramework() : + m_rpc(RPCSession::instance(getIPCSocketPath())), + m_optimize(dev::test::Options::get().optimize), + m_sender(m_rpc.account(0)) +{ + m_rpc.test_rewindToBlock(0); +} + +void ExecutionFramework::sendMessage(bytes const& _data, bool _isCreation, u256 const& _value) +{ + RPCSession::TransactionData d; + d.data = "0x" + toHex(_data); + d.from = "0x" + toString(m_sender); + d.gas = toHex(m_gas, HexPrefix::Add); + d.gasPrice = toHex(m_gasPrice, HexPrefix::Add); + d.value = toHex(_value, HexPrefix::Add); + if (!_isCreation) + { + d.to = dev::toString(m_contractAddress); + BOOST_REQUIRE(m_rpc.eth_getCode(d.to, "latest").size() > 2); + // Use eth_call to get the output + m_output = fromHex(m_rpc.eth_call(d, "latest"), WhenError::Throw); + } + + string txHash = m_rpc.eth_sendTransaction(d); + m_rpc.test_mineBlocks(1); + RPCSession::TransactionReceipt receipt(m_rpc.eth_getTransactionReceipt(txHash)); + + if (_isCreation) + { + m_contractAddress = Address(receipt.contractAddress); + BOOST_REQUIRE(m_contractAddress); + string code = m_rpc.eth_getCode(receipt.contractAddress, "latest"); + m_output = fromHex(code, WhenError::Throw); + } + + m_gasUsed = u256(receipt.gasUsed); + m_logs.clear(); + for (auto const& log: receipt.logEntries) + { + LogEntry entry; + entry.address = Address(log.address); + for (auto const& topic: log.topics) + entry.topics.push_back(h256(topic)); + entry.data = fromHex(log.data, WhenError::Throw); + m_logs.push_back(entry); + } +} + +void ExecutionFramework::sendEther(Address const& _to, u256 const& _value) +{ + RPCSession::TransactionData d; + d.data = "0x"; + d.from = "0x" + toString(m_sender); + d.gas = toHex(m_gas, HexPrefix::Add); + d.gasPrice = toHex(m_gasPrice, HexPrefix::Add); + d.value = toHex(_value, HexPrefix::Add); + d.to = dev::toString(_to); + + string txHash = m_rpc.eth_sendTransaction(d); + m_rpc.test_mineBlocks(1); +} + +size_t ExecutionFramework::currentTimestamp() +{ + auto latestBlock = m_rpc.rpcCall("eth_getBlockByNumber", {"\"latest\"", "false"}); + return size_t(u256(latestBlock.get("timestamp", "invalid").asString())); +} + +Address ExecutionFramework::account(size_t _i) +{ + return Address(m_rpc.accountCreateIfNotExists(_i)); +} + +bool ExecutionFramework::addressHasCode(Address const& _addr) +{ + string code = m_rpc.eth_getCode(toString(_addr), "latest"); + return !code.empty() && code != "0x"; +} + +u256 ExecutionFramework::balanceAt(Address const& _addr) +{ + return u256(m_rpc.eth_getBalance(toString(_addr), "latest")); +} + +bool ExecutionFramework::storageEmpty(Address const& _addr) +{ + h256 root(m_rpc.eth_getStorageRoot(toString(_addr), "latest")); + BOOST_CHECK(root); + return root == EmptyTrie; +} diff --git a/test/ExecutionFramework.h b/test/ExecutionFramework.h new file mode 100644 index 000000000..e487b1061 --- /dev/null +++ b/test/ExecutionFramework.h @@ -0,0 +1,288 @@ +/* + This file is part of solidity. + + solidity 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. + + solidity 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 solidity. If not, see . +*/ +/** + * @author Christian + * @date 2014 + * Framework for executing contracts and testing them using RPC. + */ + +#pragma once + +#include + +#include "TestHelper.h" +#include "RPCSession.h" + +#include +#include + +namespace dev +{ +namespace solidity +{ + using rational = boost::rational; + /// An Ethereum address: 20 bytes. + /// @NOTE This is not endian-specific; it's just a bunch of bytes. + using Address = h160; + + // The various denominations; here for ease of use where needed within code. + static const u256 ether = exp10<18>(); + static const u256 finney = exp10<15>(); + static const u256 szabo = exp10<12>(); + static const u256 shannon = exp10<9>(); + static const u256 wei = exp10<0>(); + +namespace test +{ + +class ExecutionFramework +{ + +public: + ExecutionFramework(); + + virtual bytes const& compileAndRunWithoutCheck( + std::string const& _sourceCode, + u256 const& _value = 0, + std::string const& _contractName = "", + bytes const& _arguments = bytes(), + std::map const& _libraryAddresses = std::map() + ) = 0; + + bytes const& compileAndRun( + std::string const& _sourceCode, + u256 const& _value = 0, + std::string const& _contractName = "", + bytes const& _arguments = bytes(), + std::map const& _libraryAddresses = std::map() + ) + { + compileAndRunWithoutCheck(_sourceCode, _value, _contractName, _arguments, _libraryAddresses); + BOOST_REQUIRE(!m_output.empty()); + return m_output; + } + + template + bytes const& callContractFunctionWithValue(std::string _sig, u256 const& _value, Args const&... _arguments) + { + FixedHash<4> hash(dev::keccak256(_sig)); + sendMessage(hash.asBytes() + encodeArgs(_arguments...), false, _value); + return m_output; + } + + template + bytes const& callContractFunction(std::string _sig, Args const&... _arguments) + { + return callContractFunctionWithValue(_sig, 0, _arguments...); + } + + template + void testSolidityAgainstCpp(std::string _sig, CppFunction const& _cppFunction, Args const&... _arguments) + { + bytes solidityResult = callContractFunction(_sig, _arguments...); + bytes cppResult = callCppAndEncodeResult(_cppFunction, _arguments...); + BOOST_CHECK_MESSAGE( + solidityResult == cppResult, + "Computed values do not match.\nSolidity: " + + toHex(solidityResult) + + "\nC++: " + + toHex(cppResult) + ); + } + + template + void testSolidityAgainstCppOnRange(std::string _sig, CppFunction const& _cppFunction, u256 const& _rangeStart, u256 const& _rangeEnd) + { + for (u256 argument = _rangeStart; argument < _rangeEnd; ++argument) + { + bytes solidityResult = callContractFunction(_sig, argument); + bytes cppResult = callCppAndEncodeResult(_cppFunction, argument); + BOOST_CHECK_MESSAGE( + solidityResult == cppResult, + "Computed values do not match.\nSolidity: " + + toHex(solidityResult) + + "\nC++: " + + toHex(cppResult) + + "\nArgument: " + + toHex(encode(argument)) + ); + } + } + + static bytes encode(bool _value) { return encode(byte(_value)); } + static bytes encode(int _value) { return encode(u256(_value)); } + static bytes encode(size_t _value) { return encode(u256(_value)); } + static bytes encode(char const* _value) { return encode(std::string(_value)); } + static bytes encode(byte _value) { return bytes(31, 0) + bytes{_value}; } + static bytes encode(u256 const& _value) { return toBigEndian(_value); } + /// @returns the fixed-point encoding of a rational number with a given + /// number of fractional bits. + static bytes encode(std::pair const& _valueAndPrecision) + { + rational const& value = _valueAndPrecision.first; + int fractionalBits = _valueAndPrecision.second; + return encode(u256((value.numerator() << fractionalBits) / value.denominator())); + } + static bytes encode(h256 const& _value) { return _value.asBytes(); } + static bytes encode(bytes const& _value, bool _padLeft = true) + { + bytes padding = bytes((32 - _value.size() % 32) % 32, 0); + return _padLeft ? padding + _value : _value + padding; + } + static bytes encode(std::string const& _value) { return encode(asBytes(_value), false); } + template + static bytes encode(std::vector<_T> const& _value) + { + bytes ret; + for (auto const& v: _value) + ret += encode(v); + return ret; + } + + template + static bytes encodeArgs(FirstArg const& _firstArg, Args const&... _followingArgs) + { + return encode(_firstArg) + encodeArgs(_followingArgs...); + } + static bytes encodeArgs() + { + return bytes(); + } + //@todo might be extended in the future + template + static bytes encodeDyn(Arg const& _arg) + { + return encodeArgs(u256(0x20), u256(_arg.size()), _arg); + } + class ContractInterface + { + public: + ContractInterface(ExecutionFramework& _framework): m_framework(_framework) {} + + void setNextValue(u256 const& _value) { m_nextValue = _value; } + + protected: + template + bytes const& call(std::string const& _sig, Args const&... _arguments) + { + auto const& ret = m_framework.callContractFunctionWithValue(_sig, m_nextValue, _arguments...); + m_nextValue = 0; + return ret; + } + + void callString(std::string const& _name, std::string const& _arg) + { + BOOST_CHECK(call(_name + "(string)", u256(0x20), _arg.length(), _arg).empty()); + } + + void callStringAddress(std::string const& _name, std::string const& _arg1, u160 const& _arg2) + { + BOOST_CHECK(call(_name + "(string,address)", u256(0x40), _arg2, _arg1.length(), _arg1).empty()); + } + + void callStringAddressBool(std::string const& _name, std::string const& _arg1, u160 const& _arg2, bool _arg3) + { + BOOST_CHECK(call(_name + "(string,address,bool)", u256(0x60), _arg2, _arg3, _arg1.length(), _arg1).empty()); + } + + void callStringBytes32(std::string const& _name, std::string const& _arg1, h256 const& _arg2) + { + BOOST_CHECK(call(_name + "(string,bytes32)", u256(0x40), _arg2, _arg1.length(), _arg1).empty()); + } + + u160 callStringReturnsAddress(std::string const& _name, std::string const& _arg) + { + bytes const& ret = call(_name + "(string)", u256(0x20), _arg.length(), _arg); + BOOST_REQUIRE(ret.size() == 0x20); + BOOST_CHECK(std::count(ret.begin(), ret.begin() + 12, 0) == 12); + return eth::abiOut(ret); + } + + std::string callAddressReturnsString(std::string const& _name, u160 const& _arg) + { + bytesConstRef ret = ref(call(_name + "(address)", _arg)); + BOOST_REQUIRE(ret.size() >= 0x20); + u256 offset = eth::abiOut(ret); + BOOST_REQUIRE_EQUAL(offset, 0x20); + u256 len = eth::abiOut(ret); + BOOST_REQUIRE_EQUAL(ret.size(), ((len + 0x1f) / 0x20) * 0x20); + return ret.cropped(0, size_t(len)).toString(); + } + + h256 callStringReturnsBytes32(std::string const& _name, std::string const& _arg) + { + bytes const& ret = call(_name + "(string)", u256(0x20), _arg.length(), _arg); + BOOST_REQUIRE(ret.size() == 0x20); + return eth::abiOut(ret); + } + + private: + u256 m_nextValue; + ExecutionFramework& m_framework; + }; + +private: + template + auto callCppAndEncodeResult(CppFunction const& _cppFunction, Args const&... _arguments) + -> typename std::enable_if::value, bytes>::type + { + _cppFunction(_arguments...); + return bytes(); + } + template + auto callCppAndEncodeResult(CppFunction const& _cppFunction, Args const&... _arguments) + -> typename std::enable_if::value, bytes>::type + { + return encode(_cppFunction(_arguments...)); + } + +protected: + void sendMessage(bytes const& _data, bool _isCreation, u256 const& _value = 0); + void sendEther(Address const& _to, u256 const& _value); + size_t currentTimestamp(); + + /// @returns the (potentially newly created) _ith address. + Address account(size_t _i); + + u256 balanceAt(Address const& _addr); + bool storageEmpty(Address const& _addr); + bool addressHasCode(Address const& _addr); + + RPCSession& m_rpc; + + struct LogEntry + { + Address address; + std::vector topics; + bytes data; + }; + + size_t m_optimizeRuns = 200; + bool m_optimize = false; + Address m_sender; + Address m_contractAddress; + u256 const m_gasPrice = 100 * szabo; + u256 const m_gas = 100000000; + bytes m_output; + std::vector m_logs; + u256 m_gasUsed; +}; + +} +} +} // end namespaces + diff --git a/test/contracts/AuctionRegistrar.cpp b/test/contracts/AuctionRegistrar.cpp index 0b573bca0..c156efd1c 100644 --- a/test/contracts/AuctionRegistrar.cpp +++ b/test/contracts/AuctionRegistrar.cpp @@ -213,7 +213,7 @@ contract GlobalRegistrar is Registrar, AuctionSystem { static unique_ptr s_compiledRegistrar; -class AuctionRegistrarTestFramework: public ExecutionFramework +class AuctionRegistrarTestFramework: public SolidityExecutionFramework { protected: void deployRegistrar() @@ -229,11 +229,11 @@ protected: BOOST_REQUIRE(!m_output.empty()); } - using ContractInterface = ExecutionFramework::ContractInterface; + using ContractInterface = SolidityExecutionFramework::ContractInterface; class RegistrarInterface: public ContractInterface { public: - RegistrarInterface(ExecutionFramework& _framework): ContractInterface(_framework) {} + RegistrarInterface(SolidityExecutionFramework& _framework): ContractInterface(_framework) {} void reserve(string const& _name) { callString("reserve", _name); diff --git a/test/contracts/FixedFeeRegistrar.cpp b/test/contracts/FixedFeeRegistrar.cpp index 8aabdac2a..829205d5a 100644 --- a/test/contracts/FixedFeeRegistrar.cpp +++ b/test/contracts/FixedFeeRegistrar.cpp @@ -125,7 +125,7 @@ contract FixedFeeRegistrar is Registrar { static unique_ptr s_compiledRegistrar; -class RegistrarTestFramework: public ExecutionFramework +class RegistrarTestFramework: public SolidityExecutionFramework { protected: void deployRegistrar() diff --git a/test/contracts/Wallet.cpp b/test/contracts/Wallet.cpp index 935baf5b5..6fbee6f17 100644 --- a/test/contracts/Wallet.cpp +++ b/test/contracts/Wallet.cpp @@ -435,7 +435,7 @@ contract Wallet is multisig, multiowned, daylimit { static unique_ptr s_compiledWallet; -class WalletTestFramework: public ExecutionFramework +class WalletTestFramework: public SolidityExecutionFramework { protected: void deployWallet( diff --git a/test/libsolidity/GasMeter.cpp b/test/libsolidity/GasMeter.cpp index bc2242845..f467d6699 100644 --- a/test/libsolidity/GasMeter.cpp +++ b/test/libsolidity/GasMeter.cpp @@ -40,7 +40,7 @@ namespace solidity namespace test { -class GasMeterTestFramework: public ExecutionFramework +class GasMeterTestFramework: public SolidityExecutionFramework { public: GasMeterTestFramework() { } diff --git a/test/libsolidity/SolidityEndToEndTest.cpp b/test/libsolidity/SolidityEndToEndTest.cpp index 6478ea86a..b5fcdb5ee 100644 --- a/test/libsolidity/SolidityEndToEndTest.cpp +++ b/test/libsolidity/SolidityEndToEndTest.cpp @@ -25,6 +25,7 @@ #include #include #include +#include #include #include @@ -38,7 +39,7 @@ namespace solidity namespace test { -BOOST_FIXTURE_TEST_SUITE(SolidityEndToEndTest, ExecutionFramework) +BOOST_FIXTURE_TEST_SUITE(SolidityEndToEndTest, SolidityExecutionFramework) BOOST_AUTO_TEST_CASE(smoke_test) { diff --git a/test/libsolidity/SolidityExecutionFramework.cpp b/test/libsolidity/SolidityExecutionFramework.cpp index 009433674..fe35087c1 100644 --- a/test/libsolidity/SolidityExecutionFramework.cpp +++ b/test/libsolidity/SolidityExecutionFramework.cpp @@ -22,7 +22,6 @@ #include #include -#include #include using namespace std; @@ -30,108 +29,7 @@ using namespace dev; using namespace dev::solidity; using namespace dev::solidity::test; -namespace // anonymous +SolidityExecutionFramework::SolidityExecutionFramework() : + ExecutionFramework() { - h256 const EmptyTrie("0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"); -} - -string getIPCSocketPath() -{ - string ipcPath = dev::test::Options::get().ipcPath; - if (ipcPath.empty()) - BOOST_FAIL("ERROR: ipcPath not set! (use --ipcpath or the environment variable ETH_TEST_IPC)"); - - return ipcPath; -} - -ExecutionFramework::ExecutionFramework() : - m_rpc(RPCSession::instance(getIPCSocketPath())), - m_optimize(dev::test::Options::get().optimize), - m_sender(m_rpc.account(0)) -{ - m_rpc.test_rewindToBlock(0); -} - -void ExecutionFramework::sendMessage(bytes const& _data, bool _isCreation, u256 const& _value) -{ - RPCSession::TransactionData d; - d.data = "0x" + toHex(_data); - d.from = "0x" + toString(m_sender); - d.gas = toHex(m_gas, HexPrefix::Add); - d.gasPrice = toHex(m_gasPrice, HexPrefix::Add); - d.value = toHex(_value, HexPrefix::Add); - if (!_isCreation) - { - d.to = dev::toString(m_contractAddress); - BOOST_REQUIRE(m_rpc.eth_getCode(d.to, "latest").size() > 2); - // Use eth_call to get the output - m_output = fromHex(m_rpc.eth_call(d, "latest"), WhenError::Throw); - } - - string txHash = m_rpc.eth_sendTransaction(d); - m_rpc.test_mineBlocks(1); - RPCSession::TransactionReceipt receipt(m_rpc.eth_getTransactionReceipt(txHash)); - - if (_isCreation) - { - m_contractAddress = Address(receipt.contractAddress); - BOOST_REQUIRE(m_contractAddress); - string code = m_rpc.eth_getCode(receipt.contractAddress, "latest"); - m_output = fromHex(code, WhenError::Throw); - } - - m_gasUsed = u256(receipt.gasUsed); - m_logs.clear(); - for (auto const& log: receipt.logEntries) - { - LogEntry entry; - entry.address = Address(log.address); - for (auto const& topic: log.topics) - entry.topics.push_back(h256(topic)); - entry.data = fromHex(log.data, WhenError::Throw); - m_logs.push_back(entry); - } -} - -void ExecutionFramework::sendEther(Address const& _to, u256 const& _value) -{ - RPCSession::TransactionData d; - d.data = "0x"; - d.from = "0x" + toString(m_sender); - d.gas = toHex(m_gas, HexPrefix::Add); - d.gasPrice = toHex(m_gasPrice, HexPrefix::Add); - d.value = toHex(_value, HexPrefix::Add); - d.to = dev::toString(_to); - - string txHash = m_rpc.eth_sendTransaction(d); - m_rpc.test_mineBlocks(1); -} - -size_t ExecutionFramework::currentTimestamp() -{ - auto latestBlock = m_rpc.rpcCall("eth_getBlockByNumber", {"\"latest\"", "false"}); - return size_t(u256(latestBlock.get("timestamp", "invalid").asString())); -} - -Address ExecutionFramework::account(size_t _i) -{ - return Address(m_rpc.accountCreateIfNotExists(_i)); -} - -bool ExecutionFramework::addressHasCode(Address const& _addr) -{ - string code = m_rpc.eth_getCode(toString(_addr), "latest"); - return !code.empty() && code != "0x"; -} - -u256 ExecutionFramework::balanceAt(Address const& _addr) -{ - return u256(m_rpc.eth_getBalance(toString(_addr), "latest")); -} - -bool ExecutionFramework::storageEmpty(Address const& _addr) -{ - h256 root(m_rpc.eth_getStorageRoot(toString(_addr), "latest")); - BOOST_CHECK(root); - return root == EmptyTrie; } diff --git a/test/libsolidity/SolidityExecutionFramework.h b/test/libsolidity/SolidityExecutionFramework.h index b2ea9c08e..16b886f18 100644 --- a/test/libsolidity/SolidityExecutionFramework.h +++ b/test/libsolidity/SolidityExecutionFramework.h @@ -24,12 +24,7 @@ #include -#include "../TestHelper.h" -#include "../RPCSession.h" - -#include -#include -#include +#include "../ExecutionFramework.h" #include #include @@ -39,34 +34,23 @@ namespace dev { namespace solidity { - using rational = boost::rational; - /// An Ethereum address: 20 bytes. - /// @NOTE This is not endian-specific; it's just a bunch of bytes. - using Address = h160; - - // The various denominations; here for ease of use where needed within code. - static const u256 ether = exp10<18>(); - static const u256 finney = exp10<15>(); - static const u256 szabo = exp10<12>(); - static const u256 shannon = exp10<9>(); - static const u256 wei = exp10<0>(); namespace test { -class ExecutionFramework +class SolidityExecutionFramework: public ExecutionFramework { public: - ExecutionFramework(); + SolidityExecutionFramework(); - bytes const& compileAndRunWithoutCheck( + virtual bytes const& compileAndRunWithoutCheck( std::string const& _sourceCode, u256 const& _value = 0, std::string const& _contractName = "", bytes const& _arguments = bytes(), std::map const& _libraryAddresses = std::map() - ) + ) override { // Silence compiler version warning std::string sourceCode = "pragma solidity >=0.0;\n" + _sourceCode; @@ -90,224 +74,8 @@ public: return m_output; } - bytes const& compileAndRun( - std::string const& _sourceCode, - u256 const& _value = 0, - std::string const& _contractName = "", - bytes const& _arguments = bytes(), - std::map const& _libraryAddresses = std::map() - ) - { - compileAndRunWithoutCheck(_sourceCode, _value, _contractName, _arguments, _libraryAddresses); - BOOST_REQUIRE(!m_output.empty()); - return m_output; - } - - template - bytes const& callContractFunctionWithValue(std::string _sig, u256 const& _value, Args const&... _arguments) - { - FixedHash<4> hash(dev::keccak256(_sig)); - sendMessage(hash.asBytes() + encodeArgs(_arguments...), false, _value); - return m_output; - } - - template - bytes const& callContractFunction(std::string _sig, Args const&... _arguments) - { - return callContractFunctionWithValue(_sig, 0, _arguments...); - } - - template - void testSolidityAgainstCpp(std::string _sig, CppFunction const& _cppFunction, Args const&... _arguments) - { - bytes solidityResult = callContractFunction(_sig, _arguments...); - bytes cppResult = callCppAndEncodeResult(_cppFunction, _arguments...); - BOOST_CHECK_MESSAGE( - solidityResult == cppResult, - "Computed values do not match.\nSolidity: " + - toHex(solidityResult) + - "\nC++: " + - toHex(cppResult) - ); - } - - template - void testSolidityAgainstCppOnRange(std::string _sig, CppFunction const& _cppFunction, u256 const& _rangeStart, u256 const& _rangeEnd) - { - for (u256 argument = _rangeStart; argument < _rangeEnd; ++argument) - { - bytes solidityResult = callContractFunction(_sig, argument); - bytes cppResult = callCppAndEncodeResult(_cppFunction, argument); - BOOST_CHECK_MESSAGE( - solidityResult == cppResult, - "Computed values do not match.\nSolidity: " + - toHex(solidityResult) + - "\nC++: " + - toHex(cppResult) + - "\nArgument: " + - toHex(encode(argument)) - ); - } - } - - static bytes encode(bool _value) { return encode(byte(_value)); } - static bytes encode(int _value) { return encode(u256(_value)); } - static bytes encode(size_t _value) { return encode(u256(_value)); } - static bytes encode(char const* _value) { return encode(std::string(_value)); } - static bytes encode(byte _value) { return bytes(31, 0) + bytes{_value}; } - static bytes encode(u256 const& _value) { return toBigEndian(_value); } - /// @returns the fixed-point encoding of a rational number with a given - /// number of fractional bits. - static bytes encode(std::pair const& _valueAndPrecision) - { - rational const& value = _valueAndPrecision.first; - int fractionalBits = _valueAndPrecision.second; - return encode(u256((value.numerator() << fractionalBits) / value.denominator())); - } - static bytes encode(h256 const& _value) { return _value.asBytes(); } - static bytes encode(bytes const& _value, bool _padLeft = true) - { - bytes padding = bytes((32 - _value.size() % 32) % 32, 0); - return _padLeft ? padding + _value : _value + padding; - } - static bytes encode(std::string const& _value) { return encode(asBytes(_value), false); } - template - static bytes encode(std::vector<_T> const& _value) - { - bytes ret; - for (auto const& v: _value) - ret += encode(v); - return ret; - } - - template - static bytes encodeArgs(FirstArg const& _firstArg, Args const&... _followingArgs) - { - return encode(_firstArg) + encodeArgs(_followingArgs...); - } - static bytes encodeArgs() - { - return bytes(); - } - //@todo might be extended in the future - template - static bytes encodeDyn(Arg const& _arg) - { - return encodeArgs(u256(0x20), u256(_arg.size()), _arg); - } - class ContractInterface - { - public: - ContractInterface(ExecutionFramework& _framework): m_framework(_framework) {} - - void setNextValue(u256 const& _value) { m_nextValue = _value; } - - protected: - template - bytes const& call(std::string const& _sig, Args const&... _arguments) - { - auto const& ret = m_framework.callContractFunctionWithValue(_sig, m_nextValue, _arguments...); - m_nextValue = 0; - return ret; - } - - void callString(std::string const& _name, std::string const& _arg) - { - BOOST_CHECK(call(_name + "(string)", u256(0x20), _arg.length(), _arg).empty()); - } - - void callStringAddress(std::string const& _name, std::string const& _arg1, u160 const& _arg2) - { - BOOST_CHECK(call(_name + "(string,address)", u256(0x40), _arg2, _arg1.length(), _arg1).empty()); - } - - void callStringAddressBool(std::string const& _name, std::string const& _arg1, u160 const& _arg2, bool _arg3) - { - BOOST_CHECK(call(_name + "(string,address,bool)", u256(0x60), _arg2, _arg3, _arg1.length(), _arg1).empty()); - } - - void callStringBytes32(std::string const& _name, std::string const& _arg1, h256 const& _arg2) - { - BOOST_CHECK(call(_name + "(string,bytes32)", u256(0x40), _arg2, _arg1.length(), _arg1).empty()); - } - - u160 callStringReturnsAddress(std::string const& _name, std::string const& _arg) - { - bytes const& ret = call(_name + "(string)", u256(0x20), _arg.length(), _arg); - BOOST_REQUIRE(ret.size() == 0x20); - BOOST_CHECK(std::count(ret.begin(), ret.begin() + 12, 0) == 12); - return eth::abiOut(ret); - } - - std::string callAddressReturnsString(std::string const& _name, u160 const& _arg) - { - bytesConstRef ret = ref(call(_name + "(address)", _arg)); - BOOST_REQUIRE(ret.size() >= 0x20); - u256 offset = eth::abiOut(ret); - BOOST_REQUIRE_EQUAL(offset, 0x20); - u256 len = eth::abiOut(ret); - BOOST_REQUIRE_EQUAL(ret.size(), ((len + 0x1f) / 0x20) * 0x20); - return ret.cropped(0, size_t(len)).toString(); - } - - h256 callStringReturnsBytes32(std::string const& _name, std::string const& _arg) - { - bytes const& ret = call(_name + "(string)", u256(0x20), _arg.length(), _arg); - BOOST_REQUIRE(ret.size() == 0x20); - return eth::abiOut(ret); - } - - private: - u256 m_nextValue; - ExecutionFramework& m_framework; - }; - -private: - template - auto callCppAndEncodeResult(CppFunction const& _cppFunction, Args const&... _arguments) - -> typename std::enable_if::value, bytes>::type - { - _cppFunction(_arguments...); - return bytes(); - } - template - auto callCppAndEncodeResult(CppFunction const& _cppFunction, Args const&... _arguments) - -> typename std::enable_if::value, bytes>::type - { - return encode(_cppFunction(_arguments...)); - } - protected: - void sendMessage(bytes const& _data, bool _isCreation, u256 const& _value = 0); - void sendEther(Address const& _to, u256 const& _value); - size_t currentTimestamp(); - - /// @returns the (potentially newly created) _ith address. - Address account(size_t _i); - - u256 balanceAt(Address const& _addr); - bool storageEmpty(Address const& _addr); - bool addressHasCode(Address const& _addr); - - RPCSession& m_rpc; - - struct LogEntry - { - Address address; - std::vector topics; - bytes data; - }; - - size_t m_optimizeRuns = 200; - bool m_optimize = false; dev::solidity::CompilerStack m_compiler; - Address m_sender; - Address m_contractAddress; - u256 const m_gasPrice = 100 * szabo; - u256 const m_gas = 100000000; - bytes m_output; - std::vector m_logs; - u256 m_gasUsed; }; } diff --git a/test/libsolidity/SolidityOptimizer.cpp b/test/libsolidity/SolidityOptimizer.cpp index a53a26384..15208b412 100644 --- a/test/libsolidity/SolidityOptimizer.cpp +++ b/test/libsolidity/SolidityOptimizer.cpp @@ -45,7 +45,7 @@ namespace solidity namespace test { -class OptimizerTestFramework: public ExecutionFramework +class OptimizerTestFramework: public SolidityExecutionFramework { public: OptimizerTestFramework() { } From d83dd59178778b5748092f244ce66e37319f4070 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Mon, 28 Nov 2016 00:58:07 +0000 Subject: [PATCH 05/12] Move ExecutionFramework to the dev::test namespace --- test/ExecutionFramework.cpp | 3 +-- test/ExecutionFramework.h | 6 +----- test/contracts/AuctionRegistrar.cpp | 1 + test/contracts/FixedFeeRegistrar.cpp | 1 + test/contracts/Wallet.cpp | 1 + test/libsolidity/GasMeter.cpp | 1 + test/libsolidity/SolidityEndToEndTest.cpp | 1 + test/libsolidity/SolidityExecutionFramework.cpp | 3 +-- test/libsolidity/SolidityExecutionFramework.h | 4 ++-- test/libsolidity/SolidityOptimizer.cpp | 1 + 10 files changed, 11 insertions(+), 11 deletions(-) diff --git a/test/ExecutionFramework.cpp b/test/ExecutionFramework.cpp index 4ae504626..0c6e0cff7 100644 --- a/test/ExecutionFramework.cpp +++ b/test/ExecutionFramework.cpp @@ -27,8 +27,7 @@ using namespace std; using namespace dev; -using namespace dev::solidity; -using namespace dev::solidity::test; +using namespace dev::test; namespace // anonymous { diff --git a/test/ExecutionFramework.h b/test/ExecutionFramework.h index e487b1061..6ec1a06b3 100644 --- a/test/ExecutionFramework.h +++ b/test/ExecutionFramework.h @@ -32,7 +32,7 @@ namespace dev { -namespace solidity +namespace test { using rational = boost::rational; /// An Ethereum address: 20 bytes. @@ -46,9 +46,6 @@ namespace solidity static const u256 shannon = exp10<9>(); static const u256 wei = exp10<0>(); -namespace test -{ - class ExecutionFramework { @@ -282,7 +279,6 @@ protected: u256 m_gasUsed; }; -} } } // end namespaces diff --git a/test/contracts/AuctionRegistrar.cpp b/test/contracts/AuctionRegistrar.cpp index c156efd1c..fb8c1c68c 100644 --- a/test/contracts/AuctionRegistrar.cpp +++ b/test/contracts/AuctionRegistrar.cpp @@ -27,6 +27,7 @@ #include using namespace std; +using namespace dev::test; namespace dev { diff --git a/test/contracts/FixedFeeRegistrar.cpp b/test/contracts/FixedFeeRegistrar.cpp index 829205d5a..39c32eb72 100644 --- a/test/contracts/FixedFeeRegistrar.cpp +++ b/test/contracts/FixedFeeRegistrar.cpp @@ -35,6 +35,7 @@ #include using namespace std; +using namespace dev::test; namespace dev { diff --git a/test/contracts/Wallet.cpp b/test/contracts/Wallet.cpp index 6fbee6f17..80f06613e 100644 --- a/test/contracts/Wallet.cpp +++ b/test/contracts/Wallet.cpp @@ -35,6 +35,7 @@ #include using namespace std; +using namespace dev::test; namespace dev { diff --git a/test/libsolidity/GasMeter.cpp b/test/libsolidity/GasMeter.cpp index f467d6699..0671fb150 100644 --- a/test/libsolidity/GasMeter.cpp +++ b/test/libsolidity/GasMeter.cpp @@ -32,6 +32,7 @@ using namespace std; using namespace dev::eth; using namespace dev::solidity; +using namespace dev::test; namespace dev { diff --git a/test/libsolidity/SolidityEndToEndTest.cpp b/test/libsolidity/SolidityEndToEndTest.cpp index b5fcdb5ee..930b11c6d 100644 --- a/test/libsolidity/SolidityEndToEndTest.cpp +++ b/test/libsolidity/SolidityEndToEndTest.cpp @@ -31,6 +31,7 @@ using namespace std; using namespace std::placeholders; +using namespace dev::test; namespace dev { diff --git a/test/libsolidity/SolidityExecutionFramework.cpp b/test/libsolidity/SolidityExecutionFramework.cpp index fe35087c1..bb9695d1e 100644 --- a/test/libsolidity/SolidityExecutionFramework.cpp +++ b/test/libsolidity/SolidityExecutionFramework.cpp @@ -24,8 +24,7 @@ #include #include -using namespace std; -using namespace dev; +using namespace dev::test; using namespace dev::solidity; using namespace dev::solidity::test; diff --git a/test/libsolidity/SolidityExecutionFramework.h b/test/libsolidity/SolidityExecutionFramework.h index 16b886f18..0fab7aeb0 100644 --- a/test/libsolidity/SolidityExecutionFramework.h +++ b/test/libsolidity/SolidityExecutionFramework.h @@ -38,7 +38,7 @@ namespace solidity namespace test { -class SolidityExecutionFramework: public ExecutionFramework +class SolidityExecutionFramework: public dev::test::ExecutionFramework { public: @@ -49,7 +49,7 @@ public: u256 const& _value = 0, std::string const& _contractName = "", bytes const& _arguments = bytes(), - std::map const& _libraryAddresses = std::map() + std::map const& _libraryAddresses = std::map() ) override { // Silence compiler version warning diff --git a/test/libsolidity/SolidityOptimizer.cpp b/test/libsolidity/SolidityOptimizer.cpp index 15208b412..603105558 100644 --- a/test/libsolidity/SolidityOptimizer.cpp +++ b/test/libsolidity/SolidityOptimizer.cpp @@ -37,6 +37,7 @@ using namespace std; using namespace dev::eth; +using namespace dev::test; namespace dev { From e26466b729de5bbb4cd578272fab2795cb66aee8 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Mon, 28 Nov 2016 00:58:41 +0000 Subject: [PATCH 06/12] LLL: add end-to-end tests --- test/liblll/EndToEndTest.cpp | 49 +++++++++++++++++++++ test/liblll/ExecutionFramework.cpp | 33 ++++++++++++++ test/liblll/ExecutionFramework.h | 70 ++++++++++++++++++++++++++++++ 3 files changed, 152 insertions(+) create mode 100644 test/liblll/EndToEndTest.cpp create mode 100644 test/liblll/ExecutionFramework.cpp create mode 100644 test/liblll/ExecutionFramework.h diff --git a/test/liblll/EndToEndTest.cpp b/test/liblll/EndToEndTest.cpp new file mode 100644 index 000000000..c9b571f38 --- /dev/null +++ b/test/liblll/EndToEndTest.cpp @@ -0,0 +1,49 @@ +/* + This file is part of solidity. + + solidity 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. + + solidity 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 solidity. If not, see . +*/ +/** + * @author Alex Beregszaszi + * @date 2016 + * End to end tests for LLL. + */ + +#include +#include +#include +#include + +using namespace std; + +namespace dev +{ +namespace lll +{ +namespace test +{ + +BOOST_FIXTURE_TEST_SUITE(LLLEndToEndTest, LLLExecutionFramework) + +BOOST_AUTO_TEST_CASE(smoke_test) +{ + char const* sourceCode = "(returnlll { (return \"test\") })"; + compileAndRun(sourceCode); +} + +BOOST_AUTO_TEST_SUITE_END() + +} +} +} // end namespaces diff --git a/test/liblll/ExecutionFramework.cpp b/test/liblll/ExecutionFramework.cpp new file mode 100644 index 000000000..4719c5f50 --- /dev/null +++ b/test/liblll/ExecutionFramework.cpp @@ -0,0 +1,33 @@ +/* + This file is part of solidity. + + solidity 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. + + solidity 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 solidity. If not, see . +*/ +/** + * @author Alex Beregszaszi + * @date 2016 + * Framework for executing LLL contracts and testing them via RPC. + */ + +#include +#include +#include + +using namespace dev::test; +using namespace dev::lll::test; + +LLLExecutionFramework::LLLExecutionFramework() : + ExecutionFramework() +{ +} diff --git a/test/liblll/ExecutionFramework.h b/test/liblll/ExecutionFramework.h new file mode 100644 index 000000000..37162e7fe --- /dev/null +++ b/test/liblll/ExecutionFramework.h @@ -0,0 +1,70 @@ +/* + This file is part of solidity. + + solidity 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. + + solidity 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 solidity. If not, see . +*/ +/** + * @author Alex Beregszaszi + * @date 2016 + * Framework for executing LLL contracts and testing them via RPC. + */ + +#pragma once + +#include + +#include "../ExecutionFramework.h" + +#include + +using namespace dev::test; + +namespace dev +{ +namespace lll +{ + +namespace test +{ + +class LLLExecutionFramework: public ExecutionFramework +{ + +public: + LLLExecutionFramework(); + + virtual bytes const& compileAndRunWithoutCheck( + std::string const& _sourceCode, + u256 const& _value = 0, + std::string const& _contractName = "", + bytes const& _arguments = bytes(), + std::map const& _libraryAddresses = std::map() + ) override + { + std::vector errors; + bytes bytecode = eth::compileLLL(_sourceCode, m_optimize, &errors); + if (!errors.empty()) + { + for (auto const& error: errors) + std::cerr << error << std::endl; + BOOST_ERROR("Compiling contract failed"); + } + sendMessage(bytecode + _arguments, true, _value); + return m_output; + } +}; + +} +} +} // end namespaces From 85ebe4e5c47f47aa46f76043279dc15962b617e4 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Mon, 28 Nov 2016 11:13:15 +0000 Subject: [PATCH 07/12] LLL: check for return value in LLL smoke test --- test/liblll/EndToEndTest.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/test/liblll/EndToEndTest.cpp b/test/liblll/EndToEndTest.cpp index c9b571f38..9025689ef 100644 --- a/test/liblll/EndToEndTest.cpp +++ b/test/liblll/EndToEndTest.cpp @@ -40,6 +40,7 @@ BOOST_AUTO_TEST_CASE(smoke_test) { char const* sourceCode = "(returnlll { (return \"test\") })"; compileAndRun(sourceCode); + BOOST_CHECK(callContractFunction("") == encodeArgs(string("test", 4))); } BOOST_AUTO_TEST_SUITE_END() From 94cae6339063fb6c33dc477991ac3d0933dc562f Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Mon, 28 Nov 2016 11:19:31 +0000 Subject: [PATCH 08/12] Add callFallback to ExectionFramework --- test/ExecutionFramework.h | 11 +++++++++++ test/liblll/EndToEndTest.cpp | 2 +- 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/test/ExecutionFramework.h b/test/ExecutionFramework.h index 6ec1a06b3..6c5a57643 100644 --- a/test/ExecutionFramework.h +++ b/test/ExecutionFramework.h @@ -73,6 +73,17 @@ public: return m_output; } + bytes const& callFallbackWithValue(u256 const& _value) + { + sendMessage(bytes(), false, _value); + return m_output; + } + + bytes const & callFallback() + { + return callFallbackWithValue(0); + } + template bytes const& callContractFunctionWithValue(std::string _sig, u256 const& _value, Args const&... _arguments) { diff --git a/test/liblll/EndToEndTest.cpp b/test/liblll/EndToEndTest.cpp index 9025689ef..b5e32e94f 100644 --- a/test/liblll/EndToEndTest.cpp +++ b/test/liblll/EndToEndTest.cpp @@ -40,7 +40,7 @@ BOOST_AUTO_TEST_CASE(smoke_test) { char const* sourceCode = "(returnlll { (return \"test\") })"; compileAndRun(sourceCode); - BOOST_CHECK(callContractFunction("") == encodeArgs(string("test", 4))); + BOOST_CHECK(callFallback() == encodeArgs(string("test", 4))); } BOOST_AUTO_TEST_SUITE_END() From 0f1d0304eef9777c002f86134e4d6ec7b4d53385 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Mon, 28 Nov 2016 11:50:07 +0000 Subject: [PATCH 09/12] LLLExecutionFramework doesn't support contractName/libraryAddresses --- test/liblll/ExecutionFramework.h | 3 +++ 1 file changed, 3 insertions(+) diff --git a/test/liblll/ExecutionFramework.h b/test/liblll/ExecutionFramework.h index 37162e7fe..58e1f0add 100644 --- a/test/liblll/ExecutionFramework.h +++ b/test/liblll/ExecutionFramework.h @@ -52,6 +52,9 @@ public: std::map const& _libraryAddresses = std::map() ) override { + BOOST_REQUIRE(_contractName.empty()); + BOOST_REQUIRE(_libraryAddresses.empty()); + std::vector errors; bytes bytecode = eth::compileLLL(_sourceCode, m_optimize, &errors); if (!errors.empty()) From 25c5dd48deae72fc3afc1514271f668f04b6c5a4 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Tue, 29 Nov 2016 21:46:52 +0000 Subject: [PATCH 10/12] Rename testSolidityAgainstCpp* to testContractAgainstCpp* --- test/ExecutionFramework.h | 20 +-- test/libsolidity/SolidityEndToEndTest.cpp | 150 +++++++++++----------- 2 files changed, 85 insertions(+), 85 deletions(-) diff --git a/test/ExecutionFramework.h b/test/ExecutionFramework.h index 6c5a57643..1274d4006 100644 --- a/test/ExecutionFramework.h +++ b/test/ExecutionFramework.h @@ -99,30 +99,30 @@ public: } template - void testSolidityAgainstCpp(std::string _sig, CppFunction const& _cppFunction, Args const&... _arguments) + void testContractAgainstCpp(std::string _sig, CppFunction const& _cppFunction, Args const&... _arguments) { - bytes solidityResult = callContractFunction(_sig, _arguments...); + bytes contractResult = callContractFunction(_sig, _arguments...); bytes cppResult = callCppAndEncodeResult(_cppFunction, _arguments...); BOOST_CHECK_MESSAGE( - solidityResult == cppResult, - "Computed values do not match.\nSolidity: " + - toHex(solidityResult) + + contractResult == cppResult, + "Computed values do not match.\nContract: " + + toHex(contractResult) + "\nC++: " + toHex(cppResult) ); } template - void testSolidityAgainstCppOnRange(std::string _sig, CppFunction const& _cppFunction, u256 const& _rangeStart, u256 const& _rangeEnd) + void testContractAgainstCppOnRange(std::string _sig, CppFunction const& _cppFunction, u256 const& _rangeStart, u256 const& _rangeEnd) { for (u256 argument = _rangeStart; argument < _rangeEnd; ++argument) { - bytes solidityResult = callContractFunction(_sig, argument); + bytes contractResult = callContractFunction(_sig, argument); bytes cppResult = callCppAndEncodeResult(_cppFunction, argument); BOOST_CHECK_MESSAGE( - solidityResult == cppResult, - "Computed values do not match.\nSolidity: " + - toHex(solidityResult) + + contractResult == cppResult, + "Computed values do not match.\nContract: " + + toHex(contractResult) + "\nC++: " + toHex(cppResult) + "\nArgument: " + diff --git a/test/libsolidity/SolidityEndToEndTest.cpp b/test/libsolidity/SolidityEndToEndTest.cpp index 930b11c6d..98ea92cab 100644 --- a/test/libsolidity/SolidityEndToEndTest.cpp +++ b/test/libsolidity/SolidityEndToEndTest.cpp @@ -48,7 +48,7 @@ BOOST_AUTO_TEST_CASE(smoke_test) " function f(uint a) returns(uint d) { return a * 7; }\n" "}\n"; compileAndRun(sourceCode); - testSolidityAgainstCppOnRange("f(uint256)", [](u256 const& a) -> u256 { return a * 7; }, 0, 100); + testContractAgainstCppOnRange("f(uint256)", [](u256 const& a) -> u256 { return a * 7; }, 0, 100); } BOOST_AUTO_TEST_CASE(empty_contract) @@ -66,7 +66,7 @@ BOOST_AUTO_TEST_CASE(exp_operator) function f(uint a) returns(uint d) { return 2 ** a; } })"; compileAndRun(sourceCode); - testSolidityAgainstCppOnRange("f(uint256)", [](u256 const& a) -> u256 { return u256(1 << a.convert_to()); }, 0, 16); + testContractAgainstCppOnRange("f(uint256)", [](u256 const& a) -> u256 { return u256(1 << a.convert_to()); }, 0, 16); } BOOST_AUTO_TEST_CASE(exp_operator_const) @@ -292,7 +292,7 @@ BOOST_AUTO_TEST_CASE(recursive_calls) return n * recursive_calls_cpp(n - 1); }; - testSolidityAgainstCppOnRange("f(uint256)", recursive_calls_cpp, 0, 5); + testContractAgainstCppOnRange("f(uint256)", recursive_calls_cpp, 0, 5); } BOOST_AUTO_TEST_CASE(multiple_functions) @@ -352,7 +352,7 @@ BOOST_AUTO_TEST_CASE(while_loop) return nfac; }; - testSolidityAgainstCppOnRange("f(uint256)", while_loop_cpp, 0, 5); + testContractAgainstCppOnRange("f(uint256)", while_loop_cpp, 0, 5); } @@ -380,7 +380,7 @@ BOOST_AUTO_TEST_CASE(do_while_loop) return nfac; }; - testSolidityAgainstCppOnRange("f(uint256)", do_while_loop_cpp, 0, 5); + testContractAgainstCppOnRange("f(uint256)", do_while_loop_cpp, 0, 5); } BOOST_AUTO_TEST_CASE(nested_loops) @@ -429,7 +429,7 @@ BOOST_AUTO_TEST_CASE(nested_loops) return n; }; - testSolidityAgainstCppOnRange("f(uint256)", nested_loops_cpp, 0, 12); + testContractAgainstCppOnRange("f(uint256)", nested_loops_cpp, 0, 12); } BOOST_AUTO_TEST_CASE(for_loop) @@ -451,7 +451,7 @@ BOOST_AUTO_TEST_CASE(for_loop) return nfac; }; - testSolidityAgainstCppOnRange("f(uint256)", for_loop_cpp, 0, 5); + testContractAgainstCppOnRange("f(uint256)", for_loop_cpp, 0, 5); } BOOST_AUTO_TEST_CASE(for_loop_empty) @@ -479,7 +479,7 @@ BOOST_AUTO_TEST_CASE(for_loop_empty) return ret; }; - testSolidityAgainstCpp("f()", for_loop_empty_cpp); + testContractAgainstCpp("f()", for_loop_empty_cpp); } BOOST_AUTO_TEST_CASE(for_loop_simple_init_expr) @@ -503,7 +503,7 @@ BOOST_AUTO_TEST_CASE(for_loop_simple_init_expr) return nfac; }; - testSolidityAgainstCppOnRange("f(uint256)", for_loop_simple_init_expr_cpp, 0, 5); + testContractAgainstCppOnRange("f(uint256)", for_loop_simple_init_expr_cpp, 0, 5); } BOOST_AUTO_TEST_CASE(for_loop_break_continue) @@ -549,7 +549,7 @@ BOOST_AUTO_TEST_CASE(for_loop_break_continue) return i; }; - testSolidityAgainstCppOnRange("f(uint256)", breakContinue, 0, 10); + testContractAgainstCppOnRange("f(uint256)", breakContinue, 0, 10); } BOOST_AUTO_TEST_CASE(calling_other_functions) @@ -593,11 +593,11 @@ BOOST_AUTO_TEST_CASE(calling_other_functions) return y; }; - testSolidityAgainstCpp("run(uint256)", collatz_cpp, u256(0)); - testSolidityAgainstCpp("run(uint256)", collatz_cpp, u256(1)); - testSolidityAgainstCpp("run(uint256)", collatz_cpp, u256(2)); - testSolidityAgainstCpp("run(uint256)", collatz_cpp, u256(8)); - testSolidityAgainstCpp("run(uint256)", collatz_cpp, u256(127)); + testContractAgainstCpp("run(uint256)", collatz_cpp, u256(0)); + testContractAgainstCpp("run(uint256)", collatz_cpp, u256(1)); + testContractAgainstCpp("run(uint256)", collatz_cpp, u256(2)); + testContractAgainstCpp("run(uint256)", collatz_cpp, u256(8)); + testContractAgainstCpp("run(uint256)", collatz_cpp, u256(127)); } BOOST_AUTO_TEST_CASE(many_local_variables) @@ -618,7 +618,7 @@ BOOST_AUTO_TEST_CASE(many_local_variables) u256 y = a + b + c + x1 + x2 + x3; return y + b + x2; }; - testSolidityAgainstCpp("run(uint256,uint256,uint256)", f, u256(0x1000), u256(0x10000), u256(0x100000)); + testContractAgainstCpp("run(uint256,uint256,uint256)", f, u256(0x1000), u256(0x10000), u256(0x100000)); } BOOST_AUTO_TEST_CASE(packing_unpacking_types) @@ -675,7 +675,7 @@ BOOST_AUTO_TEST_CASE(short_circuiting) return n; }; - testSolidityAgainstCppOnRange("run(uint256)", short_circuiting_cpp, 0, 2); + testContractAgainstCppOnRange("run(uint256)", short_circuiting_cpp, 0, 2); } BOOST_AUTO_TEST_CASE(high_bits_cleaning) @@ -697,7 +697,7 @@ BOOST_AUTO_TEST_CASE(high_bits_cleaning) return 0; return x; }; - testSolidityAgainstCpp("run()", high_bits_cleaning_cpp); + testContractAgainstCpp("run()", high_bits_cleaning_cpp); } BOOST_AUTO_TEST_CASE(sign_extension) @@ -717,7 +717,7 @@ BOOST_AUTO_TEST_CASE(sign_extension) return 0; return u256(x) * -1; }; - testSolidityAgainstCpp("run()", sign_extension_cpp); + testContractAgainstCpp("run()", sign_extension_cpp); } BOOST_AUTO_TEST_CASE(small_unsigned_types) @@ -736,7 +736,7 @@ BOOST_AUTO_TEST_CASE(small_unsigned_types) uint32_t x = t * 0xffffff; return x / 0x100; }; - testSolidityAgainstCpp("run()", small_unsigned_types_cpp); + testContractAgainstCpp("run()", small_unsigned_types_cpp); } BOOST_AUTO_TEST_CASE(small_signed_types) @@ -751,7 +751,7 @@ BOOST_AUTO_TEST_CASE(small_signed_types) { return -int32_t(10) * -int64_t(20); }; - testSolidityAgainstCpp("run()", small_signed_types_cpp); + testContractAgainstCpp("run()", small_signed_types_cpp); } BOOST_AUTO_TEST_CASE(strings) @@ -857,14 +857,14 @@ BOOST_AUTO_TEST_CASE(compound_assign) value2 *= value3 + value1; return value2 += 7; }; - testSolidityAgainstCpp("f(uint256,uint256)", f, u256(0), u256(6)); - testSolidityAgainstCpp("f(uint256,uint256)", f, u256(1), u256(3)); - testSolidityAgainstCpp("f(uint256,uint256)", f, u256(2), u256(25)); - testSolidityAgainstCpp("f(uint256,uint256)", f, u256(3), u256(69)); - testSolidityAgainstCpp("f(uint256,uint256)", f, u256(4), u256(84)); - testSolidityAgainstCpp("f(uint256,uint256)", f, u256(5), u256(2)); - testSolidityAgainstCpp("f(uint256,uint256)", f, u256(6), u256(51)); - testSolidityAgainstCpp("f(uint256,uint256)", f, u256(7), u256(48)); + testContractAgainstCpp("f(uint256,uint256)", f, u256(0), u256(6)); + testContractAgainstCpp("f(uint256,uint256)", f, u256(1), u256(3)); + testContractAgainstCpp("f(uint256,uint256)", f, u256(2), u256(25)); + testContractAgainstCpp("f(uint256,uint256)", f, u256(3), u256(69)); + testContractAgainstCpp("f(uint256,uint256)", f, u256(4), u256(84)); + testContractAgainstCpp("f(uint256,uint256)", f, u256(5), u256(2)); + testContractAgainstCpp("f(uint256,uint256)", f, u256(6), u256(51)); + testContractAgainstCpp("f(uint256,uint256)", f, u256(7), u256(48)); } BOOST_AUTO_TEST_CASE(simple_mapping) @@ -938,38 +938,38 @@ BOOST_AUTO_TEST_CASE(mapping_state) auto getVoteCount = bind(&Ballot::getVoteCount, &ballot, _1); auto grantVoteRight = bind(&Ballot::grantVoteRight, &ballot, _1); auto vote = bind(&Ballot::vote, &ballot, _1, _2); - testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(0)); - testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(1)); - testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(2)); + testContractAgainstCpp("getVoteCount(address)", getVoteCount, u160(0)); + testContractAgainstCpp("getVoteCount(address)", getVoteCount, u160(1)); + testContractAgainstCpp("getVoteCount(address)", getVoteCount, u160(2)); // voting without vote right should be rejected - testSolidityAgainstCpp("vote(address,address)", vote, u160(0), u160(2)); - testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(0)); - testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(1)); - testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(2)); + testContractAgainstCpp("vote(address,address)", vote, u160(0), u160(2)); + testContractAgainstCpp("getVoteCount(address)", getVoteCount, u160(0)); + testContractAgainstCpp("getVoteCount(address)", getVoteCount, u160(1)); + testContractAgainstCpp("getVoteCount(address)", getVoteCount, u160(2)); // grant vote rights - testSolidityAgainstCpp("grantVoteRight(address)", grantVoteRight, u160(0)); - testSolidityAgainstCpp("grantVoteRight(address)", grantVoteRight, u160(1)); + testContractAgainstCpp("grantVoteRight(address)", grantVoteRight, u160(0)); + testContractAgainstCpp("grantVoteRight(address)", grantVoteRight, u160(1)); // vote, should increase 2's vote count - testSolidityAgainstCpp("vote(address,address)", vote, u160(0), u160(2)); - testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(0)); - testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(1)); - testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(2)); + testContractAgainstCpp("vote(address,address)", vote, u160(0), u160(2)); + testContractAgainstCpp("getVoteCount(address)", getVoteCount, u160(0)); + testContractAgainstCpp("getVoteCount(address)", getVoteCount, u160(1)); + testContractAgainstCpp("getVoteCount(address)", getVoteCount, u160(2)); // vote again, should be rejected - testSolidityAgainstCpp("vote(address,address)", vote, u160(0), u160(1)); - testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(0)); - testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(1)); - testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(2)); + testContractAgainstCpp("vote(address,address)", vote, u160(0), u160(1)); + testContractAgainstCpp("getVoteCount(address)", getVoteCount, u160(0)); + testContractAgainstCpp("getVoteCount(address)", getVoteCount, u160(1)); + testContractAgainstCpp("getVoteCount(address)", getVoteCount, u160(2)); // vote without right to vote - testSolidityAgainstCpp("vote(address,address)", vote, u160(2), u160(1)); - testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(0)); - testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(1)); - testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(2)); + testContractAgainstCpp("vote(address,address)", vote, u160(2), u160(1)); + testContractAgainstCpp("getVoteCount(address)", getVoteCount, u160(0)); + testContractAgainstCpp("getVoteCount(address)", getVoteCount, u160(1)); + testContractAgainstCpp("getVoteCount(address)", getVoteCount, u160(2)); // grant vote right and now vote again - testSolidityAgainstCpp("grantVoteRight(address)", grantVoteRight, u160(2)); - testSolidityAgainstCpp("vote(address,address)", vote, u160(2), u160(1)); - testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(0)); - testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(1)); - testSolidityAgainstCpp("getVoteCount(address)", getVoteCount, u160(2)); + testContractAgainstCpp("grantVoteRight(address)", grantVoteRight, u160(2)); + testContractAgainstCpp("vote(address,address)", vote, u160(2), u160(1)); + testContractAgainstCpp("getVoteCount(address)", getVoteCount, u160(0)); + testContractAgainstCpp("getVoteCount(address)", getVoteCount, u160(1)); + testContractAgainstCpp("getVoteCount(address)", getVoteCount, u160(2)); } BOOST_AUTO_TEST_CASE(mapping_state_inc_dec) @@ -1000,7 +1000,7 @@ BOOST_AUTO_TEST_CASE(mapping_state_inc_dec) table[value]++; return --table[value++]; }; - testSolidityAgainstCppOnRange("f(uint256)", f, 0, 5); + testContractAgainstCppOnRange("f(uint256)", f, 0, 5); } BOOST_AUTO_TEST_CASE(multi_level_mapping) @@ -1020,14 +1020,14 @@ BOOST_AUTO_TEST_CASE(multi_level_mapping) if (_z == 0) return table[_x][_y]; else return table[_x][_y] = _z; }; - testSolidityAgainstCpp("f(uint256,uint256,uint256)", f, u256(4), u256(5), u256(0)); - testSolidityAgainstCpp("f(uint256,uint256,uint256)", f, u256(5), u256(4), u256(0)); - testSolidityAgainstCpp("f(uint256,uint256,uint256)", f, u256(4), u256(5), u256(9)); - testSolidityAgainstCpp("f(uint256,uint256,uint256)", f, u256(4), u256(5), u256(0)); - testSolidityAgainstCpp("f(uint256,uint256,uint256)", f, u256(5), u256(4), u256(0)); - testSolidityAgainstCpp("f(uint256,uint256,uint256)", f, u256(5), u256(4), u256(7)); - testSolidityAgainstCpp("f(uint256,uint256,uint256)", f, u256(4), u256(5), u256(0)); - testSolidityAgainstCpp("f(uint256,uint256,uint256)", f, u256(5), u256(4), u256(0)); + testContractAgainstCpp("f(uint256,uint256,uint256)", f, u256(4), u256(5), u256(0)); + testContractAgainstCpp("f(uint256,uint256,uint256)", f, u256(5), u256(4), u256(0)); + testContractAgainstCpp("f(uint256,uint256,uint256)", f, u256(4), u256(5), u256(9)); + testContractAgainstCpp("f(uint256,uint256,uint256)", f, u256(4), u256(5), u256(0)); + testContractAgainstCpp("f(uint256,uint256,uint256)", f, u256(5), u256(4), u256(0)); + testContractAgainstCpp("f(uint256,uint256,uint256)", f, u256(5), u256(4), u256(7)); + testContractAgainstCpp("f(uint256,uint256,uint256)", f, u256(4), u256(5), u256(0)); + testContractAgainstCpp("f(uint256,uint256,uint256)", f, u256(5), u256(4), u256(0)); } BOOST_AUTO_TEST_CASE(structs) @@ -1201,8 +1201,8 @@ BOOST_AUTO_TEST_CASE(constructor) { return data[_x]; }; - testSolidityAgainstCpp("get(uint256)", get, u256(6)); - testSolidityAgainstCpp("get(uint256)", get, u256(7)); + testContractAgainstCpp("get(uint256)", get, u256(6)); + testContractAgainstCpp("get(uint256)", get, u256(7)); } BOOST_AUTO_TEST_CASE(simple_accessor) @@ -1723,9 +1723,9 @@ BOOST_AUTO_TEST_CASE(sha3) { return dev::keccak256(toBigEndian(_x)); }; - testSolidityAgainstCpp("a(bytes32)", f, u256(4)); - testSolidityAgainstCpp("a(bytes32)", f, u256(5)); - testSolidityAgainstCpp("a(bytes32)", f, u256(-1)); + testContractAgainstCpp("a(bytes32)", f, u256(4)); + testContractAgainstCpp("a(bytes32)", f, u256(5)); + testContractAgainstCpp("a(bytes32)", f, u256(-1)); } BOOST_AUTO_TEST_CASE(sha256) @@ -1746,9 +1746,9 @@ BOOST_AUTO_TEST_CASE(sha256) return fromHex("af9613760f72635fbdb44a5a0a63c39f12af30f950a6ee5c971be188e89c4051"); return fromHex(""); }; - testSolidityAgainstCpp("a(bytes32)", f, u256(4)); - testSolidityAgainstCpp("a(bytes32)", f, u256(5)); - testSolidityAgainstCpp("a(bytes32)", f, u256(-1)); + testContractAgainstCpp("a(bytes32)", f, u256(4)); + testContractAgainstCpp("a(bytes32)", f, u256(5)); + testContractAgainstCpp("a(bytes32)", f, u256(-1)); } BOOST_AUTO_TEST_CASE(ripemd) @@ -1769,9 +1769,9 @@ BOOST_AUTO_TEST_CASE(ripemd) return fromHex("1cf4e77f5966e13e109703cd8a0df7ceda7f3dc3000000000000000000000000"); return fromHex(""); }; - testSolidityAgainstCpp("a(bytes32)", f, u256(4)); - testSolidityAgainstCpp("a(bytes32)", f, u256(5)); - testSolidityAgainstCpp("a(bytes32)", f, u256(-1)); + testContractAgainstCpp("a(bytes32)", f, u256(4)); + testContractAgainstCpp("a(bytes32)", f, u256(5)); + testContractAgainstCpp("a(bytes32)", f, u256(-1)); } BOOST_AUTO_TEST_CASE(ecrecover) From d82eac3fed6547ddcaac8ecccb15c7f7eaa74d16 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Tue, 29 Nov 2016 22:04:51 +0000 Subject: [PATCH 11/12] LLL: parseLLL to be less greedy catching exceptions --- liblll/Compiler.cpp | 25 +++++++++++++++++++------ 1 file changed, 19 insertions(+), 6 deletions(-) diff --git a/liblll/Compiler.cpp b/liblll/Compiler.cpp index 0cec7bc8f..73a82a35b 100644 --- a/liblll/Compiler.cpp +++ b/liblll/Compiler.cpp @@ -99,15 +99,28 @@ std::string dev::eth::compileLLLToAsm(std::string const& _src, bool _opt, std::v string dev::eth::parseLLL(string const& _src) { + bool failed = false; + sp::utree o; + try { - sp::utree o; parseTreeLLL(_src, o); - ostringstream ret; - debugOutAST(ret, o); - killBigints(o); + } + catch (...) + { + failed = true; + } + + ostringstream ret; + debugOutAST(ret, o); + killBigints(o); + + if (failed) + { + return string(); + } + else + { return ret.str(); } - catch (...) {} - return string(); } From 53d4433484c33b32d4d1063330633a308c0e48dd Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Wed, 30 Nov 2016 15:06:13 +0000 Subject: [PATCH 12/12] LLL: simplify error handling in parseLLL --- liblll/Compiler.cpp | 14 +++----------- 1 file changed, 3 insertions(+), 11 deletions(-) diff --git a/liblll/Compiler.cpp b/liblll/Compiler.cpp index 73a82a35b..cd909f347 100644 --- a/liblll/Compiler.cpp +++ b/liblll/Compiler.cpp @@ -99,7 +99,6 @@ std::string dev::eth::compileLLLToAsm(std::string const& _src, bool _opt, std::v string dev::eth::parseLLL(string const& _src) { - bool failed = false; sp::utree o; try @@ -108,19 +107,12 @@ string dev::eth::parseLLL(string const& _src) } catch (...) { - failed = true; + killBigints(o); + return string(); } ostringstream ret; debugOutAST(ret, o); killBigints(o); - - if (failed) - { - return string(); - } - else - { - return ret.str(); - } + return ret.str(); }