lukechilds
/
ethminer
mirror of https://github.com/lukechilds/ethminer.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Clean up and organize tests + state class tests

cl-refactor
Christoph Jentzsch 10 years ago
parent
2e23abbbeb
commit
be3ccd3444
17 changed files with 340 additions and 508 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 7
      libdevcore/Exceptions.h
  2. 2
      libethereum/Account.h
  3. 2
      libethereum/State.cpp
  4. 6
      libethereum/State.h
  5. 4
      libevm/VM.h
  6. 2
      test/CMakeLists.txt
  7. 287
      test/TestHelper.cpp
  8. 51
      test/TestHelper.h
  9. 17
      test/genesis.cpp
  10. 15
      test/hexPrefix.cpp
  11. 6
      test/main.cpp
  12. 15
      test/rlp.cpp
  13. 173
      test/state.cpp
  14. 33
      test/tmpFiller.json
  15. 18
      test/trie.cpp
  16. 207
      test/vm.cpp
  17. 3
      test/vm.h

7
libdevcore/Exceptions.h
View File

@ -46,4 +46,11 @@ struct FileError: virtual Exception {};
typedef boost::error_info<struct tag_invalidSymbol, char> errinfo_invalidSymbol; typedef boost::error_info<struct tag_invalidSymbol, char> errinfo_invalidSymbol;
typedef boost::error_info<struct tag_address, std::string> errinfo_wrongAddress; typedef boost::error_info<struct tag_address, std::string> errinfo_wrongAddress;
typedef boost::error_info<struct tag_comment, std::string> errinfo_comment; typedef boost::error_info<struct tag_comment, std::string> errinfo_comment;
typedef boost::error_info<struct tag_required, int> errinfo_required;
typedef boost::error_info<struct tag_got, int> errinfo_got;
typedef boost::tuple<errinfo_required, errinfo_got> RequirementError;
} }

2
libethereum/Account.h
View File

@ -82,7 +82,7 @@ public:
/// Construct an alive Account, with given endowment, for either a normal (non-contract) account or for a /// Construct an alive Account, with given endowment, for either a normal (non-contract) account or for a
/// contract account in the /// contract account in the
/// conception phase, where the code is not yet known. /// conception phase, where the code is not yet known.
Account(u256 _balance, NewAccountType _t): m_isAlive(true), m_balance(_balance), m_codeHash(_t == NormalCreation ? c_contractConceptionCodeHash : EmptySHA3) {} Account(u256 _balance, NewAccountType _t): m_isAlive(true), m_balance(_balance), m_codeHash(_t == NormalCreation ? EmptySHA3 : c_contractConceptionCodeHash) {}
/// Explicit constructor for wierd cases of construction of a normal account. /// Explicit constructor for wierd cases of construction of a normal account.
Account(u256 _nonce, u256 _balance): m_isAlive(true), m_nonce(_nonce), m_balance(_balance) {} Account(u256 _nonce, u256 _balance): m_isAlive(true), m_nonce(_nonce), m_balance(_balance) {}

2
libethereum/State.cpp
View File

@ -1130,7 +1130,7 @@ u256 State::execute(bytesConstRef _rlp, bytes* o_output, bool _commit)
ctrace << toHex(e.t().rlp(true)); ctrace << toHex(e.t().rlp(true));
#endif #endif
e.go(); e.go(e.simpleTrace());
e.finalize(); e.finalize();
#if ETH_PARANOIA #if ETH_PARANOIA

6
libethereum/State.h
View File

