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
Split 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_address, std::string> errinfo_wrongAddress;
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
/// contract account in the
/// 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.
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));
#endif
e.go();
e.go(e.simpleTrace());
e.finalize();
#if ETH_PARANOIA

6
libethereum/State.h
View File

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

4
libevm/VM.h
View File

@ -41,7 +41,7 @@ struct BreakPointHit: virtual VMException {};
struct BadInstruction: virtual VMException {};
struct BadJumpDestination: 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.
// Currently we just pull out the right (low-order in BE) 160-bits.
@ -71,7 +71,7 @@ public:
template <class Ext>
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); } }
u256 gas() const { return m_gas; }
u256 curPC() const { return m_curPC; }

2
test/CMakeLists.txt
View File

@ -9,7 +9,7 @@ link_directories(../libethereum)
file(GLOB HEADERS "*.h")
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 ethcore)

287
test/TestHelper.cpp
View File

@ -23,10 +23,14 @@
#include <thread>
#include <chrono>
#include <boost/filesystem/path.hpp>
#include <libethereum/Client.h>
#include <liblll/Compiler.h>
//#define FILL_TESTS
using namespace std;
using namespace dev::eth;
namespace dev
{
@ -56,6 +60,7 @@ void connectClients(Client& c1, Client& c2)
c2.connect("127.0.0.1", c1Port);
#endif
}
}
namespace test
{
@ -65,17 +70,12 @@ ImportTest::ImportTest(json_spirit::mObject& _o, bool isFiller):m_TestObject(_o)
importEnv(_o["env"].get_obj());
importState(_o["pre"].get_obj(), m_statePre);
importExec(_o["exec"].get_obj());
importTransaction(_o["transaction"].get_obj());
if (!isFiller)
{
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)
@ -110,130 +110,61 @@ void ImportTest::importState(json_spirit::mObject& _o, State& _state)
assert(o.count("code") > 0);
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())
_state.setStorage(address, toInt(j.first), toInt(j.second));
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
bytes code = importCode(o);
toInt(o["nonce"]);
if (toHex(code).size())
{
code.clear();
for (auto const& j: o["code"].get_array())
code.push_back(toByte(j));
cout << "address: " << address << "has code: " << toHex(code) << endl;
_state.m_cache[address] = Account(toInt(o["balance"]), Account::ContractConception);
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, true, true);
_state.ensureCached(address, false, false);
}
}
void ImportTest::importExec(json_spirit::mObject& _o)
void ImportTest::importTransaction(json_spirit::mObject& _o)
{
assert(_o.count("address")> 0);
assert(_o.count("caller") > 0);
assert(_o.count("origin") > 0);
assert(_o.count("nonce")> 0);
assert(_o.count("gasPrice") > 0);
assert(_o.count("gasLimit") > 0);
assert(_o.count("to") > 0);
assert(_o.count("value") > 0);
assert(_o.count("secretKey") > 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_environment.caller = Address(_o["caller"].get_str());
m_environment.origin = Address(_o["origin"].get_str());
m_environment.value = toInt(_o["value"]);
m_environment.gasPrice = toInt(_o["gasPrice"]);
gasExec = toInt(_o["gas"]);
if (_o["code"].type() == json_spirit::str_type)
if (_o["code"].get_str().find_first_of("0x") == 0)
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;
m_transaction.nonce = toInt(_o["nonce"]);
m_transaction.gasPrice = toInt(_o["gasPrice"]);
m_transaction.gas = toInt(_o["gasLimit"]);
m_transaction.receiveAddress = Address(_o["to"].get_str());
m_transaction.type = m_transaction.receiveAddress ? Transaction::MessageCall : Transaction::ContractCreation;
m_transaction.value = toInt(_o["value"]);
Secret secretKey = Secret(_o["secretKey"].get_str());
m_transaction.sign(secretKey);
m_transaction.data = importData(_o);
}
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
m_TestObject["out"] = "0x" + toHex(_output);
// export post state
json_spirit::mObject postState;
std::map<Address, AddressState> genesis = genesisState();
std::map<Address, Account> genesis = genesisState();
for (auto const& a: _statePost.addresses())
{
@ -254,22 +185,6 @@ void ImportTest::exportTest(bytes _output, u256 _gas, State& _statePost)
postState[toString(a.first)] = o;
}
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)
@ -298,5 +213,131 @@ byte toByte(json_spirit::mValue const& _v)
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
#include <functional>
#include <boost/test/unit_test.hpp>
#include "JsonSpiritHeaders.h"
#include <libethereum/State.h>
@ -34,6 +36,8 @@ class Client;
void mine(Client& c, int numBlocks);
void connectClients(Client& c1, Client& c2);
}
namespace test
{
@ -45,31 +49,26 @@ public:
// imports
void importEnv(json_spirit::mObject& _o);
void importState(json_spirit::mObject& _o, State& _state);
void importExec(json_spirit::mObject& _o);
void importCallCreates(json_spirit::mArray& _callcreates);
void importGas(json_spirit::mObject& _o);
void importOutput(json_spirit::mObject& _o);
void exportTest(bytes _output, u256 _gas, State& _statePost);
Manifest* getManifest(){ return &m_manifest;}
State m_statePre;
State m_statePost;
ExtVMFace m_environment;
void importState(json_spirit::mObject& _o, eth::State& _state);
void importTransaction(json_spirit::mObject& _o);
void exportTest(bytes _output, eth::State& _statePost);
eth::Manifest* getManifest(){ return &m_manifest;}
eth::State m_statePre;
eth::State m_statePost;
eth::ExtVMFace m_environment;
u256 gas;
u256 gasExec;
Transactions callcreates;
eth::Transaction m_transaction;
bytes output;
Manifest m_manifest;
eth::Manifest m_manifest;
bytes code;
private:
json_spirit::mObject& m_TestObject;
// needed for const refs
// needed for const ref
bytes data;
};
@ -77,7 +76,25 @@ private:
u256 toInt(json_spirit::mValue const& _v);
byte toByte(json_spirit::mValue const& _v);
bytes importCode(json_spirit::mObject &_o);
bytes importData(json_spirit::mObject &_o);
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 <libethereum/BlockChain.h>
#include <boost/test/unit_test.hpp>
#include "TestHelper.h"
using namespace std;
using namespace dev;
@ -33,18 +34,12 @@ using namespace dev::eth;
namespace js = json_spirit;
BOOST_AUTO_TEST_SUITE(BasicTests)
BOOST_AUTO_TEST_CASE(genesis_tests)
{
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;
string testPath = test::getTestPath();
testPath += "/BasicTests";
cnote << "Testing Genesis block...";
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_AUTO_TEST_SUITE_END()

15
test/hexPrefix.cpp
View File

@ -26,23 +26,19 @@
#include <libdevcore/CommonIO.h>
#include <libdevcrypto/TrieCommon.h>
#include <boost/test/unit_test.hpp>
#include "TestHelper.h"
using namespace std;
using namespace dev;
namespace js = json_spirit;
BOOST_AUTO_TEST_SUITE(BasicTests)
BOOST_AUTO_TEST_CASE(hexPrefix_test)
{
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;
string testPath = test::getTestPath();
testPath += "/BasicTests";
cnote << "Testing Hex-Prefix-Encode...";
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::eth;
BOOST_AUTO_TEST_CASE(basic_tests)
{
//BOOST_AUTO_TEST_CASE(basic_tests)
//{
/* RLPStream s;
BlockInfo::genesis().streamRLP(s, false);
std::cout << RLP(s.out()) << std::endl;
@ -54,5 +54,5 @@ BOOST_AUTO_TEST_CASE(basic_tests)
// r += stateTest();
// r += peerTest(argc, argv);
// BOOST_REQUIRE(!r);
}
//}

15
test/rlp.cpp
View File

@ -29,6 +29,7 @@
#include <boost/test/unit_test.hpp>
#include <algorithm>
#include "JsonSpiritHeaders.h"
#include "TestHelper.h"
using namespace std;
using namespace dev;
@ -61,16 +62,8 @@ namespace dev
static void getRLPTestCases(js::mValue& v)
{
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;
string testPath = getTestPath();
testPath += "/BasicTests";
string s = asString(contents(testPath + "/rlptest.json"));
BOOST_REQUIRE_MESSAGE( s.length() > 0,
@ -144,6 +137,7 @@ namespace dev
}
}
BOOST_AUTO_TEST_SUITE(BasicTests)
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 dev;
using namespace dev::eth;
using namespace dev::eth::test;
class FakeState: public State
{
};
using namespace dev::eth;
namespace dev { namespace eth{ namespace test {
namespace dev { namespace test {
void doStateTests(json_spirit::mValue& v, bool _fillin)
{
cout << "start state test\n";
for (auto& i: v.get_obj())
{
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("pre") > 0);
BOOST_REQUIRE(o.count("exec") > 0);
BOOST_REQUIRE(o.count("transaction") > 0);
ImportTest importer(o,_fillin);
@ -68,57 +63,47 @@ void doStateTests(json_spirit::mValue& v, bool _fillin)
importer.m_environment.code = &importer.code;
}
ExtVM evm(importer.m_statePre, importer.m_environment.myAddress,
importer.m_environment.caller, importer.m_environment.origin,
importer.m_environment.value, importer.m_environment.gasPrice,
importer.m_environment.data, importer.m_environment.code,
importer.getManifest());
State theState = importer.m_statePre;
bytes tx = importer.m_transaction.rlp();
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
{
output = vm.go(evm, Executive::simpleTrace()).toVector();
theState.execute(tx, &output);
}
catch (Exception const& _e)
{
cnote << "VM did throw an exception: " << diagnostic_information(_e);
//BOOST_ERROR("Failed VM Test with Exception: " << e.what());
cnote << "state execution did throw an exception: " << diagnostic_information(_e);
}
catch (std::exception const& _e)
{
cnote << "VM did throw an exception: " << _e.what();
//BOOST_ERROR("Failed VM Test with Exception: " << e.what());
cnote << "state execution did throw an exception: " << _e.what();
}
if (_fillin)
importer.exportTest(output, vm.gas(), evm.state());
importer.exportTest(output, theState);
else
{
BOOST_REQUIRE(o.count("post") > 0);
//BOOST_REQUIRE(o.count("callcreates") > 0);
BOOST_REQUIRE(o.count("out") > 0);
BOOST_REQUIRE(o.count("gas") > 0);
// check output
checkOutput(output, o);
int j = 0;
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());
// check addresses
auto expectedAddrs = importer.m_statePost.addresses();
auto resultAddrs = evm.state().addresses();
auto resultAddrs = theState.addresses();
for (auto& expectedPair : expectedAddrs)
{
auto& expectedAddr = expectedPair.first;
@ -127,115 +112,37 @@ void doStateTests(json_spirit::mValue& v, bool _fillin)
BOOST_ERROR("Missing expected address " << expectedAddr);
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.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.code(expectedAddr) == evm.state().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);
}
}
}
}
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) == theState.transactionsFrom(expectedAddr), expectedAddr << ": incorrect txCount " << theState.transactionsFrom(expectedAddr) << ", expected " << importer.m_statePost.transactionsFrom(expectedAddr));
BOOST_CHECK_MESSAGE(importer.m_statePost.code(expectedAddr) == theState.code(expectedAddr), expectedAddr << ": incorrect code");
for (auto& resultPair : resultAddrs)
{
auto& resultAddr = resultPair.first;
auto expectedAddrIt = expectedAddrs.find(resultAddr);
if (expectedAddrIt == expectedAddrs.end())
BOOST_ERROR("Missing result address " << resultAddr);
checkStorage(importer.m_statePost.storage(expectedAddr), theState.storage(expectedAddr), expectedAddr);
}
}
BOOST_CHECK(evm.state().addresses() == importer.m_statePost.addresses()); // Just to make sure nothing missed
//BOOST_CHECK(evm.callcreates == importer.callcreates);
checkAddresses<map<Address, u256> >(expectedAddrs, resultAddrs);
}
}
}
} }// Namespace Close
BOOST_AUTO_TEST_SUITE(StateTests)
void executeStateTests(const string& _name)
BOOST_AUTO_TEST_CASE(stExample)
{
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 += "/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());
}
dev::test::executeTests("stExample", "/StateTests", dev::test::doStateTests);
}
} } }// Namespace Close
BOOST_AUTO_TEST_CASE(vmSystemOperationsTest)
{
dev::eth::test::executeStateTests("stSystemOperationsTest");
}
//BOOST_AUTO_TEST_CASE(stSystemOperationsTest)
//{
// dev::test::executeStateTests("stSystemOperationsTest");
//}
BOOST_AUTO_TEST_CASE(tmp)
{
std::cout << "Doing systemoperationsTest in state\n";
int currentVerbosity = g_logVerbosity;
g_logVerbosity = 12;
dev::eth::test::executeStateTests("tmp");
dev::test::executeTests("tmp", "/StateTests", dev::test::doStateTests);
g_logVerbosity = currentVerbosity;
}
BOOST_AUTO_TEST_SUITE_END()

33
test/tmpFiller.json
View File

@ -1,5 +1,5 @@
{
"ABAcallsSuicide0": {
"ABAcalls0": {
"env" : {
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
"currentNumber" : "0",
@ -9,29 +9,36 @@
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
},
"pre" : {
"0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : {
"balance" : "1000000000000000000",
"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": {}
},
"945304eb96065b2a98b57a48a06ae28d285a71b5" : {
"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",
"storage" : {
}
},
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
"balance" : "1000000000000000000",
"nonce" : 0,
"code" : "",
"storage": {}
}
},
"exec" : {
"address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
"origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
"caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
"value" : "100000",
"data" : "",
"gasPrice" : "100000000000000",
"gas" : "10000000000000"
}
"transaction" : {
"nonce" : "0",
"gasPrice" : "1",
"gasLimit" : "10000",
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87",
"value" : "100000",
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
"data" : ""
}
}
}

18
test/trie.cpp
View File

@ -28,6 +28,7 @@
#include "TrieHash.h"
#include "MemTrie.h"
#include <boost/test/unit_test.hpp>
#include "TestHelper.h"
using namespace std;
using namespace dev;
@ -47,18 +48,14 @@ static unsigned fac(unsigned _i)
}
}
BOOST_AUTO_TEST_SUITE(TrieTests)
BOOST_AUTO_TEST_CASE(trie_tests)
{
const char* ptestPath = getenv("ETHEREUM_TEST_PATH");
string testPath;
string testPath = test::getTestPath();
if (ptestPath == NULL)
{
cnote << " could not find environment variable ETHEREUM_TEST_PATH \n";
testPath = "../../../tests";
}
else
testPath = ptestPath;
testPath += "/TrieTests";
cnote << "Testing Trie...";
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.
*/
#include <boost/filesystem/path.hpp>
#include "vm.h"
//#define FILL_TESTS
using namespace std;
using namespace json_spirit;
using namespace dev;
@ -59,6 +56,8 @@ bool FakeExtVM::call(Address _receiveAddress, u256 _value, bytesConstRef _data,
t.receiveAddress = _receiveAddress;
callcreates.push_back(t);
(void)_out;
(void)_myAddressOverride;
(void)_codeAddressOverride;
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]));
}
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)
{
// if (_v < (u256)1 << 64)
// o[_n] = (uint64_t)_v;
// else
o[_n] = toString(_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));
}
@ -202,17 +169,7 @@ void FakeExtVM::importState(mObject& _object)
for (auto const& j: o["storage"].get_obj())
get<2>(a)[toInt(j.first)] = toInt(j.second);
if (o["code"].type() == str_type)
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));
}
get<3>(a) = importCode(o);
}
}
@ -250,26 +207,14 @@ void FakeExtVM::importExec(mObject& _o)
thisTxCode.clear();
code = &thisTxCode;
if (_o["code"].type() == str_type)
if (_o["code"].get_str().find_first_of("0x") == 0)
thisTxCode = fromHex(_o["code"].get_str().substr(2));
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
thisTxCode = importCode(_o);
if (_o["code"].type() != str_type && _o["code"].type() != array_type)
code.reset();
thisTxData.clear();
if (_o["data"].type() == str_type)
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));
thisTxData = importData(_o);
data = &thisTxData;
}
@ -302,14 +247,7 @@ void FakeExtVM::importCallCreates(mArray& _callcreates)
t.receiveAddress = Address(tx["destination"].get_str());
t.value = toInt(tx["value"]);
t.gas = toInt(tx["gasLimit"]);
if (tx["data"].type() == 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));
t.data = importData(tx);
callcreates.push_back(t);
}
}
@ -346,7 +284,7 @@ eth::OnOpFunc FakeExtVM::simpleTrace()
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())
{
@ -424,19 +362,10 @@ void doTests(json_spirit::mValue& v, bool _fillin)
dev::test::FakeExtVM test;
test.importState(o["post"].get_obj());
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& 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<3>(expectedState) == std::get<3>(resultState), expectedAddr << ": incorrect code");
auto&& expectedStore = std::get<2>(expectedState);
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);
}
}
checkStorage(std::get<2>(expectedState), std::get<2>(resultState), expectedAddr);
}
}
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);
}
}
}
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
BOOST_AUTO_TEST_SUITE(VMTests)
BOOST_AUTO_TEST_CASE(vm_tests)
{
dev::test::executeTests("vmtests");
dev::test::executeTests("vmtests", "/VMTests", dev::test::doVMTests);
}
BOOST_AUTO_TEST_CASE(vmArithmeticTest)
{
dev::test::executeTests("vmArithmeticTest");
dev::test::executeTests("vmArithmeticTest", "/VMTests", dev::test::doVMTests);
}
BOOST_AUTO_TEST_CASE(vmBitwiseLogicOperationTest)
{
dev::test::executeTests("vmBitwiseLogicOperationTest");
dev::test::executeTests("vmBitwiseLogicOperationTest", "/VMTests", dev::test::doVMTests);
}
BOOST_AUTO_TEST_CASE(vmSha3Test)
{
dev::test::executeTests("vmSha3Test");
dev::test::executeTests("vmSha3Test", "/VMTests", dev::test::doVMTests);
}
BOOST_AUTO_TEST_CASE(vmEnvironmentalInfoTest)
{
dev::test::executeTests("vmEnvironmentalInfoTest");
dev::test::executeTests("vmEnvironmentalInfoTest", "/VMTests", dev::test::doVMTests);
}
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)
//{
// dev::test::executeTests("vmSystemOperationsTest");
// dev::test::executeTests("vmSystemOperationsTest", "/VMTests", dev::test::doVMTests);
//}
BOOST_AUTO_TEST_CASE(userDefinedFile)
@ -598,7 +461,7 @@ BOOST_AUTO_TEST_CASE(userDefinedFile)
string s = asString(contents(filename));
BOOST_REQUIRE_MESSAGE(s.length() > 0, "Contents of " + filename + " is empty. ");
json_spirit::read_string(s, v);
dev::test::doTests(v, false);
dev::test::doVMTests(v, false);
}
catch (Exception const& _e)
{
@ -611,3 +474,5 @@ BOOST_AUTO_TEST_CASE(userDefinedFile)
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/ExtVM.h>
#include <libethereum/State.h>
#include "TestHelper.h"
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 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);
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::mArray& a, u256 _v);
u256 doPosts();

Write Preview
Loading…
Cancel
Save