blockchain_tests.cpp raw
1 // Copyright (c) 2017-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 #include <chain.h>
6 #include <node/blockstorage.h>
7 #include <rpc/blockchain.h>
8 #include <sync.h>
9 #include <test/util/setup_common.h>
10 #include <util/string.h>
11
12 #include <boost/test/unit_test.hpp>
13
14 #include <cstdlib>
15
16 using util::ToString;
17
18 /* Equality between doubles is imprecise. Comparison should be done
19 * with a small threshold of tolerance, rather than exact equality.
20 */
21 static bool DoubleEquals(double a, double b, double epsilon)
22 {
23 return std::abs(a - b) < epsilon;
24 }
25
26 static CBlockIndex* CreateBlockIndexWithNbits(uint32_t nbits)
27 {
28 CBlockIndex* block_index = new CBlockIndex();
29 block_index->nHeight = 46367;
30 block_index->nTime = 1269211443;
31 block_index->nBits = nbits;
32 return block_index;
33 }
34
35 static void RejectDifficultyMismatch(double difficulty, double expected_difficulty) {
36 BOOST_CHECK_MESSAGE(
37 DoubleEquals(difficulty, expected_difficulty, 0.00001),
38 "Difficulty was " + ToString(difficulty)
39 + " but was expected to be " + ToString(expected_difficulty));
40 }
41
42 /* Given a BlockIndex with the provided nbits,
43 * verify that the expected difficulty results.
44 */
45 static void TestDifficulty(uint32_t nbits, double expected_difficulty)
46 {
47 CBlockIndex* block_index = CreateBlockIndexWithNbits(nbits);
48 double difficulty = GetDifficulty(*block_index);
49 delete block_index;
50
51 RejectDifficultyMismatch(difficulty, expected_difficulty);
52 }
53
54 BOOST_FIXTURE_TEST_SUITE(blockchain_tests, BasicTestingSetup)
55
56 BOOST_AUTO_TEST_CASE(get_difficulty_for_very_low_target)
57 {
58 TestDifficulty(0x1f111111, 0.000001);
59 }
60
61 BOOST_AUTO_TEST_CASE(get_difficulty_for_low_target)
62 {
63 TestDifficulty(0x1ef88f6f, 0.000016);
64 }
65
66 BOOST_AUTO_TEST_CASE(get_difficulty_for_mid_target)
67 {
68 TestDifficulty(0x1df88f6f, 0.004023);
69 }
70
71 BOOST_AUTO_TEST_CASE(get_difficulty_for_high_target)
72 {
73 TestDifficulty(0x1cf88f6f, 1.029916);
74 }
75
76 BOOST_AUTO_TEST_CASE(get_difficulty_for_very_high_target)
77 {
78 TestDifficulty(0x12345678, 5913134931067755359633408.0);
79 }
80
81 //! Prune chain from height down to genesis block and check that
82 //! GetPruneHeight returns the correct value
83 static void CheckGetPruneHeight(const node::BlockManager& blockman, const CChain& chain, int height) EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
84 {
85 AssertLockHeld(::cs_main);
86
87 // Emulate pruning all blocks from `height` down to the genesis block
88 // by unsetting the `BLOCK_HAVE_DATA` flag from `nStatus`
89 for (CBlockIndex* it{chain[height]}; it != nullptr && it->nHeight > 0; it = it->pprev) {
90 it->nStatus &= ~BLOCK_HAVE_DATA;
91 }
92
93 const auto prune_height{GetPruneHeight(blockman, chain)};
94 BOOST_REQUIRE(prune_height.has_value());
95 BOOST_CHECK_EQUAL(*prune_height, height);
96 }
97
98 BOOST_FIXTURE_TEST_CASE(get_prune_height, TestChain100Setup)
99 {
100 LOCK(::cs_main);
101 const auto& chain = m_node.chainman->ActiveChain();
102 const auto& blockman = m_node.chainman->m_blockman;
103
104 // Fresh chain of 100 blocks without any pruned blocks, so std::nullopt should be returned
105 BOOST_CHECK(!GetPruneHeight(blockman, chain).has_value());
106
107 // Start pruning
108 CheckGetPruneHeight(blockman, chain, 1);
109 CheckGetPruneHeight(blockman, chain, 99);
110 CheckGetPruneHeight(blockman, chain, 100);
111 }
112
113 BOOST_AUTO_TEST_CASE(num_chain_tx_max)
114 {
115 CBlockIndex block_index{};
116 block_index.m_chain_tx_count = std::numeric_limits<uint64_t>::max();
117 BOOST_CHECK_EQUAL(block_index.m_chain_tx_count, std::numeric_limits<uint64_t>::max());
118 }
119
120 BOOST_FIXTURE_TEST_CASE(invalidate_block, TestChain100Setup)
121 {
122 const CChain& active{*WITH_LOCK(Assert(m_node.chainman)->GetMutex(), return &Assert(m_node.chainman)->ActiveChain())};
123
124 // Check BlockStatus when doing InvalidateBlock()
125 BlockValidationState state;
126 auto* orig_tip = active.Tip();
127 int height_to_invalidate = orig_tip->nHeight - 10;
128 auto* tip_to_invalidate = active[height_to_invalidate];
129 m_node.chainman->ActiveChainstate().InvalidateBlock(state, tip_to_invalidate);
130
131 // tip_to_invalidate just got invalidated, so it's BLOCK_FAILED_VALID
132 WITH_LOCK(::cs_main, assert(tip_to_invalidate->nStatus & BLOCK_FAILED_VALID));
133
134 // check all ancestors of the invalidated block are validated up to BLOCK_VALID_TRANSACTIONS and are not invalid
135 auto pindex = tip_to_invalidate->pprev;
136 while (pindex) {
137 WITH_LOCK(::cs_main, assert(pindex->IsValid(BLOCK_VALID_TRANSACTIONS)));
138 WITH_LOCK(::cs_main, assert((pindex->nStatus & BLOCK_FAILED_VALID) == 0));
139 pindex = pindex->pprev;
140 }
141
142 // check all descendants of the invalidated block are BLOCK_FAILED_VALID
143 pindex = orig_tip;
144 while (pindex && pindex != tip_to_invalidate) {
145 WITH_LOCK(::cs_main, assert(pindex->nStatus & BLOCK_FAILED_VALID));
146 pindex = pindex->pprev;
147 }
148 }
149
150 BOOST_AUTO_TEST_SUITE_END()
151