@ -41,11 +41,11 @@
namespace dev namespace dev
{ {
namespace test { class ImportTest; }
namespace eth namespace eth
{ {
namespace test { class ImportTest; }
class BlockChain; class BlockChain;
struct StateChat: public LogChannel { static const char* name() { return "-S-"; } static const int verbosity = 4; }; struct StateChat: public LogChannel { static const char* name() { return "-S-"; } static const int verbosity = 4; };
@ -97,7 +97,7 @@ struct PrecompiledAddress
class State class State
{ {
friend class ExtVM; friend class ExtVM;
friend class test::ImportTest; friend class dev::test::ImportTest;
friend class Executive; friend class Executive;
public: public:

4
libevm/VM.h
View File

@ -41,7 +41,7 @@ struct BreakPointHit: virtual VMException {};
struct BadInstruction: virtual VMException {}; struct BadInstruction: virtual VMException {};
struct BadJumpDestination: virtual VMException {}; struct BadJumpDestination: virtual VMException {};
struct OutOfGas: virtual VMException {}; struct OutOfGas: virtual VMException {};
struct StackTooSmall: virtual public VMException { StackTooSmall(u256 _req, u256 _got): req(_req), got(_got) {} u256 req; u256 got; }; struct StackTooSmall: virtual public VMException {};
// Convert from a 256-bit integer stack/memory entry into a 160-bit Address hash. // Convert from a 256-bit integer stack/memory entry into a 160-bit Address hash.
// Currently we just pull out the right (low-order in BE) 160-bits. // Currently we just pull out the right (low-order in BE) 160-bits.
@ -71,7 +71,7 @@ public:
template <class Ext> template <class Ext>
bytesConstRef go(Ext& _ext, OnOpFunc const& _onOp = OnOpFunc(), uint64_t _steps = (uint64_t)-1); bytesConstRef go(Ext& _ext, OnOpFunc const& _onOp = OnOpFunc(), uint64_t _steps = (uint64_t)-1);
void require(u256 _n) { if (m_stack.size() < _n) BOOST_THROW_EXCEPTION(StackTooSmall(_n, m_stack.size())); } void require(u256 _n) { if (m_stack.size() < _n) BOOST_THROW_EXCEPTION(StackTooSmall() << RequirementError(int(_n), m_stack.size())); }
void requireMem(unsigned _n) { if (m_temp.size() < _n) { m_temp.resize(_n); } } void requireMem(unsigned _n) { if (m_temp.size() < _n) { m_temp.resize(_n); } }
u256 gas() const { return m_gas; } u256 gas() const { return m_gas; }
u256 curPC() const { return m_curPC; } u256 curPC() const { return m_curPC; }

2
test/CMakeLists.txt
View File

@ -9,7 +9,7 @@ link_directories(../libethereum)
file(GLOB HEADERS "*.h") file(GLOB HEADERS "*.h")
add_executable(testeth ${SRC_LIST} ${HEADERS}) add_executable(testeth ${SRC_LIST} ${HEADERS})
add_executable(createRandomTest createRandomTest.cpp vm.cpp) add_executable(createRandomTest createRandomTest.cpp vm.cpp TestHelper.cpp)
target_link_libraries(testeth ethereum) target_link_libraries(testeth ethereum)
target_link_libraries(testeth ethcore) target_link_libraries(testeth ethcore)

287
test/TestHelper.cpp
View File

@ -23,10 +23,14 @@
#include <thread> #include <thread>
#include <chrono> #include <chrono>
#include <boost/filesystem/path.hpp>
#include <libethereum/Client.h> #include <libethereum/Client.h>
#include <liblll/Compiler.h> #include <liblll/Compiler.h>
//#define FILL_TESTS
using namespace std; using namespace std;
using namespace dev::eth;
namespace dev namespace dev
{ {
@ -56,6 +60,7 @@ void connectClients(Client& c1, Client& c2)
c2.connect("127.0.0.1", c1Port); c2.connect("127.0.0.1", c1Port);
#endif #endif
} }
}
namespace test namespace test
{ {
@ -65,17 +70,12 @@ ImportTest::ImportTest(json_spirit::mObject& _o, bool isFiller):m_TestObject(_o)
importEnv(_o["env"].get_obj()); importEnv(_o["env"].get_obj());
importState(_o["pre"].get_obj(), m_statePre); importState(_o["pre"].get_obj(), m_statePre);
importExec(_o["exec"].get_obj()); importTransaction(_o["transaction"].get_obj());
if (!isFiller) if (!isFiller)
{ {
importState(_o["post"].get_obj(), m_statePost); importState(_o["post"].get_obj(), m_statePost);
//importCallCreates(_o["callcreates"].get_array());
importGas(_o);
importOutput(_o);
} }
// else
// m_TestObject = &_o; // if Filler then change Test object to prepare for export
} }
void ImportTest::importEnv(json_spirit::mObject& _o) void ImportTest::importEnv(json_spirit::mObject& _o)
@ -110,130 +110,61 @@ void ImportTest::importState(json_spirit::mObject& _o, State& _state)
assert(o.count("code") > 0); assert(o.count("code") > 0);
Address address = Address(i.first); Address address = Address(i.first);
_state.m_cache[address] = AddressState(toInt(o["nonce"]), toInt(o["balance"]), EmptyTrie, h256());
for (auto const& j: o["storage"].get_obj()) for (auto const& j: o["storage"].get_obj())
_state.setStorage(address, toInt(j.first), toInt(j.second)); _state.setStorage(address, toInt(j.first), toInt(j.second));
bytes code; bytes code = importCode(o);
if (o["code"].type() == json_spirit::str_type)
if (o["code"].get_str().find_first_of("0x") != 0) toInt(o["nonce"]);
code = compileLLL(o["code"].get_str(), false); if (toHex(code).size())
else
code = fromHex(o["code"].get_str().substr(2));
else
{ {
code.clear(); cout << "address: " << address << "has code: " << toHex(code) << endl;
for (auto const& j: o["code"].get_array()) _state.m_cache[address] = Account(toInt(o["balance"]), Account::ContractConception);
code.push_back(toByte(j)); i.second.get_obj()["code"] = "0x" + toHex(code); //preperation for export
_state.m_cache[address].setCode(bytesConstRef(&code));
} }
else
_state.m_cache[address] = Account(toInt(o["balance"]), Account::NormalCreation);
i.second.get_obj()["code"] = "0x" + toHex(code); //preperation for export for(int i=0; i<toInt(o["nonce"]); ++i)
_state.noteSending(address);
_state.m_cache[address].setCode(bytesConstRef(&code)); _state.ensureCached(address, false, false);
_state.ensureCached(address, true, true);
} }
} }
void ImportTest::importExec(json_spirit::mObject& _o) void ImportTest::importTransaction(json_spirit::mObject& _o)
{ {
assert(_o.count("address")> 0); assert(_o.count("nonce")> 0);
assert(_o.count("caller") > 0); assert(_o.count("gasPrice") > 0);
assert(_o.count("origin") > 0); assert(_o.count("gasLimit") > 0);
assert(_o.count("to") > 0);
assert(_o.count("value") > 0); assert(_o.count("value") > 0);
assert(_o.count("secretKey") > 0);
assert(_o.count("data") > 0); assert(_o.count("data") > 0);
assert(_o.count("gasPrice") > 0);
assert(_o.count("gas") > 0);
//assert(_o.count("code") > 0);
m_environment.myAddress = Address(_o["address"].get_str()); m_transaction.nonce = toInt(_o["nonce"]);
m_environment.caller = Address(_o["caller"].get_str()); m_transaction.gasPrice = toInt(_o["gasPrice"]);
m_environment.origin = Address(_o["origin"].get_str()); m_transaction.gas = toInt(_o["gasLimit"]);
m_environment.value = toInt(_o["value"]); m_transaction.receiveAddress = Address(_o["to"].get_str());
m_environment.gasPrice = toInt(_o["gasPrice"]); m_transaction.type = m_transaction.receiveAddress ? Transaction::MessageCall : Transaction::ContractCreation;
gasExec = toInt(_o["gas"]); m_transaction.value = toInt(_o["value"]);
Secret secretKey = Secret(_o["secretKey"].get_str());
if (_o["code"].type() == json_spirit::str_type) m_transaction.sign(secretKey);
if (_o["code"].get_str().find_first_of("0x") == 0) m_transaction.data = importData(_o);
code = fromHex(_o["code"].get_str().substr(2));
else
code = compileLLL(_o["code"].get_str());
else if (_o["code"].type() == json_spirit::array_type)
for (auto const& j: _o["code"].get_array())
code.push_back(toByte(j));
else
m_environment.code.reset();
m_environment.code = &code;
if (_o["data"].type() == json_spirit::str_type)
if (_o["data"].get_str().find_first_of("0x") == 0)
data = fromHex(_o["data"].get_str().substr(2));
else
data = fromHex(_o["data"].get_str());
else
for (auto const& j: _o["data"].get_array())
data.push_back(toByte(j));
m_environment.data = &data;
} }
void ImportTest::importCallCreates(json_spirit::mArray& _callcreates) void ImportTest::exportTest(bytes _output, State& _statePost)
{ {
for (json_spirit::mValue& v: _callcreates)
{
auto tx = v.get_obj();
assert(tx.count("data") > 0);
assert(tx.count("value") > 0);
assert(tx.count("destination") > 0);
assert(tx.count("gasLimit") > 0);
Transaction t;
t.type = tx["destination"].get_str().empty() ? Transaction::ContractCreation : Transaction::MessageCall;
t.receiveAddress = Address(tx["destination"].get_str());
t.value = toInt(tx["value"]);
t.gas = toInt(tx["gasLimit"]);
if (tx["data"].type() == json_spirit::str_type)
if (tx["data"].get_str().find_first_of("0x") == 0)
t.data = fromHex(tx["data"].get_str().substr(2));
else
t.data = fromHex(tx["data"].get_str());
else
for (auto const& j: tx["data"].get_array())
t.data.push_back(toByte(j));
callcreates.push_back(t);
}
}
void ImportTest::importGas(json_spirit::mObject& _o)
{
gas = toInt(_o["gas"]);
}
void ImportTest::importOutput(json_spirit::mObject& _o)
{
int i = 0;
if (_o["out"].type() == json_spirit::array_type)
for (auto const& d: _o["out"].get_array())
{
output[i] = uint8_t(toInt(d));
++i;
}
else if (_o["out"].get_str().find("0x") == 0)
output = fromHex(_o["out"].get_str().substr(2));
else
output = fromHex(_o["out"].get_str());
}
void ImportTest::exportTest(bytes _output, u256 _gas, State& _statePost)
{
// export gas
m_TestObject["gas"] = toString(_gas);
// export output // export output
m_TestObject["out"] = "0x" + toHex(_output); m_TestObject["out"] = "0x" + toHex(_output);
// export post state // export post state
json_spirit::mObject postState; json_spirit::mObject postState;
std::map<Address, AddressState> genesis = genesisState(); std::map<Address, Account> genesis = genesisState();
for (auto const& a: _statePost.addresses()) for (auto const& a: _statePost.addresses())
{ {
@ -254,22 +185,6 @@ void ImportTest::exportTest(bytes _output, u256 _gas, State& _statePost)
postState[toString(a.first)] = o; postState[toString(a.first)] = o;
} }
m_TestObject["post"] = json_spirit::mValue(postState); m_TestObject["post"] = json_spirit::mValue(postState);
m_TestObject["exec"].get_obj()["code"] = "0x" + toHex(code);
// // export callcreates
// m_TestObject["callcreates"] = exportCallCreates();
// for (int i = 0; i < (m_manifest.internal.size(); ++i)
// {
// Transaction t;
// t.value = m_manifest.internal[i].value;
// t.gas = ;
// t.data = m_manifest.internal[i].input; ;
// t.receiveAddress = m_manifest.internal[i].to;
// t.type =
// }
} }
u256 toInt(json_spirit::mValue const& _v) u256 toInt(json_spirit::mValue const& _v)
@ -298,5 +213,131 @@ byte toByte(json_spirit::mValue const& _v)
return 0; return 0;
} }
bytes importData(json_spirit::mObject & _o)
{
bytes data;
if (_o["data"].type() == json_spirit::str_type)
if (_o["data"].get_str().find_first_of("0x") == 0)
data = fromHex(_o["data"].get_str().substr(2));
else
data = fromHex(_o["data"].get_str());
else
for (auto const& j: _o["data"].get_array())
data.push_back(toByte(j));
return data;
}
bytes importCode(json_spirit::mObject & _o)
{
bytes code;
if (_o["code"].type() == json_spirit::str_type)
if (_o["code"].get_str().find_first_of("0x") != 0)
code = compileLLL(_o["code"].get_str(), false);
else
code = fromHex(_o["code"].get_str().substr(2));
else if (_o["code"].type() == json_spirit::array_type)
{
code.clear();
for (auto const& j: _o["code"].get_array())
code.push_back(toByte(j));
}
return code;
}
void checkOutput(bytes const& _output, json_spirit::mObject & _o)
{
int j = 0;
if (_o["out"].type() == json_spirit::array_type)
for (auto const& d: _o["out"].get_array())
{
BOOST_CHECK_MESSAGE(_output[j] == toInt(d), "Output byte [" << j << "] different!");
++j;
}
else if (_o["out"].get_str().find("0x") == 0)
BOOST_CHECK(_output == fromHex(_o["out"].get_str().substr(2)));
else
BOOST_CHECK(_output == fromHex(_o["out"].get_str()));
}
void checkStorage(map<u256, u256> _expectedStore, map<u256, u256> _resultStore, Address _expectedAddr)
{
for (auto&& expectedStorePair : _expectedStore)
{
auto& expectedStoreKey = expectedStorePair.first;
auto resultStoreIt = _resultStore.find(expectedStoreKey);
if (resultStoreIt == _resultStore.end())
BOOST_ERROR(_expectedAddr << ": missing store key " << expectedStoreKey);
else
{
auto& expectedStoreValue = expectedStorePair.second;
auto& resultStoreValue = resultStoreIt->second;
BOOST_CHECK_MESSAGE(expectedStoreValue == resultStoreValue, _expectedAddr << ": store[" << expectedStoreKey << "] = " << resultStoreValue << ", expected " << expectedStoreValue);
}
}
}
std::string getTestPath()
{
string testPath;
const char* ptestPath = getenv("ETHEREUM_TEST_PATH");
if (ptestPath == NULL)
{
cnote << " could not find environment variable ETHEREUM_TEST_PATH \n";
testPath = "../../../tests";
}
else
testPath = ptestPath;
return testPath;
}
void executeTests(const string& _name, const string& _testPathAppendix, std::function<void(json_spirit::mValue&, bool)> doTests)
{
string testPath = getTestPath();
testPath += _testPathAppendix;
#ifdef FILL_TESTS
try
{
cnote << "Populating tests...";
json_spirit::mValue v;
boost::filesystem::path p(__FILE__);
boost::filesystem::path dir = p.parent_path();
string s = asString(dev::contents(dir.string() + "/" + _name + "Filler.json"));
BOOST_REQUIRE_MESSAGE(s.length() > 0, "Contents of " + dir.string() + "/" + _name + "Filler.json is empty.");
json_spirit::read_string(s, v);
doTests(v, true);
writeFile(testPath + "/" + _name + ".json", asBytes(json_spirit::write_string(v, true)));
}
catch (Exception const& _e)
{
BOOST_ERROR("Failed test with Exception: " << diagnostic_information(_e));
}
catch (std::exception const& _e)
{
BOOST_ERROR("Failed test with Exception: " << _e.what());
}
#endif
try
{
cnote << "Testing ..." << _name;
json_spirit::mValue v;
string s = asString(dev::contents(testPath + "/" + _name + ".json"));
BOOST_REQUIRE_MESSAGE(s.length() > 0, "Contents of " + testPath + "/" + _name + ".json is empty. Have you cloned the 'tests' repo branch develop and set ETHEREUM_TEST_PATH to its path?");
json_spirit::read_string(s, v);
doTests(v, false);
}
catch (Exception const& _e)
{
BOOST_ERROR("Failed test with Exception: " << diagnostic_information(_e));
}
catch (std::exception const& _e)
{
BOOST_ERROR("Failed test with Exception: " << _e.what());
}
}
} } } // namespaces } } // namespaces

