mirror of
https://github.com/bitcoin/bitcoin.git
synced 2025-03-17 21:32:00 +01:00
Merge 9a3397456d169fd7e7a9f13ad6b752586829b5d9 into 5f4422d68dc3530c353af1f87499de1c864b60ad
This commit is contained in:
l0rinc
GitHub
commit
45c0ca8962
@ -25,7 +25,7 @@
|
||||
// a block off the wire, but before we can relay the block on to peers using
|
||||
// compact block relay.
|
||||
|
||||
static void DeserializeBlockTest(benchmark::Bench& bench)
|
||||
static void DeserializeBlockBench(benchmark::Bench& bench)
|
||||
{
|
||||
DataStream stream(benchmark::data::block413567);
|
||||
std::byte a{0};
|
||||
@ -39,26 +39,18 @@ static void DeserializeBlockTest(benchmark::Bench& bench)
|
||||
});
|
||||
}
|
||||
|
||||
static void DeserializeAndCheckBlockTest(benchmark::Bench& bench)
|
||||
static void CheckBlockBench(benchmark::Bench& bench)
|
||||
{
|
||||
DataStream stream(benchmark::data::block413567);
|
||||
std::byte a{0};
|
||||
stream.write({&a, 1}); // Prevent compaction
|
||||
|
||||
ArgsManager bench_args;
|
||||
const auto chainParams = CreateChainParams(bench_args, ChainType::MAIN);
|
||||
|
||||
CBlock block;
|
||||
DataStream(benchmark::data::block413567) >> TX_WITH_WITNESS(block);
|
||||
const auto chainParams = CreateChainParams(ArgsManager{}, ChainType::MAIN);
|
||||
bench.unit("block").run([&] {
|
||||
CBlock block; // Note that CBlock caches its checked state, so we need to recreate it here
|
||||
stream >> TX_WITH_WITNESS(block);
|
||||
bool rewound = stream.Rewind(benchmark::data::block413567.size());
|
||||
assert(rewound);
|
||||
|
||||
block.fChecked = block.m_checked_witness_commitment = block.m_checked_merkle_root = false; // Reset the cached state
|
||||
BlockValidationState validationState;
|
||||
bool checked = CheckBlock(block, validationState, chainParams->GetConsensus());
|
||||
assert(checked);
|
||||
bool checked = CheckBlock(block, validationState, chainParams->GetConsensus(), /*fCheckPOW=*/true, /*fCheckMerkleRoot=*/true);
|
||||
assert(checked && validationState.IsValid());
|
||||
});
|
||||
}
|
||||
|
||||
BENCHMARK(DeserializeBlockTest, benchmark::PriorityLevel::HIGH);
|
||||
BENCHMARK(DeserializeAndCheckBlockTest, benchmark::PriorityLevel::HIGH);
|
||||
BENCHMARK(DeserializeBlockBench, benchmark::PriorityLevel::HIGH);
|
||||
BENCHMARK(CheckBlockBench, benchmark::PriorityLevel::HIGH);
|
||||
|
||||
@ -13,10 +13,19 @@
|
||||
#include <test/util/txmempool.h>
|
||||
#include <txmempool.h>
|
||||
#include <validation.h>
|
||||
#include <bench/data/block413567.raw.h>
|
||||
#include <node/context.h>
|
||||
#include <node/miner.h>
|
||||
#include <primitives/block.h>
|
||||
#include <test/util/script.h>
|
||||
#include <util/check.h>
|
||||
|
||||
#include <array>
|
||||
#include <cassert>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <memory>
|
||||
#include <streams.h>
|
||||
#include <vector>
|
||||
|
||||
class CCoinsViewCache;
|
||||
@ -126,5 +135,53 @@ static void MempoolCheck(benchmark::Bench& bench)
|
||||
});
|
||||
}
|
||||
|
||||
static void ProcessTransactionBench(benchmark::Bench& bench)
|
||||
{
|
||||
const auto testing_setup{MakeNoLogFileContext<const TestingSetup>()};
|
||||
CTxMemPool& pool{*Assert(testing_setup->m_node.mempool)};
|
||||
ChainstateManager& chainman{*testing_setup->m_node.chainman};
|
||||
|
||||
CBlock block;
|
||||
DataStream(benchmark::data::block413567) >> TX_WITH_WITNESS(block);
|
||||
|
||||
std::vector<CTransactionRef> txs(block.vtx.size() - 1);
|
||||
for (size_t i{1}; i < block.vtx.size(); ++i) {
|
||||
CMutableTransaction mtx{*block.vtx[i]};
|
||||
for (auto& txin : mtx.vin) {
|
||||
txin.nSequence = CTxIn::SEQUENCE_FINAL;
|
||||
txin.scriptSig.clear();
|
||||
txin.scriptWitness.stack = {WITNESS_STACK_ELEM_OP_TRUE};
|
||||
}
|
||||
txs[i - 1] = MakeTransactionRef(std::move(mtx));
|
||||
}
|
||||
|
||||
CCoinsViewCache* coins_tip{nullptr};
|
||||
size_t cached_coin_count{0};
|
||||
{
|
||||
LOCK(cs_main);
|
||||
coins_tip = &chainman.ActiveChainstate().CoinsTip();
|
||||
for (const auto& tx : txs) {
|
||||
const Coin coin(CTxOut(2 * tx->GetValueOut(), P2WSH_OP_TRUE), 1, /*fCoinBaseIn=*/false);
|
||||
for (const auto& in : tx->vin) {
|
||||
coins_tip->AddCoin(in.prevout, Coin{coin}, /*possible_overwrite=*/false);
|
||||
cached_coin_count++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bench.batch(txs.size()).run([&] {
|
||||
LOCK2(cs_main, pool.cs);
|
||||
assert(coins_tip->GetCacheSize() == cached_coin_count);
|
||||
for (const auto& tx : txs) pool.removeRecursive(*tx, MemPoolRemovalReason::REPLACED);
|
||||
assert(pool.size() == 0);
|
||||
|
||||
for (const auto& tx : txs) {
|
||||
const auto res{chainman.ProcessTransaction(tx, /*test_accept=*/true)};
|
||||
assert(res.m_result_type == MempoolAcceptResult::ResultType::VALID);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
BENCHMARK(ComplexMemPool, benchmark::PriorityLevel::HIGH);
|
||||
BENCHMARK(MempoolCheck, benchmark::PriorityLevel::HIGH);
|
||||
BENCHMARK(ProcessTransactionBench, benchmark::PriorityLevel::HIGH);
|
||||
|
||||
@ -38,23 +38,37 @@ bool CheckTransaction(const CTransaction& tx, TxValidationState& state)
|
||||
// of a tx as spent, it does not check if the tx has duplicate inputs.
|
||||
// Failure to run this check will result in either a crash or an inflation bug, depending on the implementation of
|
||||
// the underlying coins database.
|
||||
std::set<COutPoint> vInOutPoints;
|
||||
if (tx.vin.size() == 1) {
|
||||
if (tx.IsCoinBase()) {
|
||||
if (tx.vin[0].scriptSig.size() < 2 || tx.vin[0].scriptSig.size() > 100) {
|
||||
return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-cb-length");
|
||||
}
|
||||
}
|
||||
} else if (tx.vin.size() == 2) {
|
||||
if (tx.vin[0].prevout == tx.vin[1].prevout) {
|
||||
return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-inputs-duplicate");
|
||||
}
|
||||
if (tx.vin[0].prevout.IsNull() || tx.vin[1].prevout.IsNull()) {
|
||||
return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-prevout-null");
|
||||
}
|
||||
} else {
|
||||
std::vector<COutPoint> sortedPrevouts;
|
||||
sortedPrevouts.reserve(tx.vin.size());
|
||||
for (const auto& txin : tx.vin) {
|
||||
if (!vInOutPoints.insert(txin.prevout).second)
|
||||
sortedPrevouts.push_back(txin.prevout);
|
||||
}
|
||||
std::sort(sortedPrevouts.begin(), sortedPrevouts.end());
|
||||
if (std::ranges::adjacent_find(sortedPrevouts) != sortedPrevouts.end()) {
|
||||
return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-inputs-duplicate");
|
||||
}
|
||||
|
||||
if (tx.IsCoinBase())
|
||||
{
|
||||
if (tx.vin[0].scriptSig.size() < 2 || tx.vin[0].scriptSig.size() > 100)
|
||||
return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-cb-length");
|
||||
}
|
||||
else
|
||||
{
|
||||
for (const auto& txin : tx.vin)
|
||||
if (txin.prevout.IsNull())
|
||||
for (const auto& in : sortedPrevouts) {
|
||||
if (!in.hash.IsNull()) break; // invalid values can only be at the beginning
|
||||
if (in.IsNull()) {
|
||||
return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-prevout-null");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -406,20 +406,110 @@ BOOST_AUTO_TEST_CASE(tx_oversized)
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(basic_transaction_tests)
|
||||
static CMutableTransaction CreateTransaction()
|
||||
{
|
||||
// Random real transaction (e2769b09e784f32f62ef849763d4f45b98e07ba658647343b915ff832b110436)
|
||||
unsigned char ch[] = {0x01, 0x00, 0x00, 0x00, 0x01, 0x6b, 0xff, 0x7f, 0xcd, 0x4f, 0x85, 0x65, 0xef, 0x40, 0x6d, 0xd5, 0xd6, 0x3d, 0x4f, 0xf9, 0x4f, 0x31, 0x8f, 0xe8, 0x20, 0x27, 0xfd, 0x4d, 0xc4, 0x51, 0xb0, 0x44, 0x74, 0x01, 0x9f, 0x74, 0xb4, 0x00, 0x00, 0x00, 0x00, 0x8c, 0x49, 0x30, 0x46, 0x02, 0x21, 0x00, 0xda, 0x0d, 0xc6, 0xae, 0xce, 0xfe, 0x1e, 0x06, 0xef, 0xdf, 0x05, 0x77, 0x37, 0x57, 0xde, 0xb1, 0x68, 0x82, 0x09, 0x30, 0xe3, 0xb0, 0xd0, 0x3f, 0x46, 0xf5, 0xfc, 0xf1, 0x50, 0xbf, 0x99, 0x0c, 0x02, 0x21, 0x00, 0xd2, 0x5b, 0x5c, 0x87, 0x04, 0x00, 0x76, 0xe4, 0xf2, 0x53, 0xf8, 0x26, 0x2e, 0x76, 0x3e, 0x2d, 0xd5, 0x1e, 0x7f, 0xf0, 0xbe, 0x15, 0x77, 0x27, 0xc4, 0xbc, 0x42, 0x80, 0x7f, 0x17, 0xbd, 0x39, 0x01, 0x41, 0x04, 0xe6, 0xc2, 0x6e, 0xf6, 0x7d, 0xc6, 0x10, 0xd2, 0xcd, 0x19, 0x24, 0x84, 0x78, 0x9a, 0x6c, 0xf9, 0xae, 0xa9, 0x93, 0x0b, 0x94, 0x4b, 0x7e, 0x2d, 0xb5, 0x34, 0x2b, 0x9d, 0x9e, 0x5b, 0x9f, 0xf7, 0x9a, 0xff, 0x9a, 0x2e, 0xe1, 0x97, 0x8d, 0xd7, 0xfd, 0x01, 0xdf, 0xc5, 0x22, 0xee, 0x02, 0x28, 0x3d, 0x3b, 0x06, 0xa9, 0xd0, 0x3a, 0xcf, 0x80, 0x96, 0x96, 0x8d, 0x7d, 0xbb, 0x0f, 0x91, 0x78, 0xff, 0xff, 0xff, 0xff, 0x02, 0x8b, 0xa7, 0x94, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x19, 0x76, 0xa9, 0x14, 0xba, 0xde, 0xec, 0xfd, 0xef, 0x05, 0x07, 0x24, 0x7f, 0xc8, 0xf7, 0x42, 0x41, 0xd7, 0x3b, 0xc0, 0x39, 0x97, 0x2d, 0x7b, 0x88, 0xac, 0x40, 0x94, 0xa8, 0x02, 0x00, 0x00, 0x00, 0x00, 0x19, 0x76, 0xa9, 0x14, 0xc1, 0x09, 0x32, 0x48, 0x3f, 0xec, 0x93, 0xed, 0x51, 0xf5, 0xfe, 0x95, 0xe7, 0x25, 0x59, 0xf2, 0xcc, 0x70, 0x43, 0xf9, 0x88, 0xac, 0x00, 0x00, 0x00, 0x00, 0x00};
|
||||
std::vector<unsigned char> vch(ch, ch + sizeof(ch) -1);
|
||||
DataStream stream(vch);
|
||||
// Serialized random real transaction (e2769b09e784f32f62ef849763d4f45b98e07ba658647343b915ff832b110436)
|
||||
static constexpr auto ser_tx{"01000000016bff7fcd4f8565ef406dd5d63d4ff94f318fe82027fd4dc451b04474019f74b4000000008c493046022100da0dc6aecefe1e06efdf05773757deb168820930e3b0d03f46f5fcf150bf990c022100d25b5c87040076e4f253f8262e763e2dd51e7ff0be157727c4bc42807f17bd39014104e6c26ef67dc610d2cd192484789a6cf9aea9930b944b7e2db5342b9d9e5b9ff79aff9a2ee1978dd7fd01dfc522ee02283d3b06a9d03acf8096968d7dbb0f9178ffffffff028ba7940e000000001976a914badeecfdef0507247fc8f74241d73bc039972d7b88ac4094a802000000001976a914c10932483fec93ed51f5fe95e72559f2cc7043f988ac0000000000"_hex};
|
||||
CMutableTransaction tx;
|
||||
stream >> TX_WITH_WITNESS(tx);
|
||||
DataStream(ser_tx) >> TX_WITH_WITNESS(tx);
|
||||
return tx;
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(transaction_duplicate_input_test)
|
||||
{
|
||||
auto tx{CreateTransaction()};
|
||||
|
||||
TxValidationState state;
|
||||
BOOST_CHECK_MESSAGE(CheckTransaction(CTransaction(tx), state) && state.IsValid(), "Simple deserialized transaction should be valid.");
|
||||
|
||||
// Check that duplicate txins fail
|
||||
tx.vin.push_back(tx.vin[0]);
|
||||
BOOST_CHECK_MESSAGE(!CheckTransaction(CTransaction(tx), state) || !state.IsValid(), "Transaction with duplicate txins should be invalid.");
|
||||
// Add duplicate input
|
||||
tx.vin.emplace_back(tx.vin[0]);
|
||||
std::ranges::shuffle(tx.vin, m_rng);
|
||||
BOOST_CHECK_MESSAGE(!CheckTransaction(CTransaction(tx), state) || !state.IsValid(), "Transaction with 2 duplicate txins should be invalid.");
|
||||
|
||||
// ... add a valid input for more complex check
|
||||
tx.vin.emplace_back(COutPoint(Txid::FromUint256(uint256{1}), 1));
|
||||
std::ranges::shuffle(tx.vin, m_rng);
|
||||
BOOST_CHECK_MESSAGE(!CheckTransaction(CTransaction(tx), state) || !state.IsValid(), "Transaction with 3 inputs (2 valid, 1 duplicate) should be invalid.");
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(transaction_duplicate_detection_test)
|
||||
{
|
||||
// Randomized testing against hash- and tree-based duplicate check
|
||||
auto reference_duplicate_check_hash{[](const std::vector<CTxIn>& vin) {
|
||||
std::unordered_set<COutPoint, SaltedOutpointHasher> vInOutPoints;
|
||||
for (const auto& txin : vin) {
|
||||
if (!vInOutPoints.insert(txin.prevout).second) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}};
|
||||
auto reference_duplicate_check_tree{[](const std::vector<CTxIn>& vin) {
|
||||
std::set<COutPoint> vInOutPoints;
|
||||
for (const auto& txin : vin) {
|
||||
if (!vInOutPoints.insert(txin.prevout).second) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}};
|
||||
|
||||
std::vector<Txid> hashes;
|
||||
std::vector<uint32_t> ns;
|
||||
for (int i = 0; i < 10; ++i) {
|
||||
hashes.emplace_back(Txid::FromUint256(m_rng.rand256()));
|
||||
ns.emplace_back(m_rng.rand32());
|
||||
}
|
||||
auto tx{CreateTransaction()};
|
||||
TxValidationState state;
|
||||
for (int i{0}; i < 100; ++i) {
|
||||
if (m_rng.randbool()) {
|
||||
tx.vin.clear();
|
||||
}
|
||||
for (int j{0}, num_inputs{1 + m_rng.randrange(5)}; j < num_inputs; ++j) {
|
||||
if (COutPoint outpoint(hashes[m_rng.randrange(hashes.size())], ns[m_rng.randrange(ns.size())]); !outpoint.IsNull()) {
|
||||
tx.vin.emplace_back(outpoint);
|
||||
}
|
||||
}
|
||||
std::ranges::shuffle(tx.vin, m_rng);
|
||||
|
||||
bool actual{CheckTransaction(CTransaction(tx), state)};
|
||||
BOOST_CHECK_EQUAL(actual, reference_duplicate_check_hash(tx.vin));
|
||||
BOOST_CHECK_EQUAL(actual, reference_duplicate_check_tree(tx.vin));
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(transaction_null_prevout_detection_test)
|
||||
{
|
||||
// Randomized testing against linear null prevout check
|
||||
auto reference_null_prevout_check_hash{[](const std::vector<CTxIn>& vin) {
|
||||
for (const auto& txin : vin) {
|
||||
if (txin.prevout.IsNull()) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}};
|
||||
|
||||
auto tx{CreateTransaction()};
|
||||
TxValidationState state;
|
||||
for (int i{0}; i < 100; ++i) {
|
||||
if (m_rng.randbool()) {
|
||||
tx.vin.clear();
|
||||
}
|
||||
for (int j{0}, num_inputs{1 + m_rng.randrange(5)}; j < num_inputs; ++j) {
|
||||
switch (m_rng.randrange(5)) {
|
||||
case 0: tx.vin.emplace_back(COutPoint()); break; // Null prevout
|
||||
case 1: tx.vin.emplace_back(Txid::FromUint256(uint256::ZERO), m_rng.rand32()); break; // Null hash, random index
|
||||
case 2: tx.vin.emplace_back(Txid::FromUint256(m_rng.rand256()), COutPoint::NULL_INDEX); break; // Random hash, Null index
|
||||
default: tx.vin.emplace_back(Txid::FromUint256(m_rng.rand256()), m_rng.rand32()); // Random prevout
|
||||
}
|
||||
}
|
||||
std::ranges::shuffle(tx.vin, m_rng);
|
||||
|
||||
BOOST_CHECK_EQUAL(CheckTransaction(CTransaction(tx), state), reference_null_prevout_check_hash(tx.vin));
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(test_Get)
|
||||
@ -1048,4 +1138,116 @@ BOOST_AUTO_TEST_CASE(test_IsStandard)
|
||||
CheckIsNotStandard(t, "dust");
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(test_uint256_sorting)
|
||||
{
|
||||
// Sorting
|
||||
std::vector original{
|
||||
uint256{1},
|
||||
uint256{2},
|
||||
uint256{3}
|
||||
};
|
||||
|
||||
std::vector shuffled{original};
|
||||
std::ranges::shuffle(shuffled, m_rng);
|
||||
std::sort(shuffled.begin(), shuffled.end());
|
||||
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(original.begin(), original.end(), shuffled.begin(), shuffled.end());
|
||||
|
||||
// Operators
|
||||
constexpr auto a{uint256{1}},
|
||||
b{uint256{2}},
|
||||
c{uint256{3}};
|
||||
|
||||
BOOST_CHECK(a == a);
|
||||
BOOST_CHECK(a == uint256{1});
|
||||
BOOST_CHECK(b == b);
|
||||
BOOST_CHECK(c == c);
|
||||
BOOST_CHECK(a != b);
|
||||
BOOST_CHECK(a != uint256{10});
|
||||
BOOST_CHECK(a != c);
|
||||
BOOST_CHECK(b != c);
|
||||
|
||||
BOOST_CHECK(a < b);
|
||||
BOOST_CHECK(a < uint256{10});
|
||||
BOOST_CHECK(b < c);
|
||||
BOOST_CHECK(a < c);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(test_transaction_identifier_sorting)
|
||||
{
|
||||
std::vector original{
|
||||
Txid::FromUint256(uint256{1}),
|
||||
Txid::FromUint256(uint256{2}),
|
||||
Txid::FromUint256(uint256{3})
|
||||
};
|
||||
|
||||
std::vector shuffled{original};
|
||||
std::ranges::shuffle(shuffled, m_rng);
|
||||
std::sort(shuffled.begin(), shuffled.end());
|
||||
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(original.begin(), original.end(), shuffled.begin(), shuffled.end());
|
||||
|
||||
// Operators
|
||||
const auto a(Txid::FromUint256(uint256{1})),
|
||||
b(Txid::FromUint256(uint256{2})),
|
||||
c(Txid::FromUint256(uint256{3}));
|
||||
|
||||
BOOST_CHECK(a == uint256{1});
|
||||
|
||||
BOOST_CHECK(a == a);
|
||||
BOOST_CHECK(a == Txid::FromUint256(uint256{1}));
|
||||
BOOST_CHECK(b == b);
|
||||
BOOST_CHECK(c == c);
|
||||
BOOST_CHECK(a != b);
|
||||
BOOST_CHECK(a != Txid::FromUint256(uint256{10}));
|
||||
BOOST_CHECK(a != c);
|
||||
BOOST_CHECK(b != c);
|
||||
|
||||
BOOST_CHECK(a < b);
|
||||
BOOST_CHECK(a < Txid::FromUint256(uint256{10}));
|
||||
BOOST_CHECK(b < c);
|
||||
BOOST_CHECK(a < c);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(test_coutpoint_sorting)
|
||||
{
|
||||
// Sorting
|
||||
std::vector original{
|
||||
COutPoint(Txid::FromUint256(uint256{1}), 1),
|
||||
COutPoint(Txid::FromUint256(uint256{1}), 2),
|
||||
COutPoint(Txid::FromUint256(uint256{1}), 3),
|
||||
COutPoint(Txid::FromUint256(uint256{2}), 1),
|
||||
COutPoint(Txid::FromUint256(uint256{2}), 2),
|
||||
COutPoint(Txid::FromUint256(uint256{2}), 3),
|
||||
COutPoint(Txid::FromUint256(uint256{3}), 1),
|
||||
COutPoint(Txid::FromUint256(uint256{3}), 2),
|
||||
COutPoint(Txid::FromUint256(uint256{3}), 3)
|
||||
};
|
||||
|
||||
std::vector shuffled{original};
|
||||
std::ranges::shuffle(shuffled, m_rng);
|
||||
std::sort(shuffled.begin(), shuffled.end());
|
||||
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(original.begin(), original.end(), shuffled.begin(), shuffled.end());
|
||||
|
||||
// Operators
|
||||
const auto a{COutPoint(Txid::FromUint256(uint256{1}), 1)},
|
||||
b{COutPoint(Txid::FromUint256(uint256{1}), 2)},
|
||||
c{COutPoint(Txid::FromUint256(uint256{2}), 1)};
|
||||
|
||||
BOOST_CHECK(a == a);
|
||||
BOOST_CHECK(a == COutPoint(Txid::FromUint256(uint256{1}), 1));
|
||||
BOOST_CHECK(b == b);
|
||||
BOOST_CHECK(c == c);
|
||||
BOOST_CHECK(a != b);
|
||||
BOOST_CHECK(a != COutPoint(Txid::FromUint256(uint256{1}), 10));
|
||||
BOOST_CHECK(a != c);
|
||||
BOOST_CHECK(b != c);
|
||||
|
||||
BOOST_CHECK(a < b);
|
||||
BOOST_CHECK(a < COutPoint(Txid::FromUint256(uint256{1}), 10));
|
||||
BOOST_CHECK(b < c);
|
||||
BOOST_CHECK(a < c);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
||||
@ -616,3 +616,8 @@ std::ostream& operator<<(std::ostream& os, const uint256& num)
|
||||
{
|
||||
return os << num.ToString();
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream& os, const COutPoint& outpoint)
|
||||
{
|
||||
return os << outpoint.hash << ", " << outpoint.n;
|
||||
}
|
||||
|
||||
@ -291,6 +291,7 @@ inline std::ostream& operator<<(std::ostream& os, const std::optional<T>& v)
|
||||
std::ostream& operator<<(std::ostream& os, const arith_uint256& num);
|
||||
std::ostream& operator<<(std::ostream& os, const uint160& num);
|
||||
std::ostream& operator<<(std::ostream& os, const uint256& num);
|
||||
std::ostream& operator<<(std::ostream& os, const COutPoint& outpoint);
|
||||
// @}
|
||||
|
||||
/**
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user