Bitcoin Core 28.99.0
P2P Digital Currency
setup_common.h
Go to the documentation of this file.
1// Copyright (c) 2015-present The Bitcoin Core developers
2// Distributed under the MIT software license, see the accompanying
3// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5#ifndef BITCOIN_TEST_UTIL_SETUP_COMMON_H
6#define BITCOIN_TEST_UTIL_SETUP_COMMON_H
7
8#include <common/args.h> // IWYU pragma: export
9#include <kernel/caches.h>
10#include <kernel/context.h>
11#include <key.h>
12#include <node/caches.h>
13#include <node/context.h> // IWYU pragma: export
14#include <optional>
15#include <ostream>
17#include <pubkey.h>
18#include <stdexcept>
19#include <test/util/random.h>
20#include <util/chaintype.h> // IWYU pragma: export
21#include <util/check.h>
22#include <util/fs.h>
24#include <util/string.h>
25#include <util/vector.h>
26
27#include <functional>
28#include <type_traits>
29#include <vector>
30
31class arith_uint256;
32class CFeeRate;
33class Chainstate;
35class uint160;
36class uint256;
37
39extern const std::function<void(const std::string&)> G_TEST_LOG_FUN;
40
42extern const std::function<std::vector<const char*>()> G_TEST_COMMAND_LINE_ARGUMENTS;
43
45extern const std::function<std::string()> G_TEST_GET_FULL_NAME;
46
47static constexpr CAmount CENT{1000000};
48
50void SetupCommonTestArgs(ArgsManager& argsman);
51
52struct TestOpts {
53 std::vector<const char*> extra_args{};
56 bool setup_net{true};
58 bool min_validation_cache{false}; // Equivalent of -maxsigcachebytes=0
59};
60
66 node::NodeContext m_node; // keep as first member to be destructed last
67
71 {
74 }
75
76 explicit BasicTestingSetup(const ChainType chainType = ChainType::MAIN, TestOpts = {});
78
100};
101
110 std::function<void()> m_make_chainman{};
111
112 explicit ChainTestingSetup(const ChainType chainType = ChainType::MAIN, TestOpts = {});
114
115 // Supplies a chainstate, if one is needed
117};
118
122 explicit TestingSetup(
123 const ChainType chainType = ChainType::MAIN,
124 TestOpts = {});
125};
126
131};
132
133class CBlock;
135class CScript;
136
142 const ChainType chain_type = ChainType::REGTEST,
143 TestOpts = {});
144
150 CBlock CreateAndProcessBlock(const std::vector<CMutableTransaction>& txns,
151 const CScript& scriptPubKey,
152 Chainstate* chainstate = nullptr);
153
159 const std::vector<CMutableTransaction>& txns,
160 const CScript& scriptPubKey,
161 Chainstate& chainstate);
162
164 void mineBlocks(int num_blocks);
165
179 std::pair<CMutableTransaction, CAmount> CreateValidTransaction(const std::vector<CTransactionRef>& input_transactions,
180 const std::vector<COutPoint>& inputs,
181 int input_height,
182 const std::vector<CKey>& input_signing_keys,
183 const std::vector<CTxOut>& outputs,
184 const std::optional<CFeeRate>& feerate,
185 const std::optional<uint32_t>& fee_output);
196 CMutableTransaction CreateValidMempoolTransaction(const std::vector<CTransactionRef>& input_transactions,
197 const std::vector<COutPoint>& inputs,
198 int input_height,
199 const std::vector<CKey>& input_signing_keys,
200 const std::vector<CTxOut>& outputs,
201 bool submit = true);
202
215 uint32_t input_vout,
216 int input_height,
217 CKey input_signing_key,
218 CScript output_destination,
219 CAmount output_amount = CAmount(1 * COIN),
220 bool submit = true);
221
233 std::vector<CTransactionRef> PopulateMempool(FastRandomContext& det_rand, size_t num_transactions, bool submit);
234
244 void MockMempoolMinFee(const CFeeRate& target_feerate);
245
246 std::vector<CTransactionRef> m_coinbase_txns; // For convenience, coinbase transactions
247 CKey coinbaseKey; // private/public key needed to spend coinbase transactions
248};
249
254template <class T = const BasicTestingSetup>
255std::unique_ptr<T> MakeNoLogFileContext(const ChainType chain_type = ChainType::REGTEST, TestOpts opts = {})
256{
257 opts.extra_args = Cat(
258 {
259 "-nodebuglogfile",
260 "-nodebug",
261 },
262 opts.extra_args);
263
264 return std::make_unique<T>(chain_type, opts);
265}
266
268
269// Make types usable in BOOST_CHECK_* @{
270namespace std {
271template <typename T> requires std::is_enum_v<T>
272inline std::ostream& operator<<(std::ostream& os, const T& e)
273{
274 return os << static_cast<std::underlying_type_t<T>>(e);
275}
276
277template <typename T>
278inline std::ostream& operator<<(std::ostream& os, const std::optional<T>& v)
279{
280 return v ? os << *v
281 : os << "std::nullopt";
282}
283} // namespace std
284
285std::ostream& operator<<(std::ostream& os, const arith_uint256& num);
286std::ostream& operator<<(std::ostream& os, const uint160& num);
287std::ostream& operator<<(std::ostream& os, const uint256& num);
288// @}
289
296{
297public:
298 explicit HasReason(std::string_view reason) : m_reason(reason) {}
299 bool operator()(std::string_view s) const { return s.find(m_reason) != std::string_view::npos; }
300 bool operator()(const std::exception& e) const { return (*this)(e.what()); }
301
302private:
303 const std::string m_reason;
304};
305
306#endif // BITCOIN_TEST_UTIL_SETUP_COMMON_H
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
static constexpr CAmount COIN
The amount of satoshis in one BTC.
Definition: amount.h:15
ChainType
Definition: chaintype.h:11
Definition: block.h:69
Fee rate in satoshis per kilovirtualbyte: CAmount / kvB.
Definition: feerate.h:33
An encapsulated private key.
Definition: key.h:35
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:415
Chainstate stores and provides an API to update our local knowledge of the current best chain.
Definition: validation.h:505
Fast randomness source.
Definition: random.h:377
void Reseed(const uint256 &seed) noexcept
Reseed with explicit seed (only for testing).
Definition: random.cpp:709
BOOST_CHECK_EXCEPTION predicates to check the specific validation error.
Definition: setup_common.h:296
bool operator()(std::string_view s) const
Definition: setup_common.h:299
const std::string m_reason
Definition: setup_common.h:303
bool operator()(const std::exception &e) const
Definition: setup_common.h:300
HasReason(std::string_view reason)
Definition: setup_common.h:298
256-bit unsigned big integer.
Path class wrapper to block calls to the fs::path(std::string) implicit constructor and the fs::path:...
Definition: fs.h:33
160-bit opaque blob.
Definition: uint256.h:189
256-bit opaque blob.
Definition: uint256.h:201
Helper class that manages an interrupt flag, and allows a thread or signal to interrupt another threa...
CacheSizes CalculateCacheSizes(const ArgsManager &args, size_t n_indexes)
Definition: caches.cpp:24
std::ostream & operator<<(std::ostream &os, const T &e)
Definition: setup_common.h:272
std::shared_ptr< const CTransaction > CTransactionRef
Definition: transaction.h:423
uint256 GetRandHash() noexcept
Generate a random uint256.
Definition: random.h:454
static constexpr CAmount CENT
Definition: setup_common.h:47
const std::function< void(const std::string &)> G_TEST_LOG_FUN
This is connected to the logger.
Definition: bench.cpp:28
void SetupCommonTestArgs(ArgsManager &argsman)
Register common test args.
const std::function< std::vector< const char * >()> G_TEST_COMMAND_LINE_ARGUMENTS
Retrieve the command line arguments.
Definition: bench.cpp:36
CBlock getBlock13b8a()
std::unique_ptr< T > MakeNoLogFileContext(const ChainType chain_type=ChainType::REGTEST, TestOpts opts={})
Make a test setup that has disk access to the debug.log file disabled.
Definition: setup_common.h:255
std::ostream & operator<<(std::ostream &os, const arith_uint256 &num)
const std::function< std::string()> G_TEST_GET_FULL_NAME
Retrieve the unit test name.
Definition: bench.cpp:47
Basic testing setup.
Definition: setup_common.h:64
fs::path m_path_lock
Definition: setup_common.h:80
ArgsManager m_args
Test-specific arguments and settings.
Definition: setup_common.h:99
BasicTestingSetup(const ChainType chainType=ChainType::MAIN, TestOpts={})
void SeedRandomForTest(SeedRand seed)
Seed the global RNG state and m_rng for testing and log the seed value.
Definition: setup_common.h:70
FastRandomContext m_rng
Definition: setup_common.h:68
util::SignalInterrupt m_interrupt
Definition: setup_common.h:65
fs::path m_path_root
Definition: setup_common.h:79
node::NodeContext m_node
Definition: setup_common.h:66
A mutable version of CTransaction.
Definition: transaction.h:378
Testing setup that performs all steps up until right before ChainstateManager gets initialized.
Definition: setup_common.h:106
kernel::CacheSizes m_kernel_cache_sizes
Definition: setup_common.h:107
bool m_block_tree_db_in_memory
Definition: setup_common.h:109
ChainTestingSetup(const ChainType chainType=ChainType::MAIN, TestOpts={})
std::function< void()> m_make_chainman
Definition: setup_common.h:110
void LoadVerifyActivateChainstate()
Identical to TestingSetup, but chain set to regtest.
Definition: setup_common.h:128
Testing fixture that pre-creates a 100-block REGTEST-mode block chain.
Definition: setup_common.h:140
void mineBlocks(int num_blocks)
Mine a series of new blocks on the active chain.
std::vector< CTransactionRef > m_coinbase_txns
Definition: setup_common.h:246
CMutableTransaction CreateValidMempoolTransaction(const std::vector< CTransactionRef > &input_transactions, const std::vector< COutPoint > &inputs, int input_height, const std::vector< CKey > &input_signing_keys, const std::vector< CTxOut > &outputs, bool submit=true)
Create a transaction and, optionally, submit to the mempool.
std::pair< CMutableTransaction, CAmount > CreateValidTransaction(const std::vector< CTransactionRef > &input_transactions, const std::vector< COutPoint > &inputs, int input_height, const std::vector< CKey > &input_signing_keys, const std::vector< CTxOut > &outputs, const std::optional< CFeeRate > &feerate, const std::optional< uint32_t > &fee_output)
Create a transaction, optionally setting the fee based on the feerate.
std::vector< CTransactionRef > PopulateMempool(FastRandomContext &det_rand, size_t num_transactions, bool submit)
Create transactions spending from m_coinbase_txns.
void MockMempoolMinFee(const CFeeRate &target_feerate)
Mock the mempool minimum feerate by adding a transaction and calling TrimToSize(0),...
CBlock CreateAndProcessBlock(const std::vector< CMutableTransaction > &txns, const CScript &scriptPubKey, Chainstate *chainstate=nullptr)
Create a new block with just given transactions, coinbase paying to scriptPubKey, and try to add it t...
TestChain100Setup(const ChainType chain_type=ChainType::REGTEST, TestOpts={})
CBlock CreateBlock(const std::vector< CMutableTransaction > &txns, const CScript &scriptPubKey, Chainstate &chainstate)
Create a new block with just given transactions, coinbase paying to scriptPubKey.
bool coins_db_in_memory
Definition: setup_common.h:54
bool min_validation_cache
Definition: setup_common.h:58
bool block_tree_db_in_memory
Definition: setup_common.h:55
std::vector< const char * > extra_args
Definition: setup_common.h:53
bool setup_validation_interface
Definition: setup_common.h:57
bool setup_net
Definition: setup_common.h:56
Testing setup that configures a complete environment.
Definition: setup_common.h:121
TestingSetup(const ChainType chainType=ChainType::MAIN, TestOpts={})
kernel::CacheSizes kernel
Definition: caches.h:27
NodeContext struct containing references to chain state and connection state.
Definition: context.h:56
void SeedRandomStateForTest(SeedRand seedtype)
Seed the global RNG state for testing and log the seed value.
Definition: random.cpp:19
SeedRand
Definition: random.h:15
V Cat(V v1, V &&v2)
Concatenate two vectors, moving elements.
Definition: vector.h:34