51
test/TestHelper.h
View File

@ -21,6 +21,8 @@
#pragma once #pragma once
#include <functional>
#include <boost/test/unit_test.hpp>
#include "JsonSpiritHeaders.h" #include "JsonSpiritHeaders.h"
#include <libethereum/State.h> #include <libethereum/State.h>
@ -34,6 +36,8 @@ class Client;
void mine(Client& c, int numBlocks); void mine(Client& c, int numBlocks);
void connectClients(Client& c1, Client& c2); void connectClients(Client& c1, Client& c2);
}
namespace test namespace test
{ {
@ -45,31 +49,26 @@ public:
// imports // imports
void importEnv(json_spirit::mObject& _o); void importEnv(json_spirit::mObject& _o);
void importState(json_spirit::mObject& _o, State& _state); void importState(json_spirit::mObject& _o, eth::State& _state);
void importExec(json_spirit::mObject& _o); void importTransaction(json_spirit::mObject& _o);
void importCallCreates(json_spirit::mArray& _callcreates); void exportTest(bytes _output, eth::State& _statePost);
void importGas(json_spirit::mObject& _o); eth::Manifest* getManifest(){ return &m_manifest;}
void importOutput(json_spirit::mObject& _o);
eth::State m_statePre;
void exportTest(bytes _output, u256 _gas, State& _statePost); eth::State m_statePost;
Manifest* getManifest(){ return &m_manifest;} eth::ExtVMFace m_environment;
State m_statePre;
State m_statePost;
ExtVMFace m_environment;
u256 gas; u256 gas;
u256 gasExec; u256 gasExec;
Transactions callcreates; eth::Transaction m_transaction;
bytes output; bytes output;
Manifest m_manifest; eth::Manifest m_manifest;
bytes code; bytes code;
private: private:
json_spirit::mObject& m_TestObject; json_spirit::mObject& m_TestObject;
// needed for const refs // needed for const ref
bytes data; bytes data;
}; };
@ -77,7 +76,25 @@ private:
u256 toInt(json_spirit::mValue const& _v); u256 toInt(json_spirit::mValue const& _v);
byte toByte(json_spirit::mValue const& _v); byte toByte(json_spirit::mValue const& _v);
bytes importCode(json_spirit::mObject &_o);
bytes importData(json_spirit::mObject &_o);
void checkOutput(bytes const& _output, json_spirit::mObject &_o);
void checkStorage(std::map<u256, u256> _expectedStore, std::map<u256, u256> _resultStore, Address _expectedAddr);
void executeTests(const std::string& _name, const std::string& _testPathAppendix, std::function<void(json_spirit::mValue&, bool)> doTests);
std::string getTestPath();
template<typename mapType>
void checkAddresses(mapType& _expectedAddrs, mapType& _resultAddrs)
{
for (auto& resultPair : _resultAddrs)
{
auto& resultAddr = resultPair.first;
auto expectedAddrIt = _expectedAddrs.find(resultAddr);
if (expectedAddrIt == _expectedAddrs.end())
BOOST_ERROR("Missing result address " << resultAddr);
}
BOOST_CHECK(_expectedAddrs == _resultAddrs);
} }
} }
} }

