mirror of
https://github.com/bitcoin/bitcoin.git
synced 2025-02-24 12:41:41 -05:00
bf0efb4fc7
-BEGIN VERIFY SCRIPT- sed -i 's/nChainTx/m_chain_tx_count/g' $(git grep -l 'nChainTx' ./src) sed -i 's/nTxCount/tx_count/g' $(git grep -l 'nTxCount' ./src) -END VERIFY SCRIPT-
120 lines
3.6 KiB
C++
120 lines
3.6 KiB
C++
// Copyright (c) 2017-2022 The Bitcoin Core developers
|
|
// Distributed under the MIT software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#include <boost/test/unit_test.hpp>
|
|
|
|
#include <chain.h>
|
|
#include <node/blockstorage.h>
|
|
#include <rpc/blockchain.h>
|
|
#include <sync.h>
|
|
#include <test/util/setup_common.h>
|
|
#include <util/string.h>
|
|
|
|
#include <cstdlib>
|
|
|
|
using util::ToString;
|
|
|
|
/* Equality between doubles is imprecise. Comparison should be done
|
|
* with a small threshold of tolerance, rather than exact equality.
|
|
*/
|
|
static bool DoubleEquals(double a, double b, double epsilon)
|
|
{
|
|
return std::abs(a - b) < epsilon;
|
|
}
|
|
|
|
static CBlockIndex* CreateBlockIndexWithNbits(uint32_t nbits)
|
|
{
|
|
CBlockIndex* block_index = new CBlockIndex();
|
|
block_index->nHeight = 46367;
|
|
block_index->nTime = 1269211443;
|
|
block_index->nBits = nbits;
|
|
return block_index;
|
|
}
|
|
|
|
static void RejectDifficultyMismatch(double difficulty, double expected_difficulty) {
|
|
BOOST_CHECK_MESSAGE(
|
|
DoubleEquals(difficulty, expected_difficulty, 0.00001),
|
|
"Difficulty was " + ToString(difficulty)
|
|
+ " but was expected to be " + ToString(expected_difficulty));
|
|
}
|
|
|
|
/* Given a BlockIndex with the provided nbits,
|
|
* verify that the expected difficulty results.
|
|
*/
|
|
static void TestDifficulty(uint32_t nbits, double expected_difficulty)
|
|
{
|
|
CBlockIndex* block_index = CreateBlockIndexWithNbits(nbits);
|
|
double difficulty = GetDifficulty(*block_index);
|
|
delete block_index;
|
|
|
|
RejectDifficultyMismatch(difficulty, expected_difficulty);
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_SUITE(blockchain_tests, BasicTestingSetup)
|
|
|
|
BOOST_AUTO_TEST_CASE(get_difficulty_for_very_low_target)
|
|
{
|
|
TestDifficulty(0x1f111111, 0.000001);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(get_difficulty_for_low_target)
|
|
{
|
|
TestDifficulty(0x1ef88f6f, 0.000016);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(get_difficulty_for_mid_target)
|
|
{
|
|
TestDifficulty(0x1df88f6f, 0.004023);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(get_difficulty_for_high_target)
|
|
{
|
|
TestDifficulty(0x1cf88f6f, 1.029916);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(get_difficulty_for_very_high_target)
|
|
{
|
|
TestDifficulty(0x12345678, 5913134931067755359633408.0);
|
|
}
|
|
|
|
//! Prune chain from height down to genesis block and check that
|
|
//! GetPruneHeight returns the correct value
|
|
static void CheckGetPruneHeight(node::BlockManager& blockman, CChain& chain, int height) EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
|
|
{
|
|
AssertLockHeld(::cs_main);
|
|
|
|
// Emulate pruning all blocks from `height` down to the genesis block
|
|
// by unsetting the `BLOCK_HAVE_DATA` flag from `nStatus`
|
|
for (CBlockIndex* it{chain[height]}; it != nullptr && it->nHeight > 0; it = it->pprev) {
|
|
it->nStatus &= ~BLOCK_HAVE_DATA;
|
|
}
|
|
|
|
const auto prune_height{GetPruneHeight(blockman, chain)};
|
|
BOOST_REQUIRE(prune_height.has_value());
|
|
BOOST_CHECK_EQUAL(*prune_height, height);
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE(get_prune_height, TestChain100Setup)
|
|
{
|
|
LOCK(::cs_main);
|
|
auto& chain = m_node.chainman->ActiveChain();
|
|
auto& blockman = m_node.chainman->m_blockman;
|
|
|
|
// Fresh chain of 100 blocks without any pruned blocks, so std::nullopt should be returned
|
|
BOOST_CHECK(!GetPruneHeight(blockman, chain).has_value());
|
|
|
|
// Start pruning
|
|
CheckGetPruneHeight(blockman, chain, 1);
|
|
CheckGetPruneHeight(blockman, chain, 99);
|
|
CheckGetPruneHeight(blockman, chain, 100);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(num_chain_tx_max)
|
|
{
|
|
CBlockIndex block_index{};
|
|
block_index.m_chain_tx_count = std::numeric_limits<uint64_t>::max();
|
|
BOOST_CHECK_EQUAL(block_index.m_chain_tx_count, std::numeric_limits<uint64_t>::max());
|
|
}
|
|
|
|
BOOST_AUTO_TEST_SUITE_END()
|