foster/bitcoin-bitcoin-core
0
0
Fork 0
mirror of https://github.com/bitcoin/bitcoin.git synced 2025-02-10 10:52:31 -05:00
Code Issues Activity

test: refactor: Give unit test functions access to test state

Browse source 
Add unit test subclasses as needed so unit test functions that need to access
members like m_rng can reference it directly.
This commit is contained in:
Ryan Ofsky 2024-08-14 07:58:26 -04:00 • committed by MarcoFalke
parent fab023e177
commit 3dc527f460
16 changed files with 145 additions and 81 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/test/bip324_tests.cpp
View file

@ -20,6 +20,7 @@
namespace { namespace {
struct BIP324Test : BasicTestingSetup {
void TestBIP324PacketVector( void TestBIP324PacketVector(
uint32_t in_idx, uint32_t in_idx,
const std::string& in_priv_ours_hex, const std::string& in_priv_ours_hex,
@ -155,10 +156,11 @@ void TestBIP324PacketVector(
} }
} }
} }
}; // struct BIP324Test
} // namespace } // namespace
BOOST_FIXTURE_TEST_SUITE(bip324_tests, BasicTestingSetup) BOOST_FIXTURE_TEST_SUITE(bip324_tests, BIP324Test)
BOOST_AUTO_TEST_CASE(packet_test_vectors) { BOOST_AUTO_TEST_CASE(packet_test_vectors) {
// BIP324 key derivation uses network magic in the HKDF process. We use mainnet params here // BIP324 key derivation uses network magic in the HKDF process. We use mainnet params here

10
src/test/bloom_tests.cpp
View file

@ -22,7 +22,13 @@
#include <boost/test/unit_test.hpp> #include <boost/test/unit_test.hpp>
BOOST_FIXTURE_TEST_SUITE(bloom_tests, BasicTestingSetup) namespace bloom_tests {
struct BloomTest : public BasicTestingSetup {
std::vector<unsigned char> RandomData();
};
} // namespace bloom_tests
BOOST_FIXTURE_TEST_SUITE(bloom_tests, BloomTest)
BOOST_AUTO_TEST_CASE(bloom_create_insert_serialize) BOOST_AUTO_TEST_CASE(bloom_create_insert_serialize)
{ {
@ -455,7 +461,7 @@ BOOST_AUTO_TEST_CASE(merkle_block_4_test_update_none)
BOOST_CHECK(!filter.contains(COutPoint(Txid::FromHex("02981fa052f0481dbc5868f4fc2166035a10f27a03cfd2de67326471df5bc041").value(), 0))); BOOST_CHECK(!filter.contains(COutPoint(Txid::FromHex("02981fa052f0481dbc5868f4fc2166035a10f27a03cfd2de67326471df5bc041").value(), 0)));
} }
static std::vector<unsigned char> RandomData() std::vector<unsigned char> BloomTest::RandomData()
{ {
uint256 r = InsecureRand256(); uint256 r = InsecureRand256();
return std::vector<unsigned char>(r.begin(), r.end()); return std::vector<unsigned char>(r.begin(), r.end());

8
src/test/checkqueue_tests.cpp
View file

@ -34,7 +34,9 @@ struct NoLockLoggingTestingSetup : public TestingSetup {
#endif #endif
}; };
BOOST_FIXTURE_TEST_SUITE(checkqueue_tests, NoLockLoggingTestingSetup) struct CheckQueueTest : NoLockLoggingTestingSetup {
void Correct_Queue_range(std::vector<size_t> range);
};
static const unsigned int QUEUE_BATCH_SIZE = 128; static const unsigned int QUEUE_BATCH_SIZE = 128;
static const int SCRIPT_CHECK_THREADS = 3; static const int SCRIPT_CHECK_THREADS = 3;
@ -156,7 +158,7 @@ typedef CCheckQueue<FrozenCleanupCheck> FrozenCleanup_Queue;
/** This test case checks that the CCheckQueue works properly /** This test case checks that the CCheckQueue works properly
* with each specified size_t Checks pushed. * with each specified size_t Checks pushed.
*/ */
static void Correct_Queue_range(std::vector<size_t> range) void CheckQueueTest::Correct_Queue_range(std::vector<size_t> range)
{ {
auto small_queue = std::make_unique<Correct_Queue>(QUEUE_BATCH_SIZE, SCRIPT_CHECK_THREADS); auto small_queue = std::make_unique<Correct_Queue>(QUEUE_BATCH_SIZE, SCRIPT_CHECK_THREADS);
// Make vChecks here to save on malloc (this test can be slow...) // Make vChecks here to save on malloc (this test can be slow...)
@ -177,6 +179,8 @@ static void Correct_Queue_range(std::vector<size_t> range)
} }
} }
BOOST_FIXTURE_TEST_SUITE(checkqueue_tests, CheckQueueTest)
/** Test that 0 checks is correct /** Test that 0 checks is correct
*/ */
BOOST_AUTO_TEST_CASE(test_CheckQueue_Correct_Zero) BOOST_AUTO_TEST_CASE(test_CheckQueue_Correct_Zero)

14
src/test/coins_tests.cpp
View file

@ -105,6 +105,7 @@ BOOST_FIXTURE_TEST_SUITE(coins_tests, BasicTestingSetup)
static const unsigned int NUM_SIMULATION_ITERATIONS = 40000; static const unsigned int NUM_SIMULATION_ITERATIONS = 40000;
struct CacheTest : BasicTestingSetup {
// This is a large randomized insert/remove simulation test on a variable-size // This is a large randomized insert/remove simulation test on a variable-size
// stack of caches on top of CCoinsViewTest. // stack of caches on top of CCoinsViewTest.
// //
@ -277,9 +278,10 @@ void SimulationTest(CCoinsView* base, bool fake_best_block)
BOOST_CHECK(uncached_an_entry); BOOST_CHECK(uncached_an_entry);
BOOST_CHECK(flushed_without_erase); BOOST_CHECK(flushed_without_erase);
} }
}; // struct CacheTest
// Run the above simulation for multiple base types. // Run the above simulation for multiple base types.
BOOST_AUTO_TEST_CASE(coins_cache_simulation_test) BOOST_FIXTURE_TEST_CASE(coins_cache_simulation_test, CacheTest)
{ {
CCoinsViewTest base; CCoinsViewTest base;
SimulationTest(&base, false); SimulationTest(&base, false);
@ -288,6 +290,7 @@ BOOST_AUTO_TEST_CASE(coins_cache_simulation_test)
SimulationTest(&db_base, true); SimulationTest(&db_base, true);
} }
struct UpdateTest : BasicTestingSetup {
// Store of all necessary tx and undo data for next test // Store of all necessary tx and undo data for next test
typedef std::map<COutPoint, std::tuple<CTransaction,CTxUndo,Coin>> UtxoData; typedef std::map<COutPoint, std::tuple<CTransaction,CTxUndo,Coin>> UtxoData;
UtxoData utxoData; UtxoData utxoData;
@ -302,6 +305,7 @@ UtxoData::iterator FindRandomFrom(const std::set<COutPoint> &utxoSet) {
assert(utxoDataIt != utxoData.end()); assert(utxoDataIt != utxoData.end());
return utxoDataIt; return utxoDataIt;
} }
}; // struct UpdateTest
// This test is similar to the previous test // This test is similar to the previous test
@ -309,7 +313,7 @@ UtxoData::iterator FindRandomFrom(const std::set<COutPoint> &utxoSet) {
// random txs are created and UpdateCoins is used to update the cache stack // random txs are created and UpdateCoins is used to update the cache stack
// In particular it is tested that spending a duplicate coinbase tx // In particular it is tested that spending a duplicate coinbase tx
// has the expected effect (the other duplicate is overwritten at all cache levels) // has the expected effect (the other duplicate is overwritten at all cache levels)
BOOST_AUTO_TEST_CASE(updatecoins_simulation_test) BOOST_FIXTURE_TEST_CASE(updatecoins_simulation_test, UpdateTest)
{ {
SeedRandomForTest(SeedRand::ZEROS); SeedRandomForTest(SeedRand::ZEROS);
@ -888,6 +892,7 @@ BOOST_AUTO_TEST_CASE(ccoins_write)
} }
struct FlushTest : BasicTestingSetup {
Coin MakeCoin() Coin MakeCoin()
{ {
Coin coin; Coin coin;
@ -919,7 +924,7 @@ void TestFlushBehavior(
size_t cache_usage; size_t cache_usage;
size_t cache_size; size_t cache_size;
auto flush_all = [&all_caches](bool erase) { auto flush_all = [this, &all_caches](bool erase) {
// Flush in reverse order to ensure that flushes happen from children up. // Flush in reverse order to ensure that flushes happen from children up.
for (auto i = all_caches.rbegin(); i != all_caches.rend(); ++i) { for (auto i = all_caches.rbegin(); i != all_caches.rend(); ++i) {
auto& cache = *i; auto& cache = *i;
@ -1074,8 +1079,9 @@ void TestFlushBehavior(
BOOST_CHECK(!all_caches[0]->HaveCoinInCache(outp)); BOOST_CHECK(!all_caches[0]->HaveCoinInCache(outp));
BOOST_CHECK(!base.HaveCoin(outp)); BOOST_CHECK(!base.HaveCoin(outp));
} }
}; // struct FlushTest
BOOST_AUTO_TEST_CASE(ccoins_flush_behavior) BOOST_FIXTURE_TEST_CASE(ccoins_flush_behavior, FlushTest)
{ {
// Create two in-memory caches atop a leveldb view. // Create two in-memory caches atop a leveldb view.
CCoinsViewDB base{{.path = "test", .cache_bytes = 1 << 23, .memory_only = true}, {}}; CCoinsViewDB base{{.path = "test", .cache_bytes = 1 << 23, .memory_only = true}, {}};

41
src/test/crypto_tests.cpp
View file

@ -25,10 +25,11 @@
#include <boost/test/unit_test.hpp> #include <boost/test/unit_test.hpp>
BOOST_FIXTURE_TEST_SUITE(crypto_tests, BasicTestingSetup) namespace crypto_tests {
struct CryptoTest : BasicTestingSetup {
template<typename Hasher, typename In, typename Out> template<typename Hasher, typename In, typename Out>
static void TestVector(const Hasher &h, const In &in, const Out &out) { void TestVector(const Hasher &h, const In &in, const Out &out) {
Out hash; Out hash;
BOOST_CHECK(out.size() == h.OUTPUT_SIZE); BOOST_CHECK(out.size() == h.OUTPUT_SIZE);
hash.resize(out.size()); hash.resize(out.size());
@ -56,22 +57,22 @@ static void TestVector(const Hasher &h, const In &in, const Out &out) {
} }
} }
static void TestSHA1(const std::string &in, const std::string &hexout) { TestVector(CSHA1(), in, ParseHex(hexout));} void TestSHA1(const std::string &in, const std::string &hexout) { TestVector(CSHA1(), in, ParseHex(hexout));}
static void TestSHA256(const std::string &in, const std::string &hexout) { TestVector(CSHA256(), in, ParseHex(hexout));} void TestSHA256(const std::string &in, const std::string &hexout) { TestVector(CSHA256(), in, ParseHex(hexout));}
static void TestSHA512(const std::string &in, const std::string &hexout) { TestVector(CSHA512(), in, ParseHex(hexout));} void TestSHA512(const std::string &in, const std::string &hexout) { TestVector(CSHA512(), in, ParseHex(hexout));}
static void TestRIPEMD160(const std::string &in, const std::string &hexout) { TestVector(CRIPEMD160(), in, ParseHex(hexout));} void TestRIPEMD160(const std::string &in, const std::string &hexout) { TestVector(CRIPEMD160(), in, ParseHex(hexout));}
static void TestHMACSHA256(const std::string &hexkey, const std::string &hexin, const std::string &hexout) { void TestHMACSHA256(const std::string &hexkey, const std::string &hexin, const std::string &hexout) {
std::vector<unsigned char> key = ParseHex(hexkey); std::vector<unsigned char> key = ParseHex(hexkey);
TestVector(CHMAC_SHA256(key.data(), key.size()), ParseHex(hexin), ParseHex(hexout)); TestVector(CHMAC_SHA256(key.data(), key.size()), ParseHex(hexin), ParseHex(hexout));
} }
static void TestHMACSHA512(const std::string &hexkey, const std::string &hexin, const std::string &hexout) { void TestHMACSHA512(const std::string &hexkey, const std::string &hexin, const std::string &hexout) {
std::vector<unsigned char> key = ParseHex(hexkey); std::vector<unsigned char> key = ParseHex(hexkey);
TestVector(CHMAC_SHA512(key.data(), key.size()), ParseHex(hexin), ParseHex(hexout)); TestVector(CHMAC_SHA512(key.data(), key.size()), ParseHex(hexin), ParseHex(hexout));
} }
static void TestAES256(const std::string &hexkey, const std::string &hexin, const std::string &hexout) void TestAES256(const std::string &hexkey, const std::string &hexin, const std::string &hexout)
{ {
std::vector<unsigned char> key = ParseHex(hexkey); std::vector<unsigned char> key = ParseHex(hexkey);
std::vector<unsigned char> in = ParseHex(hexin); std::vector<unsigned char> in = ParseHex(hexin);
@ -90,7 +91,7 @@ static void TestAES256(const std::string &hexkey, const std::string &hexin, cons
BOOST_CHECK(buf == in); BOOST_CHECK(buf == in);
} }
static void TestAES256CBC(const std::string &hexkey, const std::string &hexiv, bool pad, const std::string &hexin, const std::string &hexout) void TestAES256CBC(const std::string &hexkey, const std::string &hexiv, bool pad, const std::string &hexin, const std::string &hexout)
{ {
std::vector<unsigned char> key = ParseHex(hexkey); std::vector<unsigned char> key = ParseHex(hexkey);
std::vector<unsigned char> iv = ParseHex(hexiv); std::vector<unsigned char> iv = ParseHex(hexiv);
@ -131,7 +132,7 @@ static void TestAES256CBC(const std::string &hexkey, const std::string &hexiv, b
} }
} }
static void TestChaCha20(const std::string &hex_message, const std::string &hexkey, ChaCha20::Nonce96 nonce, uint32_t seek, const std::string& hexout) void TestChaCha20(const std::string &hex_message, const std::string &hexkey, ChaCha20::Nonce96 nonce, uint32_t seek, const std::string& hexout)
{ {
auto key = ParseHex<std::byte>(hexkey); auto key = ParseHex<std::byte>(hexkey);
assert(key.size() == 32); assert(key.size() == 32);
@ -182,7 +183,7 @@ static void TestChaCha20(const std::string &hex_message, const std::string &hexk
} }
} }
static void TestFSChaCha20(const std::string& hex_plaintext, const std::string& hexkey, uint32_t rekey_interval, const std::string& ciphertext_after_rotation) void TestFSChaCha20(const std::string& hex_plaintext, const std::string& hexkey, uint32_t rekey_interval, const std::string& ciphertext_after_rotation)
{ {
auto key = ParseHex<std::byte>(hexkey); auto key = ParseHex<std::byte>(hexkey);
BOOST_CHECK_EQUAL(FSChaCha20::KEYLEN, key.size()); BOOST_CHECK_EQUAL(FSChaCha20::KEYLEN, key.size());
@ -222,7 +223,7 @@ static void TestFSChaCha20(const std::string& hex_plaintext, const std::string&
BOOST_CHECK_EQUAL(HexStr(fsc20_output), ciphertext_after_rotation); BOOST_CHECK_EQUAL(HexStr(fsc20_output), ciphertext_after_rotation);
} }
static void TestPoly1305(const std::string &hexmessage, const std::string &hexkey, const std::string& hextag) void TestPoly1305(const std::string &hexmessage, const std::string &hexkey, const std::string& hextag)
{ {
auto key = ParseHex<std::byte>(hexkey); auto key = ParseHex<std::byte>(hexkey);
auto m = ParseHex<std::byte>(hexmessage); auto m = ParseHex<std::byte>(hexmessage);
@ -247,7 +248,7 @@ static void TestPoly1305(const std::string &hexmessage, const std::string &hexke
} }
} }
static void TestChaCha20Poly1305(const std::string& plain_hex, const std::string& aad_hex, const std::string& key_hex, ChaCha20::Nonce96 nonce, const std::string& cipher_hex) void TestChaCha20Poly1305(const std::string& plain_hex, const std::string& aad_hex, const std::string& key_hex, ChaCha20::Nonce96 nonce, const std::string& cipher_hex)
{ {
auto plain = ParseHex<std::byte>(plain_hex); auto plain = ParseHex<std::byte>(plain_hex);
auto aad = ParseHex<std::byte>(aad_hex); auto aad = ParseHex<std::byte>(aad_hex);
@ -288,7 +289,7 @@ static void TestChaCha20Poly1305(const std::string& plain_hex, const std::string
} }
} }
static void TestFSChaCha20Poly1305(const std::string& plain_hex, const std::string& aad_hex, const std::string& key_hex, uint64_t msg_idx, const std::string& cipher_hex) void TestFSChaCha20Poly1305(const std::string& plain_hex, const std::string& aad_hex, const std::string& key_hex, uint64_t msg_idx, const std::string& cipher_hex)
{ {
auto plain = ParseHex<std::byte>(plain_hex); auto plain = ParseHex<std::byte>(plain_hex);
auto aad = ParseHex<std::byte>(aad_hex); auto aad = ParseHex<std::byte>(aad_hex);
@ -334,7 +335,7 @@ static void TestFSChaCha20Poly1305(const std::string& plain_hex, const std::stri
} }
} }
static void TestHKDF_SHA256_32(const std::string &ikm_hex, const std::string &salt_hex, const std::string &info_hex, const std::string &okm_check_hex) { void TestHKDF_SHA256_32(const std::string &ikm_hex, const std::string &salt_hex, const std::string &info_hex, const std::string &okm_check_hex) {
std::vector<unsigned char> initial_key_material = ParseHex(ikm_hex); std::vector<unsigned char> initial_key_material = ParseHex(ikm_hex);
std::vector<unsigned char> salt = ParseHex(salt_hex); std::vector<unsigned char> salt = ParseHex(salt_hex);
std::vector<unsigned char> info = ParseHex(info_hex); std::vector<unsigned char> info = ParseHex(info_hex);
@ -350,6 +351,10 @@ static void TestHKDF_SHA256_32(const std::string &ikm_hex, const std::string &sa
BOOST_CHECK(HexStr(out) == okm_check_hex); BOOST_CHECK(HexStr(out) == okm_check_hex);
} }
void TestSHA3_256(const std::string& input, const std::string& output);
}; // struct CryptoTests
} // namespace crypto_tests
static std::string LongTestString() static std::string LongTestString()
{ {
std::string ret; std::string ret;
@ -365,6 +370,8 @@ static std::string LongTestString()
const std::string test1 = LongTestString(); const std::string test1 = LongTestString();
BOOST_FIXTURE_TEST_SUITE(crypto_tests, CryptoTest)
BOOST_AUTO_TEST_CASE(ripemd160_testvectors) { BOOST_AUTO_TEST_CASE(ripemd160_testvectors) {
TestRIPEMD160("", "9c1185a5c5e9fc54612808977ee8f548b2258d31"); TestRIPEMD160("", "9c1185a5c5e9fc54612808977ee8f548b2258d31");
TestRIPEMD160("abc", "8eb208f7e05d987a9b044a8e98c6b087f15a0bfc"); TestRIPEMD160("abc", "8eb208f7e05d987a9b044a8e98c6b087f15a0bfc");
@ -1076,7 +1083,7 @@ BOOST_AUTO_TEST_CASE(sha256d64)
} }
} }
static void TestSHA3_256(const std::string& input, const std::string& output) void CryptoTest::TestSHA3_256(const std::string& input, const std::string& output)
{ {
const auto in_bytes = ParseHex(input); const auto in_bytes = ParseHex(input);
const auto out_bytes = ParseHex(output); const auto out_bytes = ParseHex(output);

26
src/test/cuckoocache_tests.cpp
View file

@ -29,7 +29,7 @@
* using BOOST_CHECK_CLOSE to fail. * using BOOST_CHECK_CLOSE to fail.
* *
*/ */
BOOST_AUTO_TEST_SUITE(cuckoocache_tests); BOOST_FIXTURE_TEST_SUITE(cuckoocache_tests, BasicTestingSetup);
/* Test that no values not inserted into the cache are read out of it. /* Test that no values not inserted into the cache are read out of it.
* *
@ -49,11 +49,12 @@ BOOST_AUTO_TEST_CASE(test_cuckoocache_no_fakes)
} }
}; };
struct HitRateTest : BasicTestingSetup {
/** This helper returns the hit rate when megabytes*load worth of entries are /** This helper returns the hit rate when megabytes*load worth of entries are
* inserted into a megabytes sized cache * inserted into a megabytes sized cache
*/ */
template <typename Cache> template <typename Cache>
static double test_cache(size_t megabytes, double load) double test_cache(size_t megabytes, double load)
{ {
SeedRandomForTest(SeedRand::ZEROS); SeedRandomForTest(SeedRand::ZEROS);
std::vector<uint256> hashes; std::vector<uint256> hashes;
@ -104,9 +105,10 @@ static double normalize_hit_rate(double hits, double load)
{ {
return hits * std::max(load, 1.0); return hits * std::max(load, 1.0);
} }
}; // struct HitRateTest
/** Check the hit rate on loads ranging from 0.1 to 1.6 */ /** Check the hit rate on loads ranging from 0.1 to 1.6 */
BOOST_AUTO_TEST_CASE(cuckoocache_hit_rate_ok) BOOST_FIXTURE_TEST_CASE(cuckoocache_hit_rate_ok, HitRateTest)
{ {
/** Arbitrarily selected Hit Rate threshold that happens to work for this test /** Arbitrarily selected Hit Rate threshold that happens to work for this test
* as a lower bound on performance. * as a lower bound on performance.
@ -120,10 +122,11 @@ BOOST_AUTO_TEST_CASE(cuckoocache_hit_rate_ok)
} }
struct EraseTest : BasicTestingSetup {
/** This helper checks that erased elements are preferentially inserted onto and /** This helper checks that erased elements are preferentially inserted onto and
* that the hit rate of "fresher" keys is reasonable*/ * that the hit rate of "fresher" keys is reasonable*/
template <typename Cache> template <typename Cache>
static void test_cache_erase(size_t megabytes) void test_cache_erase(size_t megabytes)
{ {
double load = 1; double load = 1;
SeedRandomForTest(SeedRand::ZEROS); SeedRandomForTest(SeedRand::ZEROS);
@ -178,15 +181,17 @@ static void test_cache_erase(size_t megabytes)
// erased elements. // erased elements.
BOOST_CHECK(hit_rate_stale > 2 * hit_rate_erased_but_contained); BOOST_CHECK(hit_rate_stale > 2 * hit_rate_erased_but_contained);
} }
}; // struct EraseTest
BOOST_AUTO_TEST_CASE(cuckoocache_erase_ok) BOOST_FIXTURE_TEST_CASE(cuckoocache_erase_ok, EraseTest)
{ {
size_t megabytes = 4; size_t megabytes = 4;
test_cache_erase<CuckooCache::cache<uint256, SignatureCacheHasher>>(megabytes); test_cache_erase<CuckooCache::cache<uint256, SignatureCacheHasher>>(megabytes);
} }
struct EraseParallelTest : BasicTestingSetup {
template <typename Cache> template <typename Cache>
static void test_cache_erase_parallel(size_t megabytes) void test_cache_erase_parallel(size_t megabytes)
{ {
double load = 1; double load = 1;
SeedRandomForTest(SeedRand::ZEROS); SeedRandomForTest(SeedRand::ZEROS);
@ -268,15 +273,17 @@ static void test_cache_erase_parallel(size_t megabytes)
// erased elements. // erased elements.
BOOST_CHECK(hit_rate_stale > 2 * hit_rate_erased_but_contained); BOOST_CHECK(hit_rate_stale > 2 * hit_rate_erased_but_contained);
} }
BOOST_AUTO_TEST_CASE(cuckoocache_erase_parallel_ok) }; // struct EraseParallelTest
BOOST_FIXTURE_TEST_CASE(cuckoocache_erase_parallel_ok, EraseParallelTest)
{ {
size_t megabytes = 4; size_t megabytes = 4;
test_cache_erase_parallel<CuckooCache::cache<uint256, SignatureCacheHasher>>(megabytes); test_cache_erase_parallel<CuckooCache::cache<uint256, SignatureCacheHasher>>(megabytes);
} }
struct GenerationsTest : BasicTestingSetup {
template <typename Cache> template <typename Cache>
static void test_cache_generations() void test_cache_generations()
{ {
// This test checks that for a simulation of network activity, the fresh hit // This test checks that for a simulation of network activity, the fresh hit
// rate is never below 99%, and the number of times that it is worse than // rate is never below 99%, and the number of times that it is worse than
@ -365,7 +372,8 @@ static void test_cache_generations()
// max_rate_less_than_tight_hit_rate of the time // max_rate_less_than_tight_hit_rate of the time
BOOST_CHECK(double(out_of_tight_tolerance) / double(total) < max_rate_less_than_tight_hit_rate); BOOST_CHECK(double(out_of_tight_tolerance) / double(total) < max_rate_less_than_tight_hit_rate);
} }
BOOST_AUTO_TEST_CASE(cuckoocache_generations) }; // struct GenerationsTest
BOOST_FIXTURE_TEST_CASE(cuckoocache_generations, GenerationsTest)
{ {
test_cache_generations<CuckooCache::cache<uint256, SignatureCacheHasher>>(); test_cache_generations<CuckooCache::cache<uint256, SignatureCacheHasher>>();
} }

8
src/test/denialofservice_tests.cpp
View file

@ -106,7 +106,8 @@ BOOST_AUTO_TEST_CASE(outbound_slow_chain_eviction)
peerman.FinalizeNode(dummyNode1); peerman.FinalizeNode(dummyNode1);
} }
static void AddRandomOutboundPeer(NodeId& id, std::vector<CNode*>& vNodes, PeerManager& peerLogic, ConnmanTestMsg& connman, ConnectionType connType, bool onion_peer = false) struct OutboundTest : TestingSetup {
void AddRandomOutboundPeer(NodeId& id, std::vector<CNode*>& vNodes, PeerManager& peerLogic, ConnmanTestMsg& connman, ConnectionType connType, bool onion_peer = false)
{ {
CAddress addr; CAddress addr;
@ -136,8 +137,9 @@ static void AddRandomOutboundPeer(NodeId& id, std::vector<CNode*>& vNodes, PeerM
connman.AddTestNode(node); connman.AddTestNode(node);
} }
}; // struct OutboundTest
BOOST_AUTO_TEST_CASE(stale_tip_peer_management) BOOST_FIXTURE_TEST_CASE(stale_tip_peer_management, OutboundTest)
{ {
NodeId id{0}; NodeId id{0};
auto connman = std::make_unique<ConnmanTestMsg>(0x1337, 0x1337, *m_node.addrman, *m_node.netgroupman, Params()); auto connman = std::make_unique<ConnmanTestMsg>(0x1337, 0x1337, *m_node.addrman, *m_node.netgroupman, Params());
@ -235,7 +237,7 @@ BOOST_AUTO_TEST_CASE(stale_tip_peer_management)
connman->ClearTestNodes(); connman->ClearTestNodes();
} }
BOOST_AUTO_TEST_CASE(block_relay_only_eviction) BOOST_FIXTURE_TEST_CASE(block_relay_only_eviction, OutboundTest)
{ {
NodeId id{0}; NodeId id{0};
auto connman = std::make_unique<ConnmanTestMsg>(0x1337, 0x1337, *m_node.addrman, *m_node.netgroupman, Params()); auto connman = std::make_unique<ConnmanTestMsg>(0x1337, 0x1337, *m_node.addrman, *m_node.netgroupman, Params());

2
src/test/hash_tests.cpp
View file

@ -11,7 +11,7 @@
#include <boost/test/unit_test.hpp> #include <boost/test/unit_test.hpp>
BOOST_AUTO_TEST_SUITE(hash_tests) BOOST_FIXTURE_TEST_SUITE(hash_tests, BasicTestingSetup)
BOOST_AUTO_TEST_CASE(murmurhash3) BOOST_AUTO_TEST_CASE(murmurhash3)
{ {

4
src/test/miniscript_tests.cpp
View file

@ -340,6 +340,7 @@ void SatisfactionToWitness(miniscript::MiniscriptContext ctx, CScriptWitness& wi
witness.stack.push_back(*builder.GetSpendData().scripts.begin()->second.begin()); witness.stack.push_back(*builder.GetSpendData().scripts.begin()->second.begin());
} }
struct MiniScriptTest : BasicTestingSetup {
/** Run random satisfaction tests. */ /** Run random satisfaction tests. */
void TestSatisfy(const KeyConverter& converter, const std::string& testcase, const NodeRef& node) { void TestSatisfy(const KeyConverter& converter, const std::string& testcase, const NodeRef& node) {
auto script = node->ToScript(converter); auto script = node->ToScript(converter);
@ -488,10 +489,11 @@ void Test(const std::string& ms, const std::string& hexscript, const std::string
/*opslimit=*/-1, /*stacklimit=*/-1, /*opslimit=*/-1, /*stacklimit=*/-1,
/*max_wit_size=*/std::nullopt, /*max_tap_wit_size=*/std::nullopt, /*stack_exec=*/std::nullopt); /*max_wit_size=*/std::nullopt, /*max_tap_wit_size=*/std::nullopt, /*stack_exec=*/std::nullopt);
} }
}; // struct MiniScriptTest
} // namespace } // namespace
BOOST_FIXTURE_TEST_SUITE(miniscript_tests, BasicTestingSetup) BOOST_FIXTURE_TEST_SUITE(miniscript_tests, MiniScriptTest)
BOOST_AUTO_TEST_CASE(fixed_tests) BOOST_AUTO_TEST_CASE(fixed_tests)
{ {

2
src/test/minisketch_tests.cpp
View file

@ -14,7 +14,7 @@
using node::MakeMinisketch32; using node::MakeMinisketch32;
BOOST_AUTO_TEST_SUITE(minisketch_tests) BOOST_FIXTURE_TEST_SUITE(minisketch_tests, BasicTestingSetup)
BOOST_AUTO_TEST_CASE(minisketch_test) BOOST_AUTO_TEST_CASE(minisketch_test)
{ {

6
src/test/net_peer_connection_tests.cpp
View file

@ -43,8 +43,9 @@ static CService ip(uint32_t i)
return CService{CNetAddr{s}, Params().GetDefaultPort()}; return CService{CNetAddr{s}, Params().GetDefaultPort()};
} }
struct PeerTest : LogIPsTestingSetup {
/** Create a peer and connect to it. If the optional `address` (IP/CJDNS only) isn't passed, a random address is created. */ /** Create a peer and connect to it. If the optional `address` (IP/CJDNS only) isn't passed, a random address is created. */
static void AddPeer(NodeId& id, std::vector<CNode*>& nodes, PeerManager& peerman, ConnmanTestMsg& connman, ConnectionType conn_type, bool onion_peer = false, std::optional<std::string> address = std::nullopt) void AddPeer(NodeId& id, std::vector<CNode*>& nodes, PeerManager& peerman, ConnmanTestMsg& connman, ConnectionType conn_type, bool onion_peer = false, std::optional<std::string> address = std::nullopt)
{ {
CAddress addr{}; CAddress addr{};
@ -80,8 +81,9 @@ static void AddPeer(NodeId& id, std::vector<CNode*>& nodes, PeerManager& peerman
connman.AddTestNode(node); connman.AddTestNode(node);
} }
}; // struct PeerTest
BOOST_AUTO_TEST_CASE(test_addnode_getaddednodeinfo_and_connection_detection) BOOST_FIXTURE_TEST_CASE(test_addnode_getaddednodeinfo_and_connection_detection, PeerTest)
{ {
auto connman = std::make_unique<ConnmanTestMsg>(0x1337, 0x1337, *m_node.addrman, *m_node.netgroupman, Params()); auto connman = std::make_unique<ConnmanTestMsg>(0x1337, 0x1337, *m_node.addrman, *m_node.netgroupman, Params());
auto peerman = PeerManager::make(*connman, *m_node.addrman, nullptr, *m_node.chainman, *m_node.mempool, *m_node.warnings, {}); auto peerman = PeerManager::make(*connman, *m_node.addrman, nullptr, *m_node.chainman, *m_node.mempool, *m_node.warnings, {});

12
src/test/script_tests.cpp
View file

@ -110,8 +110,7 @@ static ScriptError_t ParseScriptError(const std::string& name)
return SCRIPT_ERR_UNKNOWN_ERROR; return SCRIPT_ERR_UNKNOWN_ERROR;
} }
BOOST_FIXTURE_TEST_SUITE(script_tests, BasicTestingSetup) struct ScriptTest : BasicTestingSetup {
void DoTest(const CScript& scriptPubKey, const CScript& scriptSig, const CScriptWitness& scriptWitness, uint32_t flags, const std::string& message, int scriptError, CAmount nValue = 0) void DoTest(const CScript& scriptPubKey, const CScript& scriptSig, const CScriptWitness& scriptWitness, uint32_t flags, const std::string& message, int scriptError, CAmount nValue = 0)
{ {
bool expect = (scriptError == SCRIPT_ERR_OK); bool expect = (scriptError == SCRIPT_ERR_OK);
@ -136,6 +135,7 @@ void DoTest(const CScript& scriptPubKey, const CScript& scriptSig, const CScript
BOOST_CHECK_MESSAGE(VerifyScript(scriptSig, scriptPubKey, &scriptWitness, combined_flags, MutableTransactionSignatureChecker(&tx, 0, txCredit.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err) == expect, message + strprintf(" (with flags %x)", combined_flags)); BOOST_CHECK_MESSAGE(VerifyScript(scriptSig, scriptPubKey, &scriptWitness, combined_flags, MutableTransactionSignatureChecker(&tx, 0, txCredit.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err) == expect, message + strprintf(" (with flags %x)", combined_flags));
} }
} }
}; // struct ScriptTest
void static NegateSignatureS(std::vector<unsigned char>& vchSig) { void static NegateSignatureS(std::vector<unsigned char>& vchSig) {
// Parse the signature. // Parse the signature.
@ -369,11 +369,11 @@ public:
return *this; return *this;
} }
TestBuilder& Test() TestBuilder& Test(ScriptTest& test)
{ {
TestBuilder copy = *this; // Make a copy so we can rollback the push. TestBuilder copy = *this; // Make a copy so we can rollback the push.
DoPush(); DoPush();
DoTest(creditTx->vout[0].scriptPubKey, spendTx.vin[0].scriptSig, scriptWitness, flags, comment, scriptError, nValue); test.DoTest(creditTx->vout[0].scriptPubKey, spendTx.vin[0].scriptSig, scriptWitness, flags, comment, scriptError, nValue);
*this = copy; *this = copy;
return *this; return *this;
} }
@ -425,6 +425,8 @@ std::string JSONPrettyPrint(const UniValue& univalue)
} }
} // namespace } // namespace
BOOST_FIXTURE_TEST_SUITE(script_tests, ScriptTest)
BOOST_AUTO_TEST_CASE(script_build) BOOST_AUTO_TEST_CASE(script_build)
{ {
const KeyData keys; const KeyData keys;
@ -884,7 +886,7 @@ BOOST_AUTO_TEST_CASE(script_build)
std::string strGen; std::string strGen;
#endif #endif
for (TestBuilder& test : tests) { for (TestBuilder& test : tests) {
test.Test(); test.Test(*this);
std::string str = JSONPrettyPrint(test.GetJSON()); std::string str = JSONPrettyPrint(test.GetJSON());
#ifdef UPDATE_JSON_TESTS #ifdef UPDATE_JSON_TESTS
strGen += str + ",\n"; strGen += str + ",\n";

8
src/test/sighash_tests.cpp
View file

@ -82,7 +82,8 @@ uint256 static SignatureHashOld(CScript scriptCode, const CTransaction& txTo, un
return ss.GetHash(); return ss.GetHash();
} }
void static RandomScript(CScript &script) { struct SigHashTest : BasicTestingSetup {
void RandomScript(CScript &script) {
static const opcodetype oplist[] = {OP_FALSE, OP_1, OP_2, OP_3, OP_CHECKSIG, OP_IF, OP_VERIF, OP_RETURN, OP_CODESEPARATOR}; static const opcodetype oplist[] = {OP_FALSE, OP_1, OP_2, OP_3, OP_CHECKSIG, OP_IF, OP_VERIF, OP_RETURN, OP_CODESEPARATOR};
script = CScript(); script = CScript();
int ops = (InsecureRandRange(10)); int ops = (InsecureRandRange(10));
@ -90,7 +91,7 @@ void static RandomScript(CScript &script) {
script << oplist[InsecureRandRange(std::size(oplist))]; script << oplist[InsecureRandRange(std::size(oplist))];
} }
void static RandomTransaction(CMutableTransaction& tx, bool fSingle) void RandomTransaction(CMutableTransaction& tx, bool fSingle)
{ {
tx.version = InsecureRand32(); tx.version = InsecureRand32();
tx.vin.clear(); tx.vin.clear();
@ -113,8 +114,9 @@ void static RandomTransaction(CMutableTransaction& tx, bool fSingle)
RandomScript(txout.scriptPubKey); RandomScript(txout.scriptPubKey);
} }
} }
}; // struct SigHashTest
BOOST_FIXTURE_TEST_SUITE(sighash_tests, BasicTestingSetup) BOOST_FIXTURE_TEST_SUITE(sighash_tests, SigHashTest)
BOOST_AUTO_TEST_CASE(sighash_test) BOOST_AUTO_TEST_CASE(sighash_test)
{ {

22
src/test/txpackage_tests.cpp
View file

@ -20,11 +20,11 @@
#include <boost/test/unit_test.hpp> #include <boost/test/unit_test.hpp>
BOOST_AUTO_TEST_SUITE(txpackage_tests)
// A fee amount that is above 1sat/vB but below 5sat/vB for most transactions created within these // A fee amount that is above 1sat/vB but below 5sat/vB for most transactions created within these
// unit tests. // unit tests.
static const CAmount low_fee_amt{200}; static const CAmount low_fee_amt{200};
struct TxPackageTest : TestChain100Setup {
// Create placeholder transactions that have no meaning. // Create placeholder transactions that have no meaning.
inline CTransactionRef create_placeholder_tx(size_t num_inputs, size_t num_outputs) inline CTransactionRef create_placeholder_tx(size_t num_inputs, size_t num_outputs)
{ {
@ -43,7 +43,11 @@ inline CTransactionRef create_placeholder_tx(size_t num_inputs, size_t num_outpu
} }
return MakeTransactionRef(mtx); return MakeTransactionRef(mtx);
} }
BOOST_FIXTURE_TEST_CASE(package_hash_tests, TestChain100Setup) }; // struct TxPackageTest
BOOST_FIXTURE_TEST_SUITE(txpackage_tests, TxPackageTest)
BOOST_AUTO_TEST_CASE(package_hash_tests)
{ {
// Random real segwit transaction // Random real segwit transaction
DataStream stream_1{ DataStream stream_1{
@ -124,7 +128,7 @@ BOOST_FIXTURE_TEST_CASE(package_hash_tests, TestChain100Setup)
BOOST_CHECK_EQUAL(calculated_hash_123, GetPackageHash(package_321)); BOOST_CHECK_EQUAL(calculated_hash_123, GetPackageHash(package_321));
} }
BOOST_FIXTURE_TEST_CASE(package_sanitization_tests, TestChain100Setup) BOOST_AUTO_TEST_CASE(package_sanitization_tests)
{ {
// Packages can't have more than 25 transactions. // Packages can't have more than 25 transactions.
Package package_too_many; Package package_too_many;
@ -194,7 +198,7 @@ BOOST_FIXTURE_TEST_CASE(package_sanitization_tests, TestChain100Setup)
BOOST_CHECK(IsConsistentPackage(package_with_dup_tx)); BOOST_CHECK(IsConsistentPackage(package_with_dup_tx));
} }
BOOST_FIXTURE_TEST_CASE(package_validation_tests, TestChain100Setup) BOOST_AUTO_TEST_CASE(package_validation_tests)
{ {
LOCK(cs_main); LOCK(cs_main);
unsigned int initialPoolSize = m_node.mempool->size(); unsigned int initialPoolSize = m_node.mempool->size();
@ -249,7 +253,7 @@ BOOST_FIXTURE_TEST_CASE(package_validation_tests, TestChain100Setup)
BOOST_CHECK_EQUAL(m_node.mempool->size(), initialPoolSize); BOOST_CHECK_EQUAL(m_node.mempool->size(), initialPoolSize);
} }
BOOST_FIXTURE_TEST_CASE(noncontextual_package_tests, TestChain100Setup) BOOST_AUTO_TEST_CASE(noncontextual_package_tests)
{ {
// The signatures won't be verified so we can just use a placeholder // The signatures won't be verified so we can just use a placeholder
CKey placeholder_key = GenerateRandomKey(); CKey placeholder_key = GenerateRandomKey();
@ -345,7 +349,7 @@ BOOST_FIXTURE_TEST_CASE(noncontextual_package_tests, TestChain100Setup)
} }
} }
BOOST_FIXTURE_TEST_CASE(package_submission_tests, TestChain100Setup) BOOST_AUTO_TEST_CASE(package_submission_tests)
{ {
LOCK(cs_main); LOCK(cs_main);
unsigned int expected_pool_size = m_node.mempool->size(); unsigned int expected_pool_size = m_node.mempool->size();
@ -488,7 +492,7 @@ BOOST_FIXTURE_TEST_CASE(package_submission_tests, TestChain100Setup)
// Tests for packages containing transactions that have same-txid-different-witness equivalents in // Tests for packages containing transactions that have same-txid-different-witness equivalents in
// the mempool. // the mempool.
BOOST_FIXTURE_TEST_CASE(package_witness_swap_tests, TestChain100Setup) BOOST_AUTO_TEST_CASE(package_witness_swap_tests)
{ {
// Mine blocks to mature coinbases. // Mine blocks to mature coinbases.
mineBlocks(5); mineBlocks(5);
@ -722,7 +726,7 @@ BOOST_FIXTURE_TEST_CASE(package_witness_swap_tests, TestChain100Setup)
} }
} }
BOOST_FIXTURE_TEST_CASE(package_cpfp_tests, TestChain100Setup) BOOST_AUTO_TEST_CASE(package_cpfp_tests)
{ {
mineBlocks(5); mineBlocks(5);
MockMempoolMinFee(CFeeRate(5000)); MockMempoolMinFee(CFeeRate(5000));
@ -933,7 +937,7 @@ BOOST_FIXTURE_TEST_CASE(package_cpfp_tests, TestChain100Setup)
} }
} }
BOOST_FIXTURE_TEST_CASE(package_rbf_tests, TestChain100Setup) BOOST_AUTO_TEST_CASE(package_rbf_tests)
{ {
mineBlocks(5); mineBlocks(5);
LOCK(::cs_main); LOCK(::cs_main);

53
src/test/txrequest_tests.cpp
View file

@ -15,10 +15,23 @@
#include <boost/test/unit_test.hpp> #include <boost/test/unit_test.hpp>
BOOST_FIXTURE_TEST_SUITE(txrequest_tests, BasicTestingSetup)
namespace { namespace {
class Scenario;
struct TxRequestTest : BasicTestingSetup {
std::chrono::microseconds RandomTime8s();
std::chrono::microseconds RandomTime1y();
void BuildSingleTest(Scenario& scenario, int config);
void BuildPriorityTest(Scenario& scenario, int config);
void BuildBigPriorityTest(Scenario& scenario, int peers);
void BuildRequestOrderTest(Scenario& scenario, int config);
void BuildWtxidTest(Scenario& scenario, int config);
void BuildTimeBackwardsTest(Scenario& scenario);
void BuildWeirdRequestsTest(Scenario& scenario);
void TestInterleavedScenarios();
};
constexpr std::chrono::microseconds MIN_TIME = std::chrono::microseconds::min(); constexpr std::chrono::microseconds MIN_TIME = std::chrono::microseconds::min();
constexpr std::chrono::microseconds MAX_TIME = std::chrono::microseconds::max(); constexpr std::chrono::microseconds MAX_TIME = std::chrono::microseconds::max();
constexpr std::chrono::microseconds MICROSECOND = std::chrono::microseconds{1}; constexpr std::chrono::microseconds MICROSECOND = std::chrono::microseconds{1};
@ -51,8 +64,8 @@ struct Runner
std::multiset<std::pair<NodeId, GenTxid>> expired; std::multiset<std::pair<NodeId, GenTxid>> expired;
}; };
std::chrono::microseconds RandomTime8s() { return std::chrono::microseconds{1 + InsecureRandBits(23)}; } std::chrono::microseconds TxRequestTest::RandomTime8s() { return std::chrono::microseconds{1 + InsecureRandBits(23)}; }
std::chrono::microseconds RandomTime1y() { return std::chrono::microseconds{1 + InsecureRandBits(45)}; } std::chrono::microseconds TxRequestTest::RandomTime1y() { return std::chrono::microseconds{1 + InsecureRandBits(45)}; }
/** A proxy for a Runner that helps build a sequence of consecutive test actions on a TxRequestTracker. /** A proxy for a Runner that helps build a sequence of consecutive test actions on a TxRequestTracker.
* *
@ -245,7 +258,7 @@ public:
* *
* config is an integer in [0, 32), which controls which variant of the test is used. * config is an integer in [0, 32), which controls which variant of the test is used.
*/ */
void BuildSingleTest(Scenario& scenario, int config) void TxRequestTest::BuildSingleTest(Scenario& scenario, int config)
{ {
auto peer = scenario.NewPeer(); auto peer = scenario.NewPeer();
auto gtxid = scenario.NewGTxid(); auto gtxid = scenario.NewGTxid();
@ -305,7 +318,7 @@ void BuildSingleTest(Scenario& scenario, int config)
* *
* config is an integer in [0, 32), which controls which variant of the test is used. * config is an integer in [0, 32), which controls which variant of the test is used.
*/ */
void BuildPriorityTest(Scenario& scenario, int config) void TxRequestTest::BuildPriorityTest(Scenario& scenario, int config)
{ {
scenario.SetTestName(strprintf("Priority(config=%i)", config)); scenario.SetTestName(strprintf("Priority(config=%i)", config));
@ -367,7 +380,7 @@ void BuildPriorityTest(Scenario& scenario, int config)
/** Add to scenario a randomized test in which N peers announce the same transaction, to verify /** Add to scenario a randomized test in which N peers announce the same transaction, to verify
* the order in which they are requested. */ * the order in which they are requested. */
void BuildBigPriorityTest(Scenario& scenario, int peers) void TxRequestTest::BuildBigPriorityTest(Scenario& scenario, int peers)
{ {
scenario.SetTestName(strprintf("BigPriority(peers=%i)", peers)); scenario.SetTestName(strprintf("BigPriority(peers=%i)", peers));
@ -454,7 +467,7 @@ void BuildBigPriorityTest(Scenario& scenario, int peers)
* *
* config is an integer in [0, 4) inclusive, and selects the variant of the test. * config is an integer in [0, 4) inclusive, and selects the variant of the test.
*/ */
void BuildRequestOrderTest(Scenario& scenario, int config) void TxRequestTest::BuildRequestOrderTest(Scenario& scenario, int config)
{ {
scenario.SetTestName(strprintf("RequestOrder(config=%i)", config)); scenario.SetTestName(strprintf("RequestOrder(config=%i)", config));
@ -489,7 +502,7 @@ void BuildRequestOrderTest(Scenario& scenario, int config)
* *
* config is an integer in [0, 4) inclusive, and selects the variant of the test used. * config is an integer in [0, 4) inclusive, and selects the variant of the test used.
*/ */
void BuildWtxidTest(Scenario& scenario, int config) void TxRequestTest::BuildWtxidTest(Scenario& scenario, int config)
{ {
scenario.SetTestName(strprintf("Wtxid(config=%i)", config)); scenario.SetTestName(strprintf("Wtxid(config=%i)", config));
@ -559,7 +572,7 @@ void BuildWtxidTest(Scenario& scenario, int config)
} }
/** Add to scenario a test that exercises clocks that go backwards. */ /** Add to scenario a test that exercises clocks that go backwards. */
void BuildTimeBackwardsTest(Scenario& scenario) void TxRequestTest::BuildTimeBackwardsTest(Scenario& scenario)
{ {
auto peer1 = scenario.NewPeer(); auto peer1 = scenario.NewPeer();
auto peer2 = scenario.NewPeer(); auto peer2 = scenario.NewPeer();
@ -605,7 +618,7 @@ void BuildTimeBackwardsTest(Scenario& scenario)
} }
/** Add to scenario a test that involves RequestedTx() calls for txhashes not returned by GetRequestable. */ /** Add to scenario a test that involves RequestedTx() calls for txhashes not returned by GetRequestable. */
void BuildWeirdRequestsTest(Scenario& scenario) void TxRequestTest::BuildWeirdRequestsTest(Scenario& scenario)
{ {
auto peer1 = scenario.NewPeer(); auto peer1 = scenario.NewPeer();
auto peer2 = scenario.NewPeer(); auto peer2 = scenario.NewPeer();
@ -682,19 +695,19 @@ void BuildWeirdRequestsTest(Scenario& scenario)
scenario.Check(peer2, {}, 0, 0, 0, "q23"); scenario.Check(peer2, {}, 0, 0, 0, "q23");
} }
void TestInterleavedScenarios() void TxRequestTest::TestInterleavedScenarios()
{ {
// Create a list of functions which add tests to scenarios. // Create a list of functions which add tests to scenarios.
std::vector<std::function<void(Scenario&)>> builders; std::vector<std::function<void(Scenario&)>> builders;
// Add instances of every test, for every configuration. // Add instances of every test, for every configuration.
for (int n = 0; n < 64; ++n) { for (int n = 0; n < 64; ++n) {
builders.emplace_back([n](Scenario& scenario){ BuildWtxidTest(scenario, n); }); builders.emplace_back([this, n](Scenario& scenario) { BuildWtxidTest(scenario, n); });
builders.emplace_back([n](Scenario& scenario){ BuildRequestOrderTest(scenario, n & 3); }); builders.emplace_back([this, n](Scenario& scenario) { BuildRequestOrderTest(scenario, n & 3); });
builders.emplace_back([n](Scenario& scenario){ BuildSingleTest(scenario, n & 31); }); builders.emplace_back([this, n](Scenario& scenario) { BuildSingleTest(scenario, n & 31); });
builders.emplace_back([n](Scenario& scenario){ BuildPriorityTest(scenario, n & 31); }); builders.emplace_back([this, n](Scenario& scenario) { BuildPriorityTest(scenario, n & 31); });
builders.emplace_back([n](Scenario& scenario){ BuildBigPriorityTest(scenario, (n & 7) + 1); }); builders.emplace_back([this, n](Scenario& scenario) { BuildBigPriorityTest(scenario, (n & 7) + 1); });
builders.emplace_back([](Scenario& scenario){ BuildTimeBackwardsTest(scenario); }); builders.emplace_back([this](Scenario& scenario) { BuildTimeBackwardsTest(scenario); });
builders.emplace_back([](Scenario& scenario){ BuildWeirdRequestsTest(scenario); }); builders.emplace_back([this](Scenario& scenario) { BuildWeirdRequestsTest(scenario); });
} }
// Randomly shuffle all those functions. // Randomly shuffle all those functions.
std::shuffle(builders.begin(), builders.end(), g_insecure_rand_ctx); std::shuffle(builders.begin(), builders.end(), g_insecure_rand_ctx);
@ -730,6 +743,8 @@ void TestInterleavedScenarios()
} // namespace } // namespace
BOOST_FIXTURE_TEST_SUITE(txrequest_tests, TxRequestTest)
BOOST_AUTO_TEST_CASE(TxRequestTest) BOOST_AUTO_TEST_CASE(TxRequestTest)
{ {
for (int i = 0; i < 5; ++i) { for (int i = 0; i < 5; ++i) {

6
src/test/versionbits_tests.cpp
View file

@ -256,8 +256,9 @@ BOOST_AUTO_TEST_CASE(versionbits_test)
} }
} }
struct BlockVersionTest : BasicTestingSetup {
/** Check that ComputeBlockVersion will set the appropriate bit correctly */ /** Check that ComputeBlockVersion will set the appropriate bit correctly */
static void check_computeblockversion(VersionBitsCache& versionbitscache, const Consensus::Params& params, Consensus::DeploymentPos dep) void check_computeblockversion(VersionBitsCache& versionbitscache, const Consensus::Params& params, Consensus::DeploymentPos dep)
{ {
// Clear the cache every time // Clear the cache every time
versionbitscache.Clear(); versionbitscache.Clear();
@ -412,8 +413,9 @@ static void check_computeblockversion(VersionBitsCache& versionbitscache, const
// Check that we don't signal after activation // Check that we don't signal after activation
BOOST_CHECK_EQUAL(versionbitscache.ComputeBlockVersion(lastBlock, params) & (1 << bit), 0); BOOST_CHECK_EQUAL(versionbitscache.ComputeBlockVersion(lastBlock, params) & (1 << bit), 0);
} }
}; // struct BlockVersionTest
BOOST_AUTO_TEST_CASE(versionbits_computeblockversion) BOOST_FIXTURE_TEST_CASE(versionbits_computeblockversion, BlockVersionTest)
{ {
VersionBitsCache vbcache; VersionBitsCache vbcache;