17
test/genesis.cpp
View File

@ -26,6 +26,7 @@
#include <libdevcore/CommonIO.h> #include <libdevcore/CommonIO.h>
#include <libethereum/BlockChain.h> #include <libethereum/BlockChain.h>
#include <boost/test/unit_test.hpp> #include <boost/test/unit_test.hpp>
#include "TestHelper.h"
using namespace std; using namespace std;
using namespace dev; using namespace dev;
@ -33,18 +34,12 @@ using namespace dev::eth;
namespace js = json_spirit; namespace js = json_spirit;
BOOST_AUTO_TEST_SUITE(BasicTests)
BOOST_AUTO_TEST_CASE(genesis_tests) BOOST_AUTO_TEST_CASE(genesis_tests)
{ {
const char* ptestPath = getenv("ETHEREUM_TEST_PATH"); string testPath = test::getTestPath();
string testPath; testPath += "/BasicTests";
if (ptestPath == NULL)
{
cnote << " could not find environment variable ETHEREUM_TEST_PATH \n";
testPath = "../../../tests";
}
else
testPath = ptestPath;
cnote << "Testing Genesis block..."; cnote << "Testing Genesis block...";
js::mValue v; js::mValue v;
@ -59,3 +54,5 @@ BOOST_AUTO_TEST_CASE(genesis_tests)
BOOST_CHECK_EQUAL(sha3(BlockChain::createGenesisBlock()), h256(o["genesis_hash"].get_str())); BOOST_CHECK_EQUAL(sha3(BlockChain::createGenesisBlock()), h256(o["genesis_hash"].get_str()));
} }
BOOST_AUTO_TEST_SUITE_END()

15
test/hexPrefix.cpp
View File

@ -26,23 +26,19 @@
#include <libdevcore/CommonIO.h> #include <libdevcore/CommonIO.h>
#include <libdevcrypto/TrieCommon.h> #include <libdevcrypto/TrieCommon.h>
#include <boost/test/unit_test.hpp> #include <boost/test/unit_test.hpp>
#include "TestHelper.h"
using namespace std; using namespace std;
using namespace dev; using namespace dev;
namespace js = json_spirit; namespace js = json_spirit;
BOOST_AUTO_TEST_SUITE(BasicTests)
BOOST_AUTO_TEST_CASE(hexPrefix_test) BOOST_AUTO_TEST_CASE(hexPrefix_test)
{ {
const char* ptestPath = getenv("ETHEREUM_TEST_PATH");
string testPath;
if (ptestPath == NULL) string testPath = test::getTestPath();
{ testPath += "/BasicTests";
cnote << " could not find environment variable ETHEREUM_TEST_PATH \n";
testPath = "../../../tests";
}
else
testPath = ptestPath;
cnote << "Testing Hex-Prefix-Encode..."; cnote << "Testing Hex-Prefix-Encode...";
js::mValue v; js::mValue v;
@ -62,3 +58,4 @@ BOOST_AUTO_TEST_CASE(hexPrefix_test)
} }
} }
BOOST_AUTO_TEST_SUITE_END()

6
test/main.cpp
View File

