aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--CMakeLists.txt24
-rw-r--r--ClientBase.cpp202
-rw-r--r--TestHelper.cpp16
-rw-r--r--TestHelper.h2
-rw-r--r--TestUtils.cpp130
-rw-r--r--TestUtils.h82
6 files changed, 439 insertions, 17 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt
index ef292c2b..66b95ada 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -30,6 +30,7 @@ target_link_libraries(testeth ethereum)
target_link_libraries(testeth ethcore)
target_link_libraries(testeth secp256k1)
target_link_libraries(testeth solidity)
+target_link_libraries(testeth testutils)
if (NOT HEADLESS AND NOT JUSTTESTS)
target_link_libraries(testeth webthree)
target_link_libraries(testeth natspec)
@@ -42,13 +43,36 @@ endif()
target_link_libraries(createRandomVMTest ${Boost_UNIT_TEST_FRAMEWORK_LIBRARIES})
target_link_libraries(createRandomVMTest ethereum)
target_link_libraries(createRandomVMTest ethcore)
+target_link_libraries(createRandomVMTest testutils)
target_link_libraries(createRandomStateTest ${Boost_UNIT_TEST_FRAMEWORK_LIBRARIES})
target_link_libraries(createRandomStateTest ethereum)
target_link_libraries(createRandomStateTest ethcore)
+target_link_libraries(createRandomStateTest testutils)
target_link_libraries(checkRandomVMTest ${Boost_UNIT_TEST_FRAMEWORK_LIBRARIES})
target_link_libraries(checkRandomVMTest ethereum)
target_link_libraries(checkRandomVMTest ethcore)
+target_link_libraries(checkRandomVMTest testutils)
target_link_libraries(checkRandomStateTest ${Boost_UNIT_TEST_FRAMEWORK_LIBRARIES})
target_link_libraries(checkRandomStateTest ethereum)
target_link_libraries(checkRandomStateTest ethcore)
+target_link_libraries(checkRandomStateTest testutils)
+
+enable_testing()
+set(CTEST_OUTPUT_ON_FAILURE TRUE)
+
+include(EthUtils)
+
+eth_add_test(ClientBase
+ ARGS --eth_testfile=BlockTests/bcJS_API_Test --eth_threads=1
+ ARGS --eth_testfile=BlockTests/bcJS_API_Test --eth_threads=3
+ ARGS --eth_testfile=BlockTests/bcJS_API_Test --eth_threads=10
+ ARGS --eth_testfile=BlockTests/bcValidBlockTest --eth_threads=1
+ ARGS --eth_testfile=BlockTests/bcValidBlockTest --eth_threads=3
+ ARGS --eth_testfile=BlockTests/bcValidBlockTest --eth_threads=10
+)
+
+eth_add_test(JsonRpc
+ ARGS --eth_testfile=BlockTests/bcJS_API_Test
+ ARGS --eth_testfile=BlockTests/bcValidBlockTest
+)
diff --git a/ClientBase.cpp b/ClientBase.cpp
new file mode 100644
index 00000000..2197ac83
--- /dev/null
+++ b/ClientBase.cpp
@@ -0,0 +1,202 @@
+/*
+ This file is part of cpp-ethereum.
+
+ cpp-ethereum is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ cpp-ethereum is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
+ */
+/** @file ClientBase.cpp
+ * @author Marek Kotewicz <marek@ethdev.com>
+ * @date 2015
+ */
+
+#include <boost/test/unit_test.hpp>
+#include <libdevcore/CommonJS.h>
+#include "TestUtils.h"
+
+using namespace std;
+using namespace dev;
+using namespace dev::eth;
+using namespace dev::test;
+
+BOOST_FIXTURE_TEST_SUITE(ClientBase, ParallelClientBaseFixture)
+
+BOOST_AUTO_TEST_CASE(blocks)
+{
+ enumerateClients([](Json::Value const& _json, dev::eth::ClientBase& _client) -> void
+ {
+ for (string const& name: _json["postState"].getMemberNames())
+ {
+ Json::Value o = _json["postState"][name];
+ Address address(name);
+
+ // balanceAt
+ u256 expectedBalance = u256(o["balance"].asString());
+ u256 balance = _client.balanceAt(address);
+ ETH_CHECK_EQUAL(expectedBalance, balance);
+
+ // countAt
+ u256 expectedCount = u256(o["nonce"].asString());
+ u256 count = _client.countAt(address);
+ ETH_CHECK_EQUAL(expectedCount, count);
+
+ // stateAt
+ for (string const& pos: o["storage"].getMemberNames())
+ {
+ u256 expectedState = u256(o["storage"][pos].asString());
+ u256 state = _client.stateAt(address, u256(pos));
+ ETH_CHECK_EQUAL(expectedState, state);
+ }
+
+ // codeAt
+ bytes expectedCode = fromHex(o["code"].asString());
+ bytes code = _client.codeAt(address);
+ ETH_CHECK_EQUAL_COLLECTIONS(expectedCode.begin(), expectedCode.end(),
+ code.begin(), code.end());
+ }
+
+ // number
+ unsigned expectedNumber = _json["blocks"].size();
+ unsigned number = _client.number();
+ ETH_CHECK_EQUAL(expectedNumber, number);
+
+ u256 totalDifficulty = u256(_json["genesisBlockHeader"]["difficulty"].asString());
+ for (Json::Value const& block: _json["blocks"])
+ {
+ Json::Value blockHeader = block["blockHeader"];
+ Json::Value uncles = block["uncleHeaders"];
+ Json::Value transactions = block["transactions"];
+ h256 blockHash = h256(fromHex(blockHeader["hash"].asString()));
+
+ // just update the difficulty
+ for (Json::Value const& uncle: uncles)
+ {
+ totalDifficulty += u256(uncle["difficulty"].asString());
+ }
+
+ // hashFromNumber
+ h256 expectedHashFromNumber = h256(fromHex(blockHeader["hash"].asString()));
+ h256 hashFromNumber = _client.hashFromNumber(jsToInt(blockHeader["number"].asString()));
+ ETH_CHECK_EQUAL(expectedHashFromNumber, hashFromNumber);
+
+ // blockInfo
+ auto compareBlockInfos = [](Json::Value const& _b, BlockInfo _blockInfo) -> void
+ {
+ LogBloom expectedBlockInfoBloom = LogBloom(fromHex(_b["bloom"].asString()));
+ Address expectedBlockInfoCoinbase = Address(fromHex(_b["coinbase"].asString()));
+ u256 expectedBlockInfoDifficulty = u256(_b["difficulty"].asString());
+ bytes expectedBlockInfoExtraData = fromHex(_b["extraData"].asString());
+ u256 expectedBlockInfoGasLimit = u256(_b["gasLimit"].asString());
+ u256 expectedBlockInfoGasUsed = u256(_b["gasUsed"].asString());
+ h256 expectedBlockInfoHash = h256(fromHex(_b["hash"].asString()));
+ h256 expectedBlockInfoMixHash = h256(fromHex(_b["mixHash"].asString()));
+ Nonce expectedBlockInfoNonce = Nonce(fromHex(_b["nonce"].asString()));
+ u256 expectedBlockInfoNumber = u256(_b["number"].asString());
+ h256 expectedBlockInfoParentHash = h256(fromHex(_b["parentHash"].asString()));
+ h256 expectedBlockInfoReceiptsRoot = h256(fromHex(_b["receiptTrie"].asString()));
+ u256 expectedBlockInfoTimestamp = u256(_b["timestamp"].asString());
+ h256 expectedBlockInfoTransactionsRoot = h256(fromHex(_b["transactionsTrie"].asString()));
+ h256 expectedBlockInfoUncldeHash = h256(fromHex(_b["uncleHash"].asString()));
+ ETH_CHECK_EQUAL(expectedBlockInfoBloom, _blockInfo.logBloom);
+ ETH_CHECK_EQUAL(expectedBlockInfoCoinbase, _blockInfo.coinbaseAddress);
+ ETH_CHECK_EQUAL(expectedBlockInfoDifficulty, _blockInfo.difficulty);
+ ETH_CHECK_EQUAL_COLLECTIONS(expectedBlockInfoExtraData.begin(), expectedBlockInfoExtraData.end(),
+ _blockInfo.extraData.begin(), _blockInfo.extraData.end());
+ ETH_CHECK_EQUAL(expectedBlockInfoGasLimit, _blockInfo.gasLimit);
+ ETH_CHECK_EQUAL(expectedBlockInfoGasUsed, _blockInfo.gasUsed);
+ ETH_CHECK_EQUAL(expectedBlockInfoHash, _blockInfo.hash);
+ ETH_CHECK_EQUAL(expectedBlockInfoMixHash, _blockInfo.mixHash);
+ ETH_CHECK_EQUAL(expectedBlockInfoNonce, _blockInfo.nonce);
+ ETH_CHECK_EQUAL(expectedBlockInfoNumber, _blockInfo.number);
+ ETH_CHECK_EQUAL(expectedBlockInfoParentHash, _blockInfo.parentHash);
+ ETH_CHECK_EQUAL(expectedBlockInfoReceiptsRoot, _blockInfo.receiptsRoot);
+ ETH_CHECK_EQUAL(expectedBlockInfoTimestamp, _blockInfo.timestamp);
+ ETH_CHECK_EQUAL(expectedBlockInfoTransactionsRoot, _blockInfo.transactionsRoot);
+ ETH_CHECK_EQUAL(expectedBlockInfoUncldeHash, _blockInfo.sha3Uncles);
+ };
+
+ BlockInfo blockInfo = _client.blockInfo(blockHash);
+ compareBlockInfos(blockHeader, blockInfo);
+
+ // blockDetails
+ unsigned expectedBlockDetailsNumber = jsToInt(blockHeader["number"].asString());
+ totalDifficulty += u256(blockHeader["difficulty"].asString());
+ BlockDetails blockDetails = _client.blockDetails(blockHash);
+ ETH_CHECK_EQUAL(expectedBlockDetailsNumber, blockDetails.number);
+ ETH_CHECK_EQUAL(totalDifficulty, blockDetails.totalDifficulty);
+
+ auto compareTransactions = [](Json::Value const& _t, Transaction _transaction) -> void
+ {
+ bytes expectedTransactionData = fromHex(_t["data"].asString());
+ u256 expectedTransactionGasLimit = u256(_t["gasLimit"].asString());
+ u256 expectedTransactionGasPrice = u256(_t["gasPrice"].asString());
+ u256 expectedTransactionNonce = u256(_t["nonce"].asString());
+ u256 expectedTransactionSignatureR = h256(fromHex(_t["r"].asString()));
+ u256 expectedTransactionSignatureS = h256(fromHex(_t["s"].asString()));
+// unsigned expectedTransactionSignatureV = jsToInt(t["v"].asString());
+
+ ETH_CHECK_EQUAL_COLLECTIONS(expectedTransactionData.begin(), expectedTransactionData.end(),
+ _transaction.data().begin(), _transaction.data().end());
+ ETH_CHECK_EQUAL(expectedTransactionGasLimit, _transaction.gas());
+ ETH_CHECK_EQUAL(expectedTransactionGasPrice, _transaction.gasPrice());
+ ETH_CHECK_EQUAL(expectedTransactionNonce, _transaction.nonce());
+ ETH_CHECK_EQUAL(expectedTransactionSignatureR, _transaction.signature().r);
+ ETH_CHECK_EQUAL(expectedTransactionSignatureS, _transaction.signature().s);
+// ETH_CHECK_EQUAL(expectedTransactionSignatureV, _transaction.signature().v); // 27 === 0x0, 28 === 0x1, not sure why
+ };
+
+ Transactions ts = _client.transactions(blockHash);
+ TransactionHashes tHashes = _client.transactionHashes(blockHash);
+ unsigned tsCount = _client.transactionCount(blockHash);
+
+ ETH_REQUIRE(transactions.size() == ts.size());
+ ETH_REQUIRE(transactions.size() == tHashes.size());
+
+ // transactionCount
+ ETH_CHECK_EQUAL(transactions.size(), tsCount);
+
+ for (unsigned i = 0; i < tsCount; i++)
+ {
+ Json::Value t = transactions[i];
+
+ // transaction (by block hash and transaction index)
+ Transaction transaction = _client.transaction(blockHash, i);
+ compareTransactions(t, transaction);
+
+ // transaction (by hash)
+ Transaction transactionByHash = _client.transaction(transaction.sha3());
+ compareTransactions(t, transactionByHash);
+
+ // transactions
+ compareTransactions(t, ts[i]);
+
+ // transactionHashes
+ ETH_CHECK_EQUAL(transaction.sha3(), tHashes[i]);
+ }
+
+ // uncleCount
+ unsigned usCount = _client.uncleCount(blockHash);
+ ETH_CHECK_EQUAL(uncles.size(), usCount);
+
+ for (unsigned i = 0; i < usCount; i++)
+ {
+ Json::Value u = uncles[i];
+
+ // uncle (by hash)
+ BlockInfo uncle = _client.uncle(blockHash, i);
+ compareBlockInfos(u, uncle);
+ }
+ }
+ });
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/TestHelper.cpp b/TestHelper.cpp
index b29c5dc3..7dc00149 100644
--- a/TestHelper.cpp
+++ b/TestHelper.cpp
@@ -374,22 +374,6 @@ void checkCallCreates(eth::Transactions _resultCallCreates, eth::Transactions _e
}
}
-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 userDefinedTest(string testTypeFlag, std::function<void(json_spirit::mValue&, bool)> doTests)
{
for (int i = 1; i < boost::unit_test::framework::master_test_suite().argc; ++i)
diff --git a/TestHelper.h b/TestHelper.h
index ade20f5e..022c715f 100644
--- a/TestHelper.h
+++ b/TestHelper.h
@@ -28,6 +28,7 @@
#include "JsonSpiritHeaders.h"
#include <libethereum/State.h>
#include <libevm/ExtVMFace.h>
+#include <libtestutils/Common.h>
namespace dev
{
@@ -138,7 +139,6 @@ void checkLog(eth::LogEntries _resultLogs, eth::LogEntries _expectedLogs);
void checkCallCreates(eth::Transactions _resultCallCreates, eth::Transactions _expectedCallCreates);
void executeTests(const std::string& _name, const std::string& _testPathAppendix, std::function<void(json_spirit::mValue&, bool)> doTests);
-std::string getTestPath();
void userDefinedTest(std::string testTypeFlag, std::function<void(json_spirit::mValue&, bool)> doTests);
RLPStream createRLPStreamFromTransactionFields(json_spirit::mObject& _tObj);
eth::LastHashes lastHashes(u256 _currentBlockNumber);
diff --git a/TestUtils.cpp b/TestUtils.cpp
new file mode 100644
index 00000000..71eeadb3
--- /dev/null
+++ b/TestUtils.cpp
@@ -0,0 +1,130 @@
+/*
+ This file is part of cpp-ethereum.
+
+ cpp-ethereum is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ cpp-ethereum is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
+ */
+/** @file TestUtils.cpp
+ * @author Marek Kotewicz <marek@ethdev.com>
+ * @date 2015
+ */
+
+#include <ctime>
+#include <random>
+#include <thread>
+#include <boost/test/unit_test.hpp>
+#include <boost/filesystem.hpp>
+#include <libtestutils/BlockChainLoader.h>
+#include <libtestutils/FixedClient.h>
+#include "TestUtils.h"
+
+// used methods from TestHelper:
+// getTestPath
+#include "TestHelper.h"
+
+using namespace std;
+using namespace dev;
+using namespace dev::eth;
+using namespace dev::test;
+
+namespace dev
+{
+namespace test
+{
+
+bool getCommandLineOption(std::string const& _name);
+std::string getCommandLineArgument(std::string const& _name, bool _require = false);
+
+}
+}
+
+bool dev::test::getCommandLineOption(string const& _name)
+{
+ auto argc = boost::unit_test::framework::master_test_suite().argc;
+ auto argv = boost::unit_test::framework::master_test_suite().argv;
+ bool result = false;
+ for (auto i = 0; !result && i < argc; ++i)
+ result = _name == argv[i];
+ return result;
+}
+
+std::string dev::test::getCommandLineArgument(string const& _name, bool _require)
+{
+ auto argc = boost::unit_test::framework::master_test_suite().argc;
+ auto argv = boost::unit_test::framework::master_test_suite().argv;
+ for (auto i = 1; i < argc; ++i)
+ {
+ string str = argv[i];
+ if (_name == str.substr(0, _name.size()))
+ return str.substr(str.find("=") + 1);
+ }
+ if (_require)
+ BOOST_ERROR("Failed getting command line argument: " << _name << " from: " << argv);
+ return "";
+}
+
+bool LoadTestFileFixture::m_loaded = false;
+Json::Value LoadTestFileFixture::m_json;
+
+LoadTestFileFixture::LoadTestFileFixture()
+{
+ if (!m_loaded)
+ {
+ m_json = loadJsonFromFile(toTestFilePath(getCommandLineArgument("--eth_testfile")));
+ m_loaded = true;
+ }
+}
+
+void ParallelFixture::enumerateThreads(std::function<void()> callback)
+{
+ size_t threadsCount = std::stoul(getCommandLineArgument("--eth_threads"), nullptr, 10);
+
+ vector<thread> workers;
+ for (size_t i = 0; i < threadsCount; i++)
+ workers.emplace_back(callback);
+
+ for_each(workers.begin(), workers.end(), [](thread &t)
+ {
+ t.join();
+ });
+}
+
+void BlockChainFixture::enumerateBlockchains(std::function<void(Json::Value const&, dev::eth::BlockChain&, State state)> callback)
+{
+ for (string const& name: m_json.getMemberNames())
+ {
+ BlockChainLoader bcl(m_json[name]);
+ callback(m_json[name], bcl.bc(), bcl.state());
+ }
+}
+
+void ClientBaseFixture::enumerateClients(std::function<void(Json::Value const&, dev::eth::ClientBase&)> callback)
+{
+ enumerateBlockchains([&callback](Json::Value const& _json, BlockChain& _bc, State _state) -> void
+ {
+ FixedClient client(_bc, _state);
+ callback(_json, client);
+ });
+}
+
+void ParallelClientBaseFixture::enumerateClients(std::function<void(Json::Value const&, dev::eth::ClientBase&)> callback)
+{
+ ClientBaseFixture::enumerateClients([this, &callback](Json::Value const& _json, dev::eth::ClientBase& _client) -> void
+ {
+ // json is being copied here
+ enumerateThreads([callback, _json, &_client]() -> void
+ {
+ callback(_json, _client);
+ });
+ });
+}
diff --git a/TestUtils.h b/TestUtils.h
new file mode 100644
index 00000000..fef10e98
--- /dev/null
+++ b/TestUtils.h
@@ -0,0 +1,82 @@
+/*
+ This file is part of cpp-ethereum.
+
+ cpp-ethereum is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ cpp-ethereum is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
+ */
+/** @file TestUtils.h
+ * @author Marek Kotewicz <marek@ethdev.com>
+ * @date 2015
+ */
+
+#pragma once
+
+#include <functional>
+#include <string>
+#include <json/json.h>
+#include <libethereum/BlockChain.h>
+#include <libethereum/ClientBase.h>
+
+namespace dev
+{
+namespace test
+{
+
+// should be used for multithread tests
+static SharedMutex x_boostTest;
+#define ETH_CHECK_EQUAL(x, y) { dev::WriteGuard(x_boostTest); BOOST_CHECK_EQUAL(x, y); }
+#define ETH_CHECK_EQUAL_COLLECTIONS(xb, xe, yb, ye) { dev::WriteGuard(x_boostTest); BOOST_CHECK_EQUAL_COLLECTIONS(xb, xe, yb, ye); }
+#define ETH_REQUIRE(x) { dev::WriteGuard(x_boostTest); BOOST_REQUIRE(x); }
+
+struct LoadTestFileFixture
+{
+ LoadTestFileFixture();
+
+ static bool m_loaded;
+ static Json::Value m_json;
+};
+
+struct ParallelFixture
+{
+ void enumerateThreads(std::function<void()> callback);
+};
+
+struct BlockChainFixture: public LoadTestFileFixture
+{
+ void enumerateBlockchains(std::function<void(Json::Value const&, dev::eth::BlockChain&, dev::eth::State state)> callback);
+};
+
+struct ClientBaseFixture: public BlockChainFixture
+{
+ void enumerateClients(std::function<void(Json::Value const&, dev::eth::ClientBase&)> callback);
+};
+
+// important BOOST TEST do have problems with thread safety!!!
+// BOOST_CHECK is not thread safe
+// BOOST_MESSAGE is not thread safe
+// http://boost.2283326.n4.nabble.com/Is-boost-test-thread-safe-td3471644.html
+// http://lists.boost.org/boost-users/2010/03/57691.php
+// worth reading
+// https://codecrafter.wordpress.com/2012/11/01/c-unit-test-framework-adapter-part-3/
+struct ParallelClientBaseFixture: public ClientBaseFixture, public ParallelFixture
+{
+ void enumerateClients(std::function<void(Json::Value const&, dev::eth::ClientBase&)> callback);
+};
+
+struct JsonRpcFixture: public ClientBaseFixture
+{
+
+};
+
+}
+}
generated by cgit (git 2.34.1) at 2024-11-17 23:06:59 +0800