@ -41,8 +41,8 @@ using namespace std;
using namespace dev; using namespace dev;
using namespace dev::eth; using namespace dev::eth;
BOOST_AUTO_TEST_CASE(basic_tests) //BOOST_AUTO_TEST_CASE(basic_tests)
{ //{
/* RLPStream s; /* RLPStream s;
BlockInfo::genesis().streamRLP(s, false); BlockInfo::genesis().streamRLP(s, false);
std::cout << RLP(s.out()) << std::endl; std::cout << RLP(s.out()) << std::endl;
@ -54,5 +54,5 @@ BOOST_AUTO_TEST_CASE(basic_tests)
// r += stateTest(); // r += stateTest();
// r += peerTest(argc, argv); // r += peerTest(argc, argv);
// BOOST_REQUIRE(!r); // BOOST_REQUIRE(!r);
} //}

15
test/rlp.cpp
View File

@ -29,6 +29,7 @@
#include <boost/test/unit_test.hpp> #include <boost/test/unit_test.hpp>
#include <algorithm> #include <algorithm>
#include "JsonSpiritHeaders.h" #include "JsonSpiritHeaders.h"
#include "TestHelper.h"
using namespace std; using namespace std;
using namespace dev; using namespace dev;
@ -61,16 +62,8 @@ namespace dev
static void getRLPTestCases(js::mValue& v) static void getRLPTestCases(js::mValue& v)
{ {
const char* ptestPath = getenv("ETHEREUM_TEST_PATH"); string testPath = getTestPath();
string testPath; testPath += "/BasicTests";
if (ptestPath == NULL)
{
cnote << " could not find environment variable ETHEREUM_TEST_PATH \n";
testPath = "../../../tests";
}
else
testPath = ptestPath;
string s = asString(contents(testPath + "/rlptest.json")); string s = asString(contents(testPath + "/rlptest.json"));
BOOST_REQUIRE_MESSAGE( s.length() > 0, BOOST_REQUIRE_MESSAGE( s.length() > 0,
@ -144,6 +137,7 @@ namespace dev
} }
} }
BOOST_AUTO_TEST_SUITE(BasicTests)
BOOST_AUTO_TEST_CASE(rlp_encoding_test) BOOST_AUTO_TEST_CASE(rlp_encoding_test)
{ {
@ -202,4 +196,5 @@ BOOST_AUTO_TEST_CASE(rlp_decoding_test)
} }
} }
BOOST_AUTO_TEST_SUITE_END()

173
test/state.cpp
View File

@ -37,20 +37,15 @@ using namespace std;
using namespace json_spirit; using namespace json_spirit;
using namespace dev; using namespace dev;
using namespace dev::eth; using namespace dev::eth;
using namespace dev::eth::test; using namespace dev::eth;
class FakeState: public State
{
};
namespace dev { namespace eth{ namespace test { namespace dev { namespace test {
void doStateTests(json_spirit::mValue& v, bool _fillin) void doStateTests(json_spirit::mValue& v, bool _fillin)
{ {
cout << "start state test\n";
for (auto& i: v.get_obj()) for (auto& i: v.get_obj())
{ {
cnote << i.first; cnote << i.first;
@ -58,7 +53,7 @@ void doStateTests(json_spirit::mValue& v, bool _fillin)
BOOST_REQUIRE(o.count("env") > 0); BOOST_REQUIRE(o.count("env") > 0);
BOOST_REQUIRE(o.count("pre") > 0); BOOST_REQUIRE(o.count("pre") > 0);
BOOST_REQUIRE(o.count("exec") > 0); BOOST_REQUIRE(o.count("transaction") > 0);
ImportTest importer(o,_fillin); ImportTest importer(o,_fillin);
@ -68,57 +63,47 @@ void doStateTests(json_spirit::mValue& v, bool _fillin)
importer.m_environment.code = &importer.code; importer.m_environment.code = &importer.code;
} }
ExtVM evm(importer.m_statePre, importer.m_environment.myAddress, State theState = importer.m_statePre;
importer.m_environment.caller, importer.m_environment.origin,
importer.m_environment.value, importer.m_environment.gasPrice, bytes tx = importer.m_transaction.rlp();
importer.m_environment.data, importer.m_environment.code,
importer.getManifest());
bytes output; bytes output;
VM vm(importer.gasExec);
// check
for (auto const& a: theState.addresses())
{
cout << "address: " << a.first << endl;
cout << "balance: " << theState.balance(a.first) << endl;
cout << "has code: " << theState.addressHasCode(a.first) << endl;
}
try try
{ {
output = vm.go(evm, Executive::simpleTrace()).toVector(); theState.execute(tx, &output);
} }
catch (Exception const& _e) catch (Exception const& _e)
{ {
cnote << "VM did throw an exception: " << diagnostic_information(_e); cnote << "state execution did throw an exception: " << diagnostic_information(_e);
//BOOST_ERROR("Failed VM Test with Exception: " << e.what());
} }
catch (std::exception const& _e) catch (std::exception const& _e)
{ {
cnote << "VM did throw an exception: " << _e.what(); cnote << "state execution did throw an exception: " << _e.what();
//BOOST_ERROR("Failed VM Test with Exception: " << e.what());
} }
if (_fillin) if (_fillin)
importer.exportTest(output, vm.gas(), evm.state()); importer.exportTest(output, theState);
else else
{ {
BOOST_REQUIRE(o.count("post") > 0); BOOST_REQUIRE(o.count("post") > 0);
//BOOST_REQUIRE(o.count("callcreates") > 0);
BOOST_REQUIRE(o.count("out") > 0); BOOST_REQUIRE(o.count("out") > 0);
BOOST_REQUIRE(o.count("gas") > 0);
// check output // check output
checkOutput(output, o);
int j = 0; // check addresses
if (o["out"].type() == array_type)
for (auto const& d: o["out"].get_array())
{
BOOST_CHECK_MESSAGE(output[j] == toInt(d), "Output byte [" << j << "] different!");
++j;
}
else if (o["out"].get_str().find("0x") == 0)
BOOST_CHECK(output == fromHex(o["out"].get_str().substr(2)));
else
BOOST_CHECK(output == fromHex(o["out"].get_str()));
BOOST_CHECK_EQUAL(toInt(o["gas"]), vm.gas());
auto expectedAddrs = importer.m_statePost.addresses(); auto expectedAddrs = importer.m_statePost.addresses();
auto resultAddrs = evm.state().addresses(); auto resultAddrs = theState.addresses();
for (auto& expectedPair : expectedAddrs) for (auto& expectedPair : expectedAddrs)
{ {
auto& expectedAddr = expectedPair.first; auto& expectedAddr = expectedPair.first;
@ -127,115 +112,37 @@ void doStateTests(json_spirit::mValue& v, bool _fillin)
BOOST_ERROR("Missing expected address " << expectedAddr); BOOST_ERROR("Missing expected address " << expectedAddr);
else else
{ {
BOOST_CHECK_MESSAGE(importer.m_statePost.balance(expectedAddr) == evm.state().balance(expectedAddr), expectedAddr << ": incorrect balance " << evm.state().balance(expectedAddr) << ", expected " << importer.m_statePost.balance(expectedAddr)); BOOST_CHECK_MESSAGE(importer.m_statePost.balance(expectedAddr) == theState.balance(expectedAddr), expectedAddr << ": incorrect balance " << theState.balance(expectedAddr) << ", expected " << importer.m_statePost.balance(expectedAddr));
BOOST_CHECK_MESSAGE(importer.m_statePost.transactionsFrom(expectedAddr) == evm.state().transactionsFrom(expectedAddr), expectedAddr << ": incorrect txCount " << evm.state().transactionsFrom(expectedAddr) << ", expected " << importer.m_statePost.transactionsFrom(expectedAddr)); BOOST_CHECK_MESSAGE(importer.m_statePost.transactionsFrom(expectedAddr) == theState.transactionsFrom(expectedAddr), expectedAddr << ": incorrect txCount " << theState.transactionsFrom(expectedAddr) << ", expected " << importer.m_statePost.transactionsFrom(expectedAddr));
BOOST_CHECK_MESSAGE(importer.m_statePost.code(expectedAddr) == evm.state().code(expectedAddr), expectedAddr << ": incorrect code"); BOOST_CHECK_MESSAGE(importer.m_statePost.code(expectedAddr) == theState.code(expectedAddr), expectedAddr << ": incorrect code");
auto&& expectedStore = importer.m_statePost.storage(expectedAddr);
auto&& resultStore = evm.state().storage(expectedAddr);
for (auto&& expectedStorePair : expectedStore)
{
auto& expectedStoreKey = expectedStorePair.first;
auto resultStoreIt = resultStore.find(expectedStoreKey);
if (resultStoreIt == resultStore.end())
BOOST_ERROR(expectedAddr << ": missing store key " << expectedStoreKey);
else
{
auto& expectedStoreValue = expectedStorePair.second;
auto& resultStoreValue = resultStoreIt->second;
BOOST_CHECK_MESSAGE(expectedStoreValue == resultStoreValue, expectedAddr << ": store[" << expectedStoreKey << "] = " << resultStoreValue << ", expected " << expectedStoreValue);
}
}
}
}
for (auto& resultPair : resultAddrs) checkStorage(importer.m_statePost.storage(expectedAddr), theState.storage(expectedAddr), expectedAddr);
{ }
auto& resultAddr = resultPair.first;
auto expectedAddrIt = expectedAddrs.find(resultAddr);
if (expectedAddrIt == expectedAddrs.end())
BOOST_ERROR("Missing result address " << resultAddr);
} }
checkAddresses<map<Address, u256> >(expectedAddrs, resultAddrs);
BOOST_CHECK(evm.state().addresses() == importer.m_statePost.addresses()); // Just to make sure nothing missed
//BOOST_CHECK(evm.callcreates == importer.callcreates);
} }
} }
} }
} }// Namespace Close
BOOST_AUTO_TEST_SUITE(StateTests)
void executeStateTests(const string& _name) BOOST_AUTO_TEST_CASE(stExample)
{ {
const char* ptestPath = getenv("ETHEREUM_TEST_PATH"); dev::test::executeTests("stExample", "/StateTests", dev::test::doStateTests);
string testPath;
if (ptestPath == NULL)
{
cnote << " could not find environment variable ETHEREUM_TEST_PATH \n";
testPath = "../../../tests";
}
else
testPath = ptestPath;
testPath += "/statetests";
#ifdef FILL_TESTS
try
{
cnote << "Populating VM tests...";
json_spirit::mValue v;
boost::filesystem::path p(__FILE__);
boost::filesystem::path dir = p.parent_path();
string s = asString(dev::contents(dir.string() + "/" + _name + "Filler.json"));
BOOST_REQUIRE_MESSAGE(s.length() > 0, "Contents of " + dir.string() + "/" + _name + "Filler.json is empty.");
json_spirit::read_string(s, v);
doStateTests(v, true);
writeFile(testPath + "/" + _name + ".json", asBytes(json_spirit::write_string(v, true)));
}
catch (Exception const& _e)
{
BOOST_ERROR("Failed VM Test with Exception: " << diagnostic_information(_e));
}
catch (std::exception const& _e)
{
BOOST_ERROR("Failed VM Test with Exception: " << _e.what());
}
#endif
try
{
cnote << "Testing VM..." << _name;
json_spirit::mValue v;
string s = asString(dev::contents(testPath + "/" + _name + ".json"));
BOOST_REQUIRE_MESSAGE(s.length() > 0, "Contents of " + testPath + "/" + _name + ".json is empty. Have you cloned the 'tests' repo branch develop and set ETHEREUM_TEST_PATH to its path?");
json_spirit::read_string(s, v);
doStateTests(v, false);
}
catch (Exception const& _e)
{
BOOST_ERROR("Failed VM Test with Exception: " << diagnostic_information(_e));
}
catch (std::exception const& _e)
{
BOOST_ERROR("Failed VM Test with Exception: " << _e.what());
}
} }
} } }// Namespace Close
BOOST_AUTO_TEST_CASE(vmSystemOperationsTest) //BOOST_AUTO_TEST_CASE(stSystemOperationsTest)
{ //{
dev::eth::test::executeStateTests("stSystemOperationsTest"); // dev::test::executeStateTests("stSystemOperationsTest");
} //}
BOOST_AUTO_TEST_CASE(tmp) BOOST_AUTO_TEST_CASE(tmp)
{ {
std::cout << "Doing systemoperationsTest in state\n";
int currentVerbosity = g_logVerbosity; int currentVerbosity = g_logVerbosity;
g_logVerbosity = 12; g_logVerbosity = 12;
dev::eth::test::executeStateTests("tmp"); dev::test::executeTests("tmp", "/StateTests", dev::test::doStateTests);
g_logVerbosity = currentVerbosity; g_logVerbosity = currentVerbosity;
} }
BOOST_AUTO_TEST_SUITE_END()

33
test/tmpFiller.json
View File

@ -1,5 +1,5 @@
{ {
"ABAcallsSuicide0": { "ABAcalls0": {
"env" : { "env" : {
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6", "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
"currentNumber" : "0", "currentNumber" : "0",
@ -9,29 +9,36 @@
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba" "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
}, },
"pre" : { "pre" : {
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : { "095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
"balance" : "1000000000000000000", "balance" : "1000000000000000000",
"nonce" : 0, "nonce" : 0,
"code" : "{ [[ (PC) ]] (CALL 1000 0x945304eb96065b2a98b57a48a06ae28d285a71b5 24 0 0 0 0) (SUICIDE 0x945304eb96065b2a98b57a48a06ae28d285a71b5) }", "code" : "{ [[ (PC) ]] (CALL 1000 0x945304eb96065b2a98b57a48a06ae28d285a71b5 24 0 0 0 0) }",
"storage": {} "storage": {}
}, },
"945304eb96065b2a98b57a48a06ae28d285a71b5" : { "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
"balance" : "23", "balance" : "23",
"code" : "{ [[ (PC) ]] (ADD 1 (CALL 500 0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6 23 0 0 0 0)) } ", "code" : " { [[ (PC) ]] (ADD 1 (CALL 500 0x095e7baea6a6c7c4c2dfeb977efac326af552d87 23 0 0 0 0)) } ",
"nonce" : "0", "nonce" : "0",
"storage" : { "storage" : {
} }
},
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
"balance" : "1000000000000000000",
"nonce" : 0,
"code" : "",
"storage": {}
} }
}, },
"exec" : { "transaction" : {
"address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6", "nonce" : "0",
"origin" : "cd1722f3947def4cf144679da39c4c32bdc35681", "gasPrice" : "1",
"caller" : "cd1722f3947def4cf144679da39c4c32bdc35681", "gasLimit" : "10000",
"value" : "100000", "to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
"data" : "", "value" : "100000",
"gasPrice" : "100000000000000", "secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
"gas" : "10000000000000" "data" : ""
} }
} }
} }

18
test/trie.cpp
View File

@ -28,6 +28,7 @@
#include "TrieHash.h" #include "TrieHash.h"
#include "MemTrie.h" #include "MemTrie.h"
#include <boost/test/unit_test.hpp> #include <boost/test/unit_test.hpp>
#include "TestHelper.h"
using namespace std; using namespace std;
using namespace dev; using namespace dev;
@ -47,18 +48,14 @@ static unsigned fac(unsigned _i)
} }
} }
BOOST_AUTO_TEST_SUITE(TrieTests)
BOOST_AUTO_TEST_CASE(trie_tests) BOOST_AUTO_TEST_CASE(trie_tests)
{ {
const char* ptestPath = getenv("ETHEREUM_TEST_PATH"); string testPath = test::getTestPath();
string testPath;
if (ptestPath == NULL)
{ testPath += "/TrieTests";
cnote << " could not find environment variable ETHEREUM_TEST_PATH \n";
testPath = "../../../tests";
}
else
testPath = ptestPath;
cnote << "Testing Trie..."; cnote << "Testing Trie...";
js::mValue v; js::mValue v;
@ -364,3 +361,6 @@ BOOST_AUTO_TEST_CASE(trieStess)
} }
} }
BOOST_AUTO_TEST_SUITE_END()

207
test/vm.cpp
View File

@ -20,11 +20,8 @@
* vm test functions. * vm test functions.
*/ */
#include <boost/filesystem/path.hpp>
#include "vm.h" #include "vm.h"
//#define FILL_TESTS
using namespace std; using namespace std;
using namespace json_spirit; using namespace json_spirit;
using namespace dev; using namespace dev;
@ -59,6 +56,8 @@ bool FakeExtVM::call(Address _receiveAddress, u256 _value, bytesConstRef _data,
t.receiveAddress = _receiveAddress; t.receiveAddress = _receiveAddress;
callcreates.push_back(t); callcreates.push_back(t);
(void)_out; (void)_out;
(void)_myAddressOverride;
(void)_codeAddressOverride;
return true; return true;
} }
@ -91,45 +90,13 @@ void FakeExtVM::reset(u256 _myBalance, u256 _myNonce, map<u256, u256> const& _st
set(myAddress, _myBalance, _myNonce, _storage, get<3>(addresses[myAddress])); set(myAddress, _myBalance, _myNonce, _storage, get<3>(addresses[myAddress]));
} }
u256 FakeExtVM::toInt(mValue const& _v)
{
switch (_v.type())
{
case str_type: return u256(_v.get_str());
case int_type: return (u256)_v.get_uint64();
case bool_type: return (u256)(uint64_t)_v.get_bool();
case real_type: return (u256)(uint64_t)_v.get_real();
default: cwarn << "Bad type for scalar: " << _v.type();
}
return 0;
}
byte FakeExtVM::toByte(mValue const& _v)
{
switch (_v.type())
{
case str_type: return (byte)stoi(_v.get_str());
case int_type: return (byte)_v.get_uint64();
case bool_type: return (byte)_v.get_bool();
case real_type: return (byte)_v.get_real();
default: cwarn << "Bad type for scalar: " << _v.type();
}
return 0;
}
void FakeExtVM::push(mObject& o, string const& _n, u256 _v) void FakeExtVM::push(mObject& o, string const& _n, u256 _v)
{ {
// if (_v < (u256)1 << 64)
// o[_n] = (uint64_t)_v;
// else
o[_n] = toString(_v); o[_n] = toString(_v);
} }
void FakeExtVM::push(mArray& a, u256 _v) void FakeExtVM::push(mArray& a, u256 _v)
{ {
// if (_v < (u256)1 << 64)
// a.push_back((uint64_t)_v);
// else
a.push_back(toString(_v)); a.push_back(toString(_v));
} }
@ -202,17 +169,7 @@ void FakeExtVM::importState(mObject& _object)
for (auto const& j: o["storage"].get_obj()) for (auto const& j: o["storage"].get_obj())
get<2>(a)[toInt(j.first)] = toInt(j.second); get<2>(a)[toInt(j.first)] = toInt(j.second);
if (o["code"].type() == str_type) get<3>(a) = importCode(o);
if (o["code"].get_str().find_first_of("0x") != 0)
get<3>(a) = compileLLL(o["code"].get_str(), false);
else
get<3>(a) = fromHex(o["code"].get_str().substr(2));
else
{
get<3>(a).clear();
for (auto const& j: o["code"].get_array())
get<3>(a).push_back(toByte(j));
}
} }
} }
@ -250,26 +207,14 @@ void FakeExtVM::importExec(mObject& _o)
thisTxCode.clear(); thisTxCode.clear();
code = &thisTxCode; code = &thisTxCode;
if (_o["code"].type() == str_type)
if (_o["code"].get_str().find_first_of("0x") == 0) thisTxCode = importCode(_o);
thisTxCode = fromHex(_o["code"].get_str().substr(2)); if (_o["code"].type() != str_type && _o["code"].type() != array_type)
else
thisTxCode = compileLLL(_o["code"].get_str());
else if (_o["code"].type() == array_type)
for (auto const& j: _o["code"].get_array())
thisTxCode.push_back(toByte(j));
else
code.reset(); code.reset();
thisTxData.clear(); thisTxData.clear();
if (_o["data"].type() == str_type) thisTxData = importData(_o);
if (_o["data"].get_str().find_first_of("0x") == 0)
thisTxData = fromHex(_o["data"].get_str().substr(2));
else
thisTxData = fromHex(_o["data"].get_str());
else
for (auto const& j: _o["data"].get_array())
thisTxData.push_back(toByte(j));
data = &thisTxData; data = &thisTxData;
} }
@ -302,14 +247,7 @@ void FakeExtVM::importCallCreates(mArray& _callcreates)
t.receiveAddress = Address(tx["destination"].get_str()); t.receiveAddress = Address(tx["destination"].get_str());
t.value = toInt(tx["value"]); t.value = toInt(tx["value"]);
t.gas = toInt(tx["gasLimit"]); t.gas = toInt(tx["gasLimit"]);
if (tx["data"].type() == str_type) t.data = importData(tx);
if (tx["data"].get_str().find_first_of("0x") == 0)
t.data = fromHex(tx["data"].get_str().substr(2));
else
t.data = fromHex(tx["data"].get_str());
else
for (auto const& j: tx["data"].get_array())
t.data.push_back(toByte(j));
callcreates.push_back(t); callcreates.push_back(t);
} }
} }
@ -346,7 +284,7 @@ eth::OnOpFunc FakeExtVM::simpleTrace()
namespace dev { namespace test { namespace dev { namespace test {
void doTests(json_spirit::mValue& v, bool _fillin) void doVMTests(json_spirit::mValue& v, bool _fillin)
{ {
for (auto& i: v.get_obj()) for (auto& i: v.get_obj())
{ {
@ -424,19 +362,10 @@ void doTests(json_spirit::mValue& v, bool _fillin)
dev::test::FakeExtVM test; dev::test::FakeExtVM test;
test.importState(o["post"].get_obj()); test.importState(o["post"].get_obj());
test.importCallCreates(o["callcreates"].get_array()); test.importCallCreates(o["callcreates"].get_array());
int i = 0;
if (o["out"].type() == array_type)
for (auto const& d: o["out"].get_array())
{
BOOST_CHECK_MESSAGE(output[i] == test.toInt(d), "Output byte [" << i << "] different!");
++i;
}
else if (o["out"].get_str().find("0x") == 0)
BOOST_CHECK(output == fromHex(o["out"].get_str().substr(2)));
else
BOOST_CHECK(output == fromHex(o["out"].get_str()));
BOOST_CHECK_EQUAL(test.toInt(o["gas"]), vm.gas()); checkOutput(output, o);
BOOST_CHECK_EQUAL(toInt(o["gas"]), vm.gas());
auto& expectedAddrs = test.addresses; auto& expectedAddrs = test.addresses;
auto& resultAddrs = fev.addresses; auto& resultAddrs = fev.addresses;
@ -454,134 +383,68 @@ void doTests(json_spirit::mValue& v, bool _fillin)
BOOST_CHECK_MESSAGE(std::get<1>(expectedState) == std::get<1>(resultState), expectedAddr << ": incorrect txCount " << std::get<1>(resultState) << ", expected " << std::get<1>(expectedState)); BOOST_CHECK_MESSAGE(std::get<1>(expectedState) == std::get<1>(resultState), expectedAddr << ": incorrect txCount " << std::get<1>(resultState) << ", expected " << std::get<1>(expectedState));
BOOST_CHECK_MESSAGE(std::get<3>(expectedState) == std::get<3>(resultState), expectedAddr << ": incorrect code"); BOOST_CHECK_MESSAGE(std::get<3>(expectedState) == std::get<3>(resultState), expectedAddr << ": incorrect code");
auto&& expectedStore = std::get<2>(expectedState); checkStorage(std::get<2>(expectedState), std::get<2>(resultState), expectedAddr);
auto&& resultStore = std::get<2>(resultState);
for (auto&& expectedStorePair : expectedStore)
{
auto& expectedStoreKey = expectedStorePair.first;
auto resultStoreIt = resultStore.find(expectedStoreKey);
if (resultStoreIt == resultStore.end())
BOOST_ERROR(expectedAddr << ": missing store key " << expectedStoreKey);
else
{
auto& expectedStoreValue = expectedStorePair.second;
auto& resultStoreValue = resultStoreIt->second;
BOOST_CHECK_MESSAGE(expectedStoreValue == resultStoreValue, expectedAddr << ": store[" << expectedStoreKey << "] = " << resultStoreValue << ", expected " << expectedStoreValue);
}
}
} }
} }
BOOST_CHECK(test.addresses == fev.addresses); // Just to make sure nothing missed checkAddresses<std::map<Address, std::tuple<u256, u256, std::map<u256, u256>, bytes> > >(test.addresses, fev.addresses);
BOOST_CHECK(test.callcreates == fev.callcreates); BOOST_CHECK(test.callcreates == fev.callcreates);
} }
} }
} }
void executeTests(const string& _name)
{
const char* ptestPath = getenv("ETHEREUM_TEST_PATH");
string testPath;
if (ptestPath == NULL)
{
cnote << " could not find environment variable ETHEREUM_TEST_PATH \n";
testPath = "../../../tests";
}
else
testPath = ptestPath;
testPath += "/vmtests";
#ifdef FILL_TESTS
try
{
cnote << "Populating VM tests...";
json_spirit::mValue v;
boost::filesystem::path p(__FILE__);
boost::filesystem::path dir = p.parent_path();
string s = asString(contents(dir.string() + "/" + _name + "Filler.json"));
BOOST_REQUIRE_MESSAGE(s.length() > 0, "Contents of " + _name + "Filler.json is empty.");
json_spirit::read_string(s, v);
dev::test::doTests(v, true);
writeFile(testPath + "/" + _name + ".json", asBytes(json_spirit::write_string(v, true)));
}
catch (Exception const& _e)
{
BOOST_ERROR("Failed VM Test with Exception: " << diagnostic_information(_e));
}
catch (std::exception const& _e)
{
BOOST_ERROR("Failed VM Test with Exception: " << _e.what());
}
#endif
try
{
cnote << "Testing VM..." << _name;
json_spirit::mValue v;
string s = asString(contents(testPath + "/" + _name + ".json"));
BOOST_REQUIRE_MESSAGE(s.length() > 0, "Contents of " + testPath + "/" + _name + ".json is empty. Have you cloned the 'tests' repo branch develop and set ETHEREUM_TEST_PATH to its path?");
json_spirit::read_string(s, v);
dev::test::doTests(v, false);
}
catch (Exception const& _e)
{
BOOST_ERROR("Failed VM Test with Exception: " << diagnostic_information(_e));
}
catch (std::exception const& _e)
{
BOOST_ERROR("Failed VM Test with Exception: " << _e.what());
}
}
} } // Namespace Close } } // Namespace Close
BOOST_AUTO_TEST_SUITE(VMTests)
BOOST_AUTO_TEST_CASE(vm_tests) BOOST_AUTO_TEST_CASE(vm_tests)
{ {
dev::test::executeTests("vmtests"); dev::test::executeTests("vmtests", "/VMTests", dev::test::doVMTests);
} }
BOOST_AUTO_TEST_CASE(vmArithmeticTest) BOOST_AUTO_TEST_CASE(vmArithmeticTest)
{ {
dev::test::executeTests("vmArithmeticTest"); dev::test::executeTests("vmArithmeticTest", "/VMTests", dev::test::doVMTests);
} }
BOOST_AUTO_TEST_CASE(vmBitwiseLogicOperationTest) BOOST_AUTO_TEST_CASE(vmBitwiseLogicOperationTest)
{ {
dev::test::executeTests("vmBitwiseLogicOperationTest"); dev::test::executeTests("vmBitwiseLogicOperationTest", "/VMTests", dev::test::doVMTests);
} }
BOOST_AUTO_TEST_CASE(vmSha3Test) BOOST_AUTO_TEST_CASE(vmSha3Test)
{ {
dev::test::executeTests("vmSha3Test"); dev::test::executeTests("vmSha3Test", "/VMTests", dev::test::doVMTests);
} }
BOOST_AUTO_TEST_CASE(vmEnvironmentalInfoTest) BOOST_AUTO_TEST_CASE(vmEnvironmentalInfoTest)
{ {
dev::test::executeTests("vmEnvironmentalInfoTest"); dev::test::executeTests("vmEnvironmentalInfoTest", "/VMTests", dev::test::doVMTests);
} }
BOOST_AUTO_TEST_CASE(vmBlockInfoTest) BOOST_AUTO_TEST_CASE(vmBlockInfoTest)
{ {
dev::test::executeTests("vmBlockInfoTest"); dev::test::executeTests("vmBlockInfoTest", "/VMTests", dev::test::doVMTests);
} }
BOOST_AUTO_TEST_CASE(vmIOandFlowOperationsTest) //BOOST_AUTO_TEST_CASE(vmIOandFlowOperationsTest)
//{
// dev::test::executeTests("vmIOandFlowOperationsTest", "/VMTests", dev::test::doVMTests);
//}
BOOST_AUTO_TEST_CASE(vmPushDupSwapTest)
{ {
dev::test::executeTests("vmIOandFlowOperationsTest"); dev::test::executeTests("vmPushDupSwapTest", "/VMTests", dev::test::doVMTests);
} }
BOOST_AUTO_TEST_CASE(vmPushDupSwapTest) BOOST_AUTO_TEST_CASE(vmNamecoin)
{ {
dev::test::executeTests("vmPushDupSwapTest"); dev::test::executeTests("vmNamecoin", "/VMTests", dev::test::doVMTests);
} }
//BOOST_AUTO_TEST_CASE(vmSystemOperationsTest) //BOOST_AUTO_TEST_CASE(vmSystemOperationsTest)
//{ //{
// dev::test::executeTests("vmSystemOperationsTest"); // dev::test::executeTests("vmSystemOperationsTest", "/VMTests", dev::test::doVMTests);
//} //}
BOOST_AUTO_TEST_CASE(userDefinedFile) BOOST_AUTO_TEST_CASE(userDefinedFile)
@ -598,7 +461,7 @@ BOOST_AUTO_TEST_CASE(userDefinedFile)
string s = asString(contents(filename)); string s = asString(contents(filename));
BOOST_REQUIRE_MESSAGE(s.length() > 0, "Contents of " + filename + " is empty. "); BOOST_REQUIRE_MESSAGE(s.length() > 0, "Contents of " + filename + " is empty. ");
json_spirit::read_string(s, v); json_spirit::read_string(s, v);
dev::test::doTests(v, false); dev::test::doVMTests(v, false);
} }
catch (Exception const& _e) catch (Exception const& _e)
{ {
@ -611,3 +474,5 @@ BOOST_AUTO_TEST_CASE(userDefinedFile)
g_logVerbosity = currentVerbosity; g_logVerbosity = currentVerbosity;
} }
} }
BOOST_AUTO_TEST_SUITE_END()

3
test/vm.h
View File

@ -36,6 +36,7 @@ along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
#include <libethereum/Transaction.h> #include <libethereum/Transaction.h>
#include <libethereum/ExtVM.h> #include <libethereum/ExtVM.h>
#include <libethereum/State.h> #include <libethereum/State.h>
#include "TestHelper.h"
namespace dev { namespace test { namespace dev { namespace test {
@ -60,8 +61,6 @@ public:
void setContract(Address _myAddress, u256 _myBalance, u256 _myNonce, std::map<u256, u256> const& _storage, bytes const& _code); 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); void set(Address _a, u256 _myBalance, u256 _myNonce, std::map<u256, u256> const& _storage, bytes const& _code);
void reset(u256 _myBalance, u256 _myNonce, std::map<u256, u256> const& _storage); void reset(u256 _myBalance, u256 _myNonce, std::map<u256, u256> const& _storage);
u256 toInt(json_spirit::mValue const& _v);
byte toByte(json_spirit::mValue const& _v);
void push(json_spirit::mObject& o, std::string const& _n, u256 _v); void push(json_spirit::mObject& o, std::string const& _n, u256 _v);
void push(json_spirit::mArray& a, u256 _v); void push(json_spirit::mArray& a, u256 _v);
u256 doPosts(); u256 doPosts();

Write Preview
Loading…
Cancel
Save