Branch data Line data Source code
1 : : // Copyright (c) 2014-2022 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 <addresstype.h>
6 : : #include <clientversion.h>
7 : : #include <coins.h>
8 : : #include <streams.h>
9 : : #include <test/util/poolresourcetester.h>
10 : : #include <test/util/random.h>
11 : : #include <test/util/setup_common.h>
12 : : #include <txdb.h>
13 : : #include <uint256.h>
14 : : #include <undo.h>
15 : : #include <util/strencodings.h>
16 : :
17 : : #include <map>
18 : : #include <vector>
19 : :
20 : : #include <boost/test/unit_test.hpp>
21 : :
22 : : using namespace util::hex_literals;
23 : :
24 : : int ApplyTxInUndo(Coin&& undo, CCoinsViewCache& view, const COutPoint& out);
25 : : void UpdateCoins(const CTransaction& tx, CCoinsViewCache& inputs, CTxUndo &txundo, int nHeight);
26 : :
27 : : namespace
28 : : {
29 : : //! equality test
30 : 1112768 : bool operator==(const Coin &a, const Coin &b) {
31 : : // Empty Coin objects are always equal.
32 [ + + - + ]: 1112768 : if (a.IsSpent() && b.IsSpent()) return true;
33 : 653288 : return a.fCoinBase == b.fCoinBase &&
34 [ + - + - : 653288 : a.nHeight == b.nHeight &&
- + ]
35 : 326644 : a.out == b.out;
36 : : }
37 : :
38 : 2 : class CCoinsViewTest : public CCoinsView
39 : : {
40 : : FastRandomContext& m_rng;
41 : : uint256 hashBestBlock_;
42 : : std::map<COutPoint, Coin> map_;
43 : :
44 : : public:
45 : 2 : CCoinsViewTest(FastRandomContext& rng) : m_rng{rng} {}
46 : :
47 : 6206179 : std::optional<Coin> GetCoin(const COutPoint& outpoint) const override
48 : : {
49 [ + + ]: 6206179 : if (auto it{map_.find(outpoint)}; it != map_.end()) {
50 [ + + + + ]: 471160 : if (!it->second.IsSpent() || m_rng.randbool()) {
51 : 300417 : return it->second; // TODO spent coins shouldn't be returned
52 : : }
53 : : }
54 : 5905762 : return std::nullopt;
55 : : }
56 : :
57 : 0 : uint256 GetBestBlock() const override { return hashBestBlock_; }
58 : :
59 : 290 : bool BatchWrite(CoinsViewCacheCursor& cursor, const uint256& hashBlock) override
60 : : {
61 [ + + ]: 240722 : for (auto it{cursor.Begin()}; it != cursor.End(); it = cursor.NextAndMaybeErase(*it)){
62 [ + + ]: 240432 : if (it->second.IsDirty()) {
63 : : // Same optimization used in CCoinsViewDB is to only write dirty entries.
64 : 85681 : map_[it->first] = it->second.coin;
65 [ + + + + ]: 85681 : if (it->second.coin.IsSpent() && m_rng.randrange(3) == 0) {
66 : : // Randomly delete empty entries on write.
67 : 12774 : map_.erase(it->first);
68 : : }
69 : : }
70 : : }
71 [ - + ]: 290 : if (!hashBlock.IsNull())
72 : 0 : hashBestBlock_ = hashBlock;
73 : 290 : return true;
74 : : }
75 : : };
76 : :
77 : 0 : class CCoinsViewCacheTest : public CCoinsViewCache
78 : : {
79 : : public:
80 [ + - + - : 812 : explicit CCoinsViewCacheTest(CCoinsView* _base) : CCoinsViewCache(_base) {}
+ - + - +
- ]
81 : :
82 : 380 : void SelfTest(bool sanity_check = true) const
83 : : {
84 : : // Manually recompute the dynamic usage of the whole data, and compare it.
85 : 380 : size_t ret = memusage::DynamicUsage(cacheCoins);
86 : 380 : size_t count = 0;
87 [ + + ]: 527489 : for (const auto& entry : cacheCoins) {
88 [ + + ]: 527109 : ret += entry.second.coin.DynamicMemoryUsage();
89 : 527109 : ++count;
90 : : }
91 [ + - ]: 380 : BOOST_CHECK_EQUAL(GetCacheSize(), count);
92 [ + - ]: 380 : BOOST_CHECK_EQUAL(DynamicMemoryUsage(), ret);
93 [ + + ]: 380 : if (sanity_check) {
94 : 271 : SanityCheck();
95 : : }
96 : 380 : }
97 : :
98 [ + - ]: 10 : CCoinsMap& map() const { return cacheCoins; }
99 : 198 : CoinsCachePair& sentinel() const { return m_sentinel; }
100 : 198 : size_t& usage() const { return cachedCoinsUsage; }
101 : : };
102 : :
103 : : } // namespace
104 : :
105 : : BOOST_FIXTURE_TEST_SUITE(coins_tests, BasicTestingSetup)
106 : :
107 : : static const unsigned int NUM_SIMULATION_ITERATIONS = 40000;
108 : :
109 : 2 : struct CacheTest : BasicTestingSetup {
110 : : // This is a large randomized insert/remove simulation test on a variable-size
111 : : // stack of caches on top of CCoinsViewTest.
112 : : //
113 : : // It will randomly create/update/delete Coin entries to a tip of caches, with
114 : : // txids picked from a limited list of random 256-bit hashes. Occasionally, a
115 : : // new tip is added to the stack of caches, or the tip is flushed and removed.
116 : : //
117 : : // During the process, booleans are kept to make sure that the randomized
118 : : // operation hits all branches.
119 : : //
120 : : // If fake_best_block is true, assign a random uint256 to mock the recording
121 : : // of best block on flush. This is necessary when using CCoinsViewDB as the base,
122 : : // otherwise we'll hit an assertion in BatchWrite.
123 : : //
124 : 2 : void SimulationTest(CCoinsView* base, bool fake_best_block)
125 : : {
126 : : // Various coverage trackers.
127 : 2 : bool removed_all_caches = false;
128 : 2 : bool reached_4_caches = false;
129 : 2 : bool added_an_entry = false;
130 : 2 : bool added_an_unspendable_entry = false;
131 : 2 : bool removed_an_entry = false;
132 : 2 : bool updated_an_entry = false;
133 : 2 : bool found_an_entry = false;
134 : 2 : bool missed_an_entry = false;
135 : 2 : bool uncached_an_entry = false;
136 : 2 : bool flushed_without_erase = false;
137 : :
138 : : // A simple map to track what we expect the cache stack to represent.
139 [ + - ]: 2 : std::map<COutPoint, Coin> result;
140 : :
141 : : // The cache stack.
142 : 2 : std::vector<std::unique_ptr<CCoinsViewCacheTest>> stack; // A stack of CCoinsViewCaches on top.
143 [ + - ]: 4 : stack.push_back(std::make_unique<CCoinsViewCacheTest>(base)); // Start with one cache.
144 : :
145 : : // Use a limited set of random transaction ids, so we do test overwriting entries.
146 : 2 : std::vector<Txid> txids;
147 [ + - ]: 2 : txids.resize(NUM_SIMULATION_ITERATIONS / 8);
148 [ + + ]: 10002 : for (unsigned int i = 0; i < txids.size(); i++) {
149 : 10000 : txids[i] = Txid::FromUint256(m_rng.rand256());
150 : : }
151 : :
152 [ + + ]: 80002 : for (unsigned int i = 0; i < NUM_SIMULATION_ITERATIONS; i++) {
153 : : // Do a random modification.
154 : 80000 : {
155 [ + - ]: 80000 : auto txid = txids[m_rng.randrange(txids.size())]; // txid we're going to modify in this iteration.
156 [ + - ]: 80000 : Coin& coin = result[COutPoint(txid, 0)];
157 : :
158 : : // Determine whether to test HaveCoin before or after Access* (or both). As these functions
159 : : // can influence each other's behaviour by pulling things into the cache, all combinations
160 : : // are tested.
161 : 80000 : bool test_havecoin_before = m_rng.randbits(2) == 0;
162 : 80000 : bool test_havecoin_after = m_rng.randbits(2) == 0;
163 : :
164 [ + + + - ]: 80000 : bool result_havecoin = test_havecoin_before ? stack.back()->HaveCoin(COutPoint(txid, 0)) : false;
165 : :
166 : : // Infrequently, test usage of AccessByTxid instead of AccessCoin - the
167 : : // former just delegates to the latter and returns the first unspent in a txn.
168 [ + + ]: 80000 : const Coin& entry = (m_rng.randrange(500) == 0) ?
169 [ + - + - ]: 80000 : AccessByTxid(*stack.back(), txid) : stack.back()->AccessCoin(COutPoint(txid, 0));
170 [ + - + - : 160000 : BOOST_CHECK(coin == entry);
+ + ]
171 : :
172 [ + + ]: 80000 : if (test_havecoin_before) {
173 [ + - + - ]: 40044 : BOOST_CHECK(result_havecoin == !entry.IsSpent());
174 : : }
175 : :
176 [ + + ]: 80000 : if (test_havecoin_after) {
177 [ + - ]: 19980 : bool ret = stack.back()->HaveCoin(COutPoint(txid, 0));
178 [ + - + - ]: 39960 : BOOST_CHECK(ret == !entry.IsSpent());
179 : : }
180 : :
181 [ + + + + ]: 80000 : if (m_rng.randrange(5) == 0 || coin.IsSpent()) {
182 : 47992 : Coin newcoin;
183 : 47992 : newcoin.out.nValue = RandMoney(m_rng);
184 : 47992 : newcoin.nHeight = 1;
185 : :
186 : : // Infrequently test adding unspendable coins.
187 [ + + + + ]: 47992 : if (m_rng.randrange(16) == 0 && coin.IsSpent()) {
188 : 2474 : newcoin.out.scriptPubKey.assign(1 + m_rng.randbits(6), OP_RETURN);
189 [ + - + - ]: 4948 : BOOST_CHECK(newcoin.out.scriptPubKey.IsUnspendable());
190 : 2474 : added_an_unspendable_entry = true;
191 : : } else {
192 : : // Random sizes so we can test memory usage accounting
193 : 45518 : newcoin.out.scriptPubKey.assign(m_rng.randbits(6), 0);
194 [ + + ]: 45518 : (coin.IsSpent() ? added_an_entry : updated_an_entry) = true;
195 : 45518 : coin = newcoin;
196 : : }
197 [ + + + + ]: 47992 : bool is_overwrite = !coin.IsSpent() || m_rng.rand32() & 1;
198 [ + - ]: 47992 : stack.back()->AddCoin(COutPoint(txid, 0), std::move(newcoin), is_overwrite);
199 : 47992 : } else {
200 : : // Spend the coin.
201 : 32008 : removed_an_entry = true;
202 : 32008 : coin.Clear();
203 [ + - + - : 64016 : BOOST_CHECK(stack.back()->SpendCoin(COutPoint(txid, 0)));
+ - ]
204 : : }
205 : : }
206 : :
207 : : // Once every 10 iterations, remove a random entry from the cache
208 [ + + ]: 80000 : if (m_rng.randrange(10) == 0) {
209 : 8117 : COutPoint out(txids[m_rng.rand32() % txids.size()], 0);
210 [ + - ]: 8117 : int cacheid = m_rng.rand32() % stack.size();
211 [ + - ]: 8117 : stack[cacheid]->Uncache(out);
212 [ + - ]: 8117 : uncached_an_entry |= !stack[cacheid]->HaveCoinInCache(out);
213 : : }
214 : :
215 : : // Once every 1000 iterations and at the end, verify the full cache.
216 [ + + + + ]: 80000 : if (m_rng.randrange(1000) == 1 || i == NUM_SIMULATION_ITERATIONS - 1) {
217 [ + + ]: 370246 : for (const auto& entry : result) {
218 [ + - ]: 370163 : bool have = stack.back()->HaveCoin(entry.first);
219 [ + - ]: 370163 : const Coin& coin = stack.back()->AccessCoin(entry.first);
220 [ + - + - : 740326 : BOOST_CHECK(have == !coin.IsSpent());
+ - ]
221 [ + - + - : 740326 : BOOST_CHECK(coin == entry.second);
+ + ]
222 [ + + ]: 370163 : if (coin.IsSpent()) {
223 : : missed_an_entry = true;
224 : : } else {
225 [ + - + - : 425152 : BOOST_CHECK(stack.back()->HaveCoinInCache(entry.first));
+ - ]
226 : 212576 : found_an_entry = true;
227 : : }
228 : : }
229 [ + + ]: 285 : for (const auto& test : stack) {
230 [ + - ]: 202 : test->SelfTest();
231 : : }
232 : : }
233 : :
234 [ + + ]: 80000 : if (m_rng.randrange(100) == 0) {
235 : : // Every 100 iterations, flush an intermediate cache
236 [ + + + + ]: 780 : if (stack.size() > 1 && m_rng.randbool() == 0) {
237 : 282 : unsigned int flushIndex = m_rng.randrange(stack.size() - 1);
238 [ + + + - ]: 282 : if (fake_best_block) stack[flushIndex]->SetBestBlock(m_rng.rand256());
239 : 282 : bool should_erase = m_rng.randrange(4) < 3;
240 [ + - + + : 564 : BOOST_CHECK(should_erase ? stack[flushIndex]->Flush() : stack[flushIndex]->Sync());
+ - + - +
- ]
241 : 282 : flushed_without_erase |= !should_erase;
242 : : }
243 : : }
244 [ + + ]: 80000 : if (m_rng.randrange(100) == 0) {
245 : : // Every 100 iterations, change the cache stack.
246 [ + - + + ]: 806 : if (stack.size() > 0 && m_rng.randbool() == 0) {
247 : : //Remove the top cache
248 [ + + + - ]: 411 : if (fake_best_block) stack.back()->SetBestBlock(m_rng.rand256());
249 : 411 : bool should_erase = m_rng.randrange(4) < 3;
250 [ + - + + : 822 : BOOST_CHECK(should_erase ? stack.back()->Flush() : stack.back()->Sync());
+ - + - +
- ]
251 : 411 : flushed_without_erase |= !should_erase;
252 : 411 : stack.pop_back();
253 : : }
254 [ + + + + : 806 : if (stack.size() == 0 || (stack.size() < 4 && m_rng.randbool())) {
+ + ]
255 : : //Add a new cache
256 : 413 : CCoinsView* tip = base;
257 [ + + ]: 413 : if (stack.size() > 0) {
258 : 312 : tip = stack.back().get();
259 : : } else {
260 : : removed_all_caches = true;
261 : : }
262 [ + - ]: 826 : stack.push_back(std::make_unique<CCoinsViewCacheTest>(tip));
263 [ + + ]: 413 : if (stack.size() == 4) {
264 : 81 : reached_4_caches = true;
265 : : }
266 : : }
267 : : }
268 : : }
269 : :
270 : : // Verify coverage.
271 [ + - + - : 4 : BOOST_CHECK(removed_all_caches);
+ - ]
272 [ + - + - : 4 : BOOST_CHECK(reached_4_caches);
+ - ]
273 [ + - + - : 4 : BOOST_CHECK(added_an_entry);
+ - ]
274 [ + - + - : 4 : BOOST_CHECK(added_an_unspendable_entry);
+ - ]
275 [ + - + - : 4 : BOOST_CHECK(removed_an_entry);
+ - ]
276 [ + - + - : 4 : BOOST_CHECK(updated_an_entry);
+ - ]
277 [ + - + - : 4 : BOOST_CHECK(found_an_entry);
+ - ]
278 [ + - + - : 4 : BOOST_CHECK(missed_an_entry);
+ - ]
279 [ + - + - : 4 : BOOST_CHECK(uncached_an_entry);
+ - ]
280 [ + - + - ]: 4 : BOOST_CHECK(flushed_without_erase);
281 : 2 : }
282 : : }; // struct CacheTest
283 : :
284 : : // Run the above simulation for multiple base types.
285 [ + - + - : 7 : BOOST_FIXTURE_TEST_CASE(coins_cache_simulation_test, CacheTest)
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
286 : : {
287 [ + - ]: 1 : CCoinsViewTest base{m_rng};
288 [ + - ]: 1 : SimulationTest(&base, false);
289 : :
290 : 0 : CCoinsViewDB db_base{{.path = "test", .cache_bytes = 1 << 23, .memory_only = true}, {}};
291 [ + - ]: 1 : SimulationTest(&db_base, true);
292 [ + - + - ]: 2 : }
293 : :
294 : : struct UpdateTest : BasicTestingSetup {
295 : : // Store of all necessary tx and undo data for next test
296 : : typedef std::map<COutPoint, std::tuple<CTransaction,CTxUndo,Coin>> UtxoData;
297 : : UtxoData utxoData;
298 : :
299 : 40257 : UtxoData::iterator FindRandomFrom(const std::set<COutPoint> &utxoSet) {
300 [ - + ]: 40257 : assert(utxoSet.size());
301 : 40257 : auto utxoSetIt = utxoSet.lower_bound(COutPoint(Txid::FromUint256(m_rng.rand256()), 0));
302 [ + + ]: 40257 : if (utxoSetIt == utxoSet.end()) {
303 : 382 : utxoSetIt = utxoSet.begin();
304 : : }
305 : 40257 : auto utxoDataIt = utxoData.find(*utxoSetIt);
306 [ - + ]: 40257 : assert(utxoDataIt != utxoData.end());
307 : 40257 : return utxoDataIt;
308 : : }
309 : : }; // struct UpdateTest
310 : :
311 : :
312 : : // This test is similar to the previous test
313 : : // except the emphasis is on testing the functionality of UpdateCoins
314 : : // random txs are created and UpdateCoins is used to update the cache stack
315 : : // In particular it is tested that spending a duplicate coinbase tx
316 : : // has the expected effect (the other duplicate is overwritten at all cache levels)
317 [ + - + - : 7 : BOOST_FIXTURE_TEST_CASE(updatecoins_simulation_test, UpdateTest)
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
318 : : {
319 : 1 : SeedRandomForTest(SeedRand::ZEROS);
320 : :
321 : 1 : bool spent_a_duplicate_coinbase = false;
322 : : // A simple map to track what we expect the cache stack to represent.
323 [ + - ]: 1 : std::map<COutPoint, Coin> result;
324 : :
325 : : // The cache stack.
326 [ + - ]: 1 : CCoinsViewTest base{m_rng}; // A CCoinsViewTest at the bottom.
327 : 1 : std::vector<std::unique_ptr<CCoinsViewCacheTest>> stack; // A stack of CCoinsViewCaches on top.
328 [ + - ]: 2 : stack.push_back(std::make_unique<CCoinsViewCacheTest>(&base)); // Start with one cache.
329 : :
330 : : // Track the txids we've used in various sets
331 : 1 : std::set<COutPoint> coinbase_coins;
332 : 1 : std::set<COutPoint> disconnected_coins;
333 : 1 : std::set<COutPoint> duplicate_coins;
334 : 1 : std::set<COutPoint> utxoset;
335 : :
336 [ + + ]: 40001 : for (unsigned int i = 0; i < NUM_SIMULATION_ITERATIONS; i++) {
337 : 40000 : uint32_t randiter = m_rng.rand32();
338 : :
339 : : // 19/20 txs add a new transaction
340 [ + + ]: 40000 : if (randiter % 20 < 19) {
341 [ + - ]: 37952 : CMutableTransaction tx;
342 [ + - ]: 37952 : tx.vin.resize(1);
343 [ + - ]: 37952 : tx.vout.resize(1);
344 : 37952 : tx.vout[0].nValue = i; //Keep txs unique unless intended to duplicate
345 : 37952 : tx.vout[0].scriptPubKey.assign(m_rng.rand32() & 0x3F, 0); // Random sizes so we can test memory usage accounting
346 : 37952 : const int height{int(m_rng.rand32() >> 1)};
347 : 37952 : Coin old_coin;
348 : :
349 : : // 2/20 times create a new coinbase
350 [ + + + + ]: 37952 : if (randiter % 20 < 2 || coinbase_coins.size() < 10) {
351 : : // 1/10 of those times create a duplicate coinbase
352 [ + + - + ]: 4049 : if (m_rng.randrange(10) == 0 && coinbase_coins.size()) {
353 : 380 : auto utxod = FindRandomFrom(coinbase_coins);
354 : : // Reuse the exact same coinbase
355 [ + - ]: 380 : tx = CMutableTransaction{std::get<0>(utxod->second)};
356 : : // shouldn't be available for reconnection if it's been duplicated
357 : 380 : disconnected_coins.erase(utxod->first);
358 : :
359 [ + - ]: 380 : duplicate_coins.insert(utxod->first);
360 : : }
361 : : else {
362 [ + - + - ]: 3669 : coinbase_coins.insert(COutPoint(tx.GetHash(), 0));
363 : : }
364 [ + - - + ]: 8098 : assert(CTransaction(tx).IsCoinBase());
365 : : }
366 : :
367 : : // 17/20 times reconnect previous or add a regular tx
368 : : else {
369 : :
370 [ + + ]: 33903 : COutPoint prevout;
371 : : // 1/20 times reconnect a previously disconnected tx
372 [ + + + + ]: 33903 : if (randiter % 20 == 2 && disconnected_coins.size()) {
373 : 2018 : auto utxod = FindRandomFrom(disconnected_coins);
374 [ + - ]: 2018 : tx = CMutableTransaction{std::get<0>(utxod->second)};
375 [ + - ]: 2018 : prevout = tx.vin[0].prevout;
376 [ + - + + : 4036 : if (!CTransaction(tx).IsCoinBase() && !utxoset.count(prevout)) {
+ + + + ]
377 : 581 : disconnected_coins.erase(utxod->first);
378 : 581 : continue;
379 : : }
380 : :
381 : : // If this tx is already IN the UTXO, then it must be a coinbase, and it must be a duplicate
382 [ - + ]: 1437 : if (utxoset.count(utxod->first)) {
383 [ # # # # ]: 0 : assert(CTransaction(tx).IsCoinBase());
384 [ # # ]: 0 : assert(duplicate_coins.count(utxod->first));
385 : : }
386 : 1437 : disconnected_coins.erase(utxod->first);
387 : : }
388 : :
389 : : // 16/20 times create a regular tx
390 : : else {
391 : 31885 : auto utxod = FindRandomFrom(utxoset);
392 [ + - ]: 31885 : prevout = utxod->first;
393 : :
394 : : // Construct the tx to spend the coins of prevouthash
395 [ + - ]: 31885 : tx.vin[0].prevout = prevout;
396 [ + - - + ]: 63770 : assert(!CTransaction(tx).IsCoinBase());
397 : : }
398 : : // In this simple test coins only have two states, spent or unspent, save the unspent state to restore
399 [ + - ]: 33322 : old_coin = result[prevout];
400 : : // Update the expected result of prevouthash to know these coins are spent
401 [ + - ]: 33322 : result[prevout].Clear();
402 : :
403 : 33322 : utxoset.erase(prevout);
404 : :
405 : : // The test is designed to ensure spending a duplicate coinbase will work properly
406 : : // if that ever happens and not resurrect the previously overwritten coinbase
407 [ + + ]: 33322 : if (duplicate_coins.count(prevout)) {
408 : 346 : spent_a_duplicate_coinbase = true;
409 : : }
410 : :
411 : : }
412 : : // Update the expected result to know about the new output coins
413 [ - + ]: 37371 : assert(tx.vout.size() == 1);
414 [ + - ]: 37371 : const COutPoint outpoint(tx.GetHash(), 0);
415 [ + - + - ]: 37371 : result[outpoint] = Coin{tx.vout[0], height, CTransaction{tx}.IsCoinBase()};
416 : :
417 : : // Call UpdateCoins on the top cache
418 : 37371 : CTxUndo undo;
419 [ + - + - ]: 37371 : UpdateCoins(CTransaction{tx}, *(stack.back()), undo, height);
420 : :
421 : : // Update the utxo set for future spends
422 [ + - ]: 37371 : utxoset.insert(outpoint);
423 : :
424 : : // Track this tx and undo info to use later
425 [ + - + - ]: 112113 : utxoData.emplace(outpoint, std::make_tuple(tx,undo,old_coin));
426 [ + - ]: 77952 : } else if (utxoset.size()) {
427 : : //1/20 times undo a previous transaction
428 : 2048 : auto utxod = FindRandomFrom(utxoset);
429 : :
430 [ + - ]: 2048 : CTransaction &tx = std::get<0>(utxod->second);
431 : 2048 : CTxUndo &undo = std::get<1>(utxod->second);
432 [ + - ]: 2048 : Coin &orig_coin = std::get<2>(utxod->second);
433 : :
434 : : // Update the expected result
435 : : // Remove new outputs
436 [ + - ]: 2048 : result[utxod->first].Clear();
437 : : // If not coinbase restore prevout
438 [ + + ]: 2048 : if (!tx.IsCoinBase()) {
439 [ + - ]: 1810 : result[tx.vin[0].prevout] = orig_coin;
440 : : }
441 : :
442 : : // Disconnect the tx from the current UTXO
443 : : // See code in DisconnectBlock
444 : : // remove outputs
445 [ + - + - : 4096 : BOOST_CHECK(stack.back()->SpendCoin(utxod->first));
+ - + + ]
446 : : // restore inputs
447 [ + + ]: 2048 : if (!tx.IsCoinBase()) {
448 : 1810 : const COutPoint &out = tx.vin[0].prevout;
449 : 1810 : Coin coin = undo.vprevout[0];
450 [ + - ]: 1810 : ApplyTxInUndo(std::move(coin), *(stack.back()), out);
451 : 1810 : }
452 : : // Store as a candidate for reconnection
453 [ + - ]: 2048 : disconnected_coins.insert(utxod->first);
454 : :
455 : : // Update the utxoset
456 : 2048 : utxoset.erase(utxod->first);
457 [ + + ]: 2048 : if (!tx.IsCoinBase())
458 [ + - ]: 1810 : utxoset.insert(tx.vin[0].prevout);
459 : : }
460 : :
461 : : // Once every 1000 iterations and at the end, verify the full cache.
462 [ + + + + ]: 39419 : if (m_rng.randrange(1000) == 1 || i == NUM_SIMULATION_ITERATIONS - 1) {
463 [ + + ]: 662643 : for (const auto& entry : result) {
464 [ + - ]: 662605 : bool have = stack.back()->HaveCoin(entry.first);
465 [ + - ]: 662605 : const Coin& coin = stack.back()->AccessCoin(entry.first);
466 [ + - + - : 1325210 : BOOST_CHECK(have == !coin.IsSpent());
+ - ]
467 [ + - + - ]: 1325210 : BOOST_CHECK(coin == entry.second);
468 : : }
469 : : }
470 : :
471 : : // One every 10 iterations, remove a random entry from the cache
472 [ + + + + ]: 39419 : if (utxoset.size() > 1 && m_rng.randrange(30) == 0) {
473 [ + - ]: 1351 : stack[m_rng.rand32() % stack.size()]->Uncache(FindRandomFrom(utxoset)->first);
474 : : }
475 [ + + + + ]: 39419 : if (disconnected_coins.size() > 1 && m_rng.randrange(30) == 0) {
476 [ + - ]: 1231 : stack[m_rng.rand32() % stack.size()]->Uncache(FindRandomFrom(disconnected_coins)->first);
477 : : }
478 [ + + + + ]: 39419 : if (duplicate_coins.size() > 1 && m_rng.randrange(30) == 0) {
479 [ + - ]: 1344 : stack[m_rng.rand32() % stack.size()]->Uncache(FindRandomFrom(duplicate_coins)->first);
480 : : }
481 : :
482 [ + + ]: 39419 : if (m_rng.randrange(100) == 0) {
483 : : // Every 100 iterations, flush an intermediate cache
484 [ + + + + ]: 372 : if (stack.size() > 1 && m_rng.randbool() == 0) {
485 : 173 : unsigned int flushIndex = m_rng.randrange(stack.size() - 1);
486 [ + - + - : 346 : BOOST_CHECK(stack[flushIndex]->Flush());
+ - ]
487 : : }
488 : : }
489 [ + + ]: 39419 : if (m_rng.randrange(100) == 0) {
490 : : // Every 100 iterations, change the cache stack.
491 [ + - + + ]: 398 : if (stack.size() > 0 && m_rng.randbool() == 0) {
492 [ + - + - : 390 : BOOST_CHECK(stack.back()->Flush());
+ - ]
493 : 195 : stack.pop_back();
494 : : }
495 [ + + + + : 398 : if (stack.size() == 0 || (stack.size() < 4 && m_rng.randbool())) {
+ + ]
496 : 196 : CCoinsView* tip = &base;
497 [ + + ]: 196 : if (stack.size() > 0) {
498 : 165 : tip = stack.back().get();
499 : : }
500 [ + - ]: 392 : stack.push_back(std::make_unique<CCoinsViewCacheTest>(tip));
501 : : }
502 : : }
503 : : }
504 : :
505 : : // Verify coverage.
506 [ + - + - ]: 2 : BOOST_CHECK(spent_a_duplicate_coinbase);
507 : 1 : }
508 : :
509 [ + - + - : 7 : BOOST_AUTO_TEST_CASE(ccoins_serialization)
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
510 : : {
511 : : // Good example
512 : 1 : DataStream ss1{"97f23c835800816115944e077fe7c803cfa57f29b36bf87c1d35"_hex};
513 : 1 : Coin cc1;
514 [ + - ]: 1 : ss1 >> cc1;
515 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(cc1.fCoinBase, false);
516 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(cc1.nHeight, 203998U);
517 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(cc1.out.nValue, CAmount{60000000000});
518 [ + - + - : 3 : BOOST_CHECK_EQUAL(HexStr(cc1.out.scriptPubKey), HexStr(GetScriptForDestination(PKHash(uint160("816115944e077fe7c803cfa57f29b36bf87c1d35"_hex_u8)))));
+ - + - +
- ]
519 : :
520 : : // Good example
521 [ + - ]: 1 : DataStream ss2{"8ddf77bbd123008c988f1a4a4de2161e0f50aac7f17e7f9555caa4"_hex};
522 : 1 : Coin cc2;
523 [ + - ]: 1 : ss2 >> cc2;
524 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(cc2.fCoinBase, true);
525 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(cc2.nHeight, 120891U);
526 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(cc2.out.nValue, 110397);
527 [ + - + - : 3 : BOOST_CHECK_EQUAL(HexStr(cc2.out.scriptPubKey), HexStr(GetScriptForDestination(PKHash(uint160("8c988f1a4a4de2161e0f50aac7f17e7f9555caa4"_hex_u8)))));
+ - + - +
- ]
528 : :
529 : : // Smallest possible example
530 [ + - ]: 1 : DataStream ss3{"000006"_hex};
531 : 1 : Coin cc3;
532 [ + - ]: 1 : ss3 >> cc3;
533 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(cc3.fCoinBase, false);
534 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(cc3.nHeight, 0U);
535 [ + - + - ]: 1 : BOOST_CHECK_EQUAL(cc3.out.nValue, 0);
536 [ + - - + : 1 : BOOST_CHECK_EQUAL(cc3.out.scriptPubKey.size(), 0U);
+ - ]
537 : :
538 : : // scriptPubKey that ends beyond the end of the stream
539 [ + - ]: 1 : DataStream ss4{"000007"_hex};
540 : 1 : try {
541 : 1 : Coin cc4;
542 [ - + ]: 1 : ss4 >> cc4;
543 [ # # # # ]: 0 : BOOST_CHECK_MESSAGE(false, "We should have thrown");
544 [ - + ]: 1 : } catch (const std::ios_base::failure&) {
545 : 1 : }
546 : :
547 : : // Very large scriptPubKey (3*10^9 bytes) past the end of the stream
548 : 1 : DataStream tmp{};
549 : 1 : uint64_t x = 3000000000ULL;
550 [ + - ]: 1 : tmp << VARINT(x);
551 [ + - + - : 1 : BOOST_CHECK_EQUAL(HexStr(tmp), "8a95c0bb00");
+ - ]
552 [ + - ]: 1 : DataStream ss5{"00008a95c0bb00"_hex};
553 : 1 : try {
554 : 1 : Coin cc5;
555 [ - + ]: 1 : ss5 >> cc5;
556 [ # # # # ]: 0 : BOOST_CHECK_MESSAGE(false, "We should have thrown");
557 [ - + ]: 1 : } catch (const std::ios_base::failure&) {
558 : 1 : }
559 : 1 : }
560 : :
561 : : const static COutPoint OUTPOINT;
562 : : const static CAmount SPENT = -1;
563 : : const static CAmount ABSENT = -2;
564 : : const static CAmount FAIL = -3;
565 : : const static CAmount VALUE1 = 100;
566 : : const static CAmount VALUE2 = 200;
567 : : const static CAmount VALUE3 = 300;
568 : : const static char DIRTY = CCoinsCacheEntry::DIRTY;
569 : : const static char FRESH = CCoinsCacheEntry::FRESH;
570 : : const static char NO_ENTRY = -1;
571 : :
572 : : const static auto FLAGS = {char(0), FRESH, DIRTY, char(DIRTY | FRESH)};
573 : : const static auto CLEAN_FLAGS = {char(0), FRESH};
574 : : const static auto ABSENT_FLAGS = {NO_ENTRY};
575 : :
576 : 320 : static void SetCoinsValue(CAmount value, Coin& coin)
577 : : {
578 [ - + ]: 320 : assert(value != ABSENT);
579 : 320 : coin.Clear();
580 [ - + ]: 320 : assert(coin.IsSpent());
581 [ + + ]: 320 : if (value != SPENT) {
582 : 160 : coin.out.nValue = value;
583 : 160 : coin.nHeight = 1;
584 : 160 : assert(!coin.IsSpent());
585 : : }
586 : 320 : }
587 : :
588 : 486 : static size_t InsertCoinsMapEntry(CCoinsMap& map, CoinsCachePair& sentinel, CAmount value, char flags)
589 : : {
590 [ + + ]: 486 : if (value == ABSENT) {
591 [ - + ]: 166 : assert(flags == NO_ENTRY);
592 : : return 0;
593 : : }
594 [ - + ]: 320 : assert(flags != NO_ENTRY);
595 : 320 : CCoinsCacheEntry entry;
596 : 320 : SetCoinsValue(value, entry.coin);
597 [ + - ]: 320 : auto inserted = map.emplace(OUTPOINT, std::move(entry));
598 [ - + ]: 320 : assert(inserted.second);
599 : 320 : inserted.first->second.AddFlags(flags, *inserted.first, sentinel);
600 [ - + ]: 320 : return inserted.first->second.coin.DynamicMemoryUsage();
601 : 320 : }
602 : :
603 : 202 : void GetCoinsMapEntry(const CCoinsMap& map, CAmount& value, char& flags, const COutPoint& outp = OUTPOINT)
604 : : {
605 : 202 : auto it = map.find(outp);
606 [ + + ]: 202 : if (it == map.end()) {
607 : 35 : value = ABSENT;
608 : 35 : flags = NO_ENTRY;
609 : : } else {
610 [ + + ]: 167 : if (it->second.coin.IsSpent()) {
611 : 60 : value = SPENT;
612 : : } else {
613 : 107 : value = it->second.coin.out.nValue;
614 : : }
615 [ - + ]: 167 : flags = it->second.GetFlags();
616 [ - + ]: 167 : assert(flags != NO_ENTRY);
617 : : }
618 : 202 : }
619 : :
620 : 288 : void WriteCoinsViewEntry(CCoinsView& view, CAmount value, char flags)
621 : : {
622 : 288 : CoinsCachePair sentinel{};
623 : 288 : sentinel.second.SelfRef(sentinel);
624 [ + - ]: 288 : CCoinsMapMemoryResource resource;
625 [ + - + - ]: 288 : CCoinsMap map{0, CCoinsMap::hasher{}, CCoinsMap::key_equal{}, &resource};
626 [ + - ]: 288 : auto usage{InsertCoinsMapEntry(map, sentinel, value, flags)};
627 [ + - ]: 288 : auto cursor{CoinsViewCacheCursor(usage, sentinel, map, /*will_erase=*/true)};
628 [ + - + + : 568 : BOOST_CHECK(view.BatchWrite(cursor, {}));
+ - ]
629 : 288 : }
630 : :
631 : : class SingleEntryCacheTest
632 : : {
633 : : public:
634 : 198 : SingleEntryCacheTest(CAmount base_value, CAmount cache_value, char cache_flags)
635 [ + - + - ]: 198 : {
636 [ + + + - ]: 270 : WriteCoinsViewEntry(base, base_value, base_value == ABSENT ? NO_ENTRY : DIRTY);
637 [ + - ]: 198 : cache.usage() += InsertCoinsMapEntry(cache.map(), cache.sentinel(), cache_value, cache_flags);
638 : 198 : }
639 : :
640 : : CCoinsView root;
641 : : CCoinsViewCacheTest base{&root};
642 : : CCoinsViewCacheTest cache{&base};
643 : : };
644 : :
645 : 27 : static void CheckAccessCoin(CAmount base_value, CAmount cache_value, CAmount expected_value, char cache_flags, char expected_flags)
646 : : {
647 : 27 : SingleEntryCacheTest test(base_value, cache_value, cache_flags);
648 [ + - ]: 27 : test.cache.AccessCoin(OUTPOINT);
649 [ + - ]: 27 : test.cache.SelfTest(/*sanity_check=*/false);
650 : :
651 : 27 : CAmount result_value;
652 : 27 : char result_flags;
653 : 27 : GetCoinsMapEntry(test.cache.map(), result_value, result_flags);
654 [ + - + - ]: 27 : BOOST_CHECK_EQUAL(result_value, expected_value);
655 [ + - + - ]: 27 : BOOST_CHECK_EQUAL(result_flags, expected_flags);
656 : 27 : }
657 : :
658 [ + - + - : 7 : BOOST_AUTO_TEST_CASE(ccoins_access)
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
659 : : {
660 : : /* Check AccessCoin behavior, requesting a coin from a cache view layered on
661 : : * top of a base view, and checking the resulting entry in the cache after
662 : : * the access.
663 : : *
664 : : * Base Cache Result Cache Result
665 : : * Value Value Value Flags Flags
666 : : */
667 : 1 : CheckAccessCoin(ABSENT, ABSENT, ABSENT, NO_ENTRY , NO_ENTRY );
668 : 1 : CheckAccessCoin(ABSENT, SPENT , SPENT , 0 , 0 );
669 : 1 : CheckAccessCoin(ABSENT, SPENT , SPENT , FRESH , FRESH );
670 : 1 : CheckAccessCoin(ABSENT, SPENT , SPENT , DIRTY , DIRTY );
671 : 1 : CheckAccessCoin(ABSENT, SPENT , SPENT , DIRTY|FRESH, DIRTY|FRESH);
672 : 1 : CheckAccessCoin(ABSENT, VALUE2, VALUE2, 0 , 0 );
673 : 1 : CheckAccessCoin(ABSENT, VALUE2, VALUE2, FRESH , FRESH );
674 : 1 : CheckAccessCoin(ABSENT, VALUE2, VALUE2, DIRTY , DIRTY );
675 : 1 : CheckAccessCoin(ABSENT, VALUE2, VALUE2, DIRTY|FRESH, DIRTY|FRESH);
676 : 1 : CheckAccessCoin(SPENT , ABSENT, ABSENT, NO_ENTRY , NO_ENTRY );
677 : 1 : CheckAccessCoin(SPENT , SPENT , SPENT , 0 , 0 );
678 : 1 : CheckAccessCoin(SPENT , SPENT , SPENT , FRESH , FRESH );
679 : 1 : CheckAccessCoin(SPENT , SPENT , SPENT , DIRTY , DIRTY );
680 : 1 : CheckAccessCoin(SPENT , SPENT , SPENT , DIRTY|FRESH, DIRTY|FRESH);
681 : 1 : CheckAccessCoin(SPENT , VALUE2, VALUE2, 0 , 0 );
682 : 1 : CheckAccessCoin(SPENT , VALUE2, VALUE2, FRESH , FRESH );
683 : 1 : CheckAccessCoin(SPENT , VALUE2, VALUE2, DIRTY , DIRTY );
684 : 1 : CheckAccessCoin(SPENT , VALUE2, VALUE2, DIRTY|FRESH, DIRTY|FRESH);
685 : 1 : CheckAccessCoin(VALUE1, ABSENT, VALUE1, NO_ENTRY , 0 );
686 : 1 : CheckAccessCoin(VALUE1, SPENT , SPENT , 0 , 0 );
687 : 1 : CheckAccessCoin(VALUE1, SPENT , SPENT , FRESH , FRESH );
688 : 1 : CheckAccessCoin(VALUE1, SPENT , SPENT , DIRTY , DIRTY );
689 : 1 : CheckAccessCoin(VALUE1, SPENT , SPENT , DIRTY|FRESH, DIRTY|FRESH);
690 : 1 : CheckAccessCoin(VALUE1, VALUE2, VALUE2, 0 , 0 );
691 : 1 : CheckAccessCoin(VALUE1, VALUE2, VALUE2, FRESH , FRESH );
692 : 1 : CheckAccessCoin(VALUE1, VALUE2, VALUE2, DIRTY , DIRTY );
693 : 1 : CheckAccessCoin(VALUE1, VALUE2, VALUE2, DIRTY|FRESH, DIRTY|FRESH);
694 : 1 : }
695 : :
696 : 27 : static void CheckSpendCoins(CAmount base_value, CAmount cache_value, CAmount expected_value, char cache_flags, char expected_flags)
697 : : {
698 : 27 : SingleEntryCacheTest test(base_value, cache_value, cache_flags);
699 [ + - ]: 27 : test.cache.SpendCoin(OUTPOINT);
700 [ + - ]: 27 : test.cache.SelfTest();
701 : :
702 : 27 : CAmount result_value;
703 : 27 : char result_flags;
704 : 27 : GetCoinsMapEntry(test.cache.map(), result_value, result_flags);
705 [ + - + - ]: 27 : BOOST_CHECK_EQUAL(result_value, expected_value);
706 [ + - + - ]: 27 : BOOST_CHECK_EQUAL(result_flags, expected_flags);
707 : 27 : };
708 : :
709 [ + - + - : 7 : BOOST_AUTO_TEST_CASE(ccoins_spend)
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
710 : : {
711 : : /* Check SpendCoin behavior, requesting a coin from a cache view layered on
712 : : * top of a base view, spending, and then checking
713 : : * the resulting entry in the cache after the modification.
714 : : *
715 : : * Base Cache Result Cache Result
716 : : * Value Value Value Flags Flags
717 : : */
718 : 1 : CheckSpendCoins(ABSENT, ABSENT, ABSENT, NO_ENTRY , NO_ENTRY );
719 : 1 : CheckSpendCoins(ABSENT, SPENT , SPENT , 0 , DIRTY );
720 : 1 : CheckSpendCoins(ABSENT, SPENT , ABSENT, FRESH , NO_ENTRY );
721 : 1 : CheckSpendCoins(ABSENT, SPENT , SPENT , DIRTY , DIRTY );
722 : 1 : CheckSpendCoins(ABSENT, SPENT , ABSENT, DIRTY|FRESH, NO_ENTRY );
723 : 1 : CheckSpendCoins(ABSENT, VALUE2, SPENT , 0 , DIRTY );
724 : 1 : CheckSpendCoins(ABSENT, VALUE2, ABSENT, FRESH , NO_ENTRY );
725 : 1 : CheckSpendCoins(ABSENT, VALUE2, SPENT , DIRTY , DIRTY );
726 : 1 : CheckSpendCoins(ABSENT, VALUE2, ABSENT, DIRTY|FRESH, NO_ENTRY );
727 : 1 : CheckSpendCoins(SPENT , ABSENT, ABSENT, NO_ENTRY , NO_ENTRY );
728 : 1 : CheckSpendCoins(SPENT , SPENT , SPENT , 0 , DIRTY );
729 : 1 : CheckSpendCoins(SPENT , SPENT , ABSENT, FRESH , NO_ENTRY );
730 : 1 : CheckSpendCoins(SPENT , SPENT , SPENT , DIRTY , DIRTY );
731 : 1 : CheckSpendCoins(SPENT , SPENT , ABSENT, DIRTY|FRESH, NO_ENTRY );
732 : 1 : CheckSpendCoins(SPENT , VALUE2, SPENT , 0 , DIRTY );
733 : 1 : CheckSpendCoins(SPENT , VALUE2, ABSENT, FRESH , NO_ENTRY );
734 : 1 : CheckSpendCoins(SPENT , VALUE2, SPENT , DIRTY , DIRTY );
735 : 1 : CheckSpendCoins(SPENT , VALUE2, ABSENT, DIRTY|FRESH, NO_ENTRY );
736 : 1 : CheckSpendCoins(VALUE1, ABSENT, SPENT , NO_ENTRY , DIRTY );
737 : 1 : CheckSpendCoins(VALUE1, SPENT , SPENT , 0 , DIRTY );
738 : 1 : CheckSpendCoins(VALUE1, SPENT , ABSENT, FRESH , NO_ENTRY );
739 : 1 : CheckSpendCoins(VALUE1, SPENT , SPENT , DIRTY , DIRTY );
740 : 1 : CheckSpendCoins(VALUE1, SPENT , ABSENT, DIRTY|FRESH, NO_ENTRY );
741 : 1 : CheckSpendCoins(VALUE1, VALUE2, SPENT , 0 , DIRTY );
742 : 1 : CheckSpendCoins(VALUE1, VALUE2, ABSENT, FRESH , NO_ENTRY );
743 : 1 : CheckSpendCoins(VALUE1, VALUE2, SPENT , DIRTY , DIRTY );
744 : 1 : CheckSpendCoins(VALUE1, VALUE2, ABSENT, DIRTY|FRESH, NO_ENTRY );
745 : 1 : }
746 : :
747 : 54 : static void CheckAddCoinBase(CAmount base_value, CAmount cache_value, CAmount modify_value, CAmount expected_value, char cache_flags, char expected_flags, bool coinbase)
748 : : {
749 : 54 : SingleEntryCacheTest test(base_value, cache_value, cache_flags);
750 : :
751 : 54 : CAmount result_value;
752 : 54 : char result_flags;
753 : 54 : try {
754 : 54 : CTxOut output;
755 : 54 : output.nValue = modify_value;
756 [ + + ]: 66 : test.cache.AddCoin(OUTPOINT, Coin(std::move(output), 1, coinbase), coinbase);
757 [ + - ]: 42 : test.cache.SelfTest();
758 : 42 : GetCoinsMapEntry(test.cache.map(), result_value, result_flags);
759 [ - + ]: 54 : } catch (std::logic_error&) {
760 : 12 : result_value = FAIL;
761 : 12 : result_flags = NO_ENTRY;
762 : 12 : }
763 : :
764 [ + - + - ]: 54 : BOOST_CHECK_EQUAL(result_value, expected_value);
765 [ + - + - ]: 54 : BOOST_CHECK_EQUAL(result_flags, expected_flags);
766 : 54 : }
767 : :
768 : : // Simple wrapper for CheckAddCoinBase function above that loops through
769 : : // different possible base_values, making sure each one gives the same results.
770 : : // This wrapper lets the coins_add test below be shorter and less repetitive,
771 : : // while still verifying that the CoinsViewCache::AddCoin implementation
772 : : // ignores base values.
773 : : template <typename... Args>
774 : 18 : static void CheckAddCoin(Args&&... args)
775 : : {
776 [ + + ]: 72 : for (const CAmount base_value : {ABSENT, SPENT, VALUE1})
777 : 54 : CheckAddCoinBase(base_value, std::forward<Args>(args)...);
778 : 18 : }
779 : :
780 [ + - + - : 7 : BOOST_AUTO_TEST_CASE(ccoins_add)
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
781 : : {
782 : : /* Check AddCoin behavior, requesting a new coin from a cache view,
783 : : * writing a modification to the coin, and then checking the resulting
784 : : * entry in the cache after the modification. Verify behavior with the
785 : : * AddCoin possible_overwrite argument set to false, and to true.
786 : : *
787 : : * Cache Write Result Cache Result possible_overwrite
788 : : * Value Value Value Flags Flags
789 : : */
790 : 1 : CheckAddCoin(ABSENT, VALUE3, VALUE3, NO_ENTRY , DIRTY|FRESH, false);
791 : 1 : CheckAddCoin(ABSENT, VALUE3, VALUE3, NO_ENTRY , DIRTY , true );
792 : 1 : CheckAddCoin(SPENT , VALUE3, VALUE3, 0 , DIRTY|FRESH, false);
793 : 1 : CheckAddCoin(SPENT , VALUE3, VALUE3, 0 , DIRTY , true );
794 : 1 : CheckAddCoin(SPENT , VALUE3, VALUE3, FRESH , DIRTY|FRESH, false);
795 : 1 : CheckAddCoin(SPENT , VALUE3, VALUE3, FRESH , DIRTY|FRESH, true );
796 : 1 : CheckAddCoin(SPENT , VALUE3, VALUE3, DIRTY , DIRTY , false);
797 : 1 : CheckAddCoin(SPENT , VALUE3, VALUE3, DIRTY , DIRTY , true );
798 : 1 : CheckAddCoin(SPENT , VALUE3, VALUE3, DIRTY|FRESH, DIRTY|FRESH, false);
799 : 1 : CheckAddCoin(SPENT , VALUE3, VALUE3, DIRTY|FRESH, DIRTY|FRESH, true );
800 : 1 : CheckAddCoin(VALUE2, VALUE3, FAIL , 0 , NO_ENTRY , false);
801 : 1 : CheckAddCoin(VALUE2, VALUE3, VALUE3, 0 , DIRTY , true );
802 : 1 : CheckAddCoin(VALUE2, VALUE3, FAIL , FRESH , NO_ENTRY , false);
803 : 1 : CheckAddCoin(VALUE2, VALUE3, VALUE3, FRESH , DIRTY|FRESH, true );
804 : 1 : CheckAddCoin(VALUE2, VALUE3, FAIL , DIRTY , NO_ENTRY , false);
805 : 1 : CheckAddCoin(VALUE2, VALUE3, VALUE3, DIRTY , DIRTY , true );
806 : 1 : CheckAddCoin(VALUE2, VALUE3, FAIL , DIRTY|FRESH, NO_ENTRY , false);
807 : 1 : CheckAddCoin(VALUE2, VALUE3, VALUE3, DIRTY|FRESH, DIRTY|FRESH, true );
808 : 1 : }
809 : :
810 : 90 : void CheckWriteCoins(CAmount parent_value, CAmount child_value, CAmount expected_value, char parent_flags, char child_flags, char expected_flags)
811 : : {
812 : 90 : SingleEntryCacheTest test(ABSENT, parent_value, parent_flags);
813 : :
814 : 90 : CAmount result_value;
815 : 90 : char result_flags;
816 : 90 : try {
817 [ + + ]: 90 : WriteCoinsViewEntry(test.cache, child_value, child_flags);
818 [ + - ]: 82 : test.cache.SelfTest(/*sanity_check=*/false);
819 : 82 : GetCoinsMapEntry(test.cache.map(), result_value, result_flags);
820 [ - + ]: 8 : } catch (std::logic_error&) {
821 : 8 : result_value = FAIL;
822 : 8 : result_flags = NO_ENTRY;
823 : 8 : }
824 : :
825 [ + - + - ]: 90 : BOOST_CHECK_EQUAL(result_value, expected_value);
826 [ + - + - ]: 90 : BOOST_CHECK_EQUAL(result_flags, expected_flags);
827 : 90 : }
828 : :
829 [ + - + - : 7 : BOOST_AUTO_TEST_CASE(ccoins_write)
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
830 : : {
831 : : /* Check BatchWrite behavior, flushing one entry from a child cache to a
832 : : * parent cache, and checking the resulting entry in the parent cache
833 : : * after the write.
834 : : *
835 : : * Parent Child Result Parent Child Result
836 : : * Value Value Value Flags Flags Flags
837 : : */
838 : 1 : CheckWriteCoins(ABSENT, ABSENT, ABSENT, NO_ENTRY , NO_ENTRY , NO_ENTRY );
839 : 1 : CheckWriteCoins(ABSENT, SPENT , SPENT , NO_ENTRY , DIRTY , DIRTY );
840 : 1 : CheckWriteCoins(ABSENT, SPENT , ABSENT, NO_ENTRY , DIRTY|FRESH, NO_ENTRY );
841 : 1 : CheckWriteCoins(ABSENT, VALUE2, VALUE2, NO_ENTRY , DIRTY , DIRTY );
842 : 1 : CheckWriteCoins(ABSENT, VALUE2, VALUE2, NO_ENTRY , DIRTY|FRESH, DIRTY|FRESH);
843 : 1 : CheckWriteCoins(SPENT , ABSENT, SPENT , 0 , NO_ENTRY , 0 );
844 : 1 : CheckWriteCoins(SPENT , ABSENT, SPENT , FRESH , NO_ENTRY , FRESH );
845 : 1 : CheckWriteCoins(SPENT , ABSENT, SPENT , DIRTY , NO_ENTRY , DIRTY );
846 : 1 : CheckWriteCoins(SPENT , ABSENT, SPENT , DIRTY|FRESH, NO_ENTRY , DIRTY|FRESH);
847 : 1 : CheckWriteCoins(SPENT , SPENT , SPENT , 0 , DIRTY , DIRTY );
848 : 1 : CheckWriteCoins(SPENT , SPENT , SPENT , 0 , DIRTY|FRESH, DIRTY );
849 : 1 : CheckWriteCoins(SPENT , SPENT , ABSENT, FRESH , DIRTY , NO_ENTRY );
850 : 1 : CheckWriteCoins(SPENT , SPENT , ABSENT, FRESH , DIRTY|FRESH, NO_ENTRY );
851 : 1 : CheckWriteCoins(SPENT , SPENT , SPENT , DIRTY , DIRTY , DIRTY );
852 : 1 : CheckWriteCoins(SPENT , SPENT , SPENT , DIRTY , DIRTY|FRESH, DIRTY );
853 : 1 : CheckWriteCoins(SPENT , SPENT , ABSENT, DIRTY|FRESH, DIRTY , NO_ENTRY );
854 : 1 : CheckWriteCoins(SPENT , SPENT , ABSENT, DIRTY|FRESH, DIRTY|FRESH, NO_ENTRY );
855 : 1 : CheckWriteCoins(SPENT , VALUE2, VALUE2, 0 , DIRTY , DIRTY );
856 : 1 : CheckWriteCoins(SPENT , VALUE2, VALUE2, 0 , DIRTY|FRESH, DIRTY );
857 : 1 : CheckWriteCoins(SPENT , VALUE2, VALUE2, FRESH , DIRTY , DIRTY|FRESH);
858 : 1 : CheckWriteCoins(SPENT , VALUE2, VALUE2, FRESH , DIRTY|FRESH, DIRTY|FRESH);
859 : 1 : CheckWriteCoins(SPENT , VALUE2, VALUE2, DIRTY , DIRTY , DIRTY );
860 : 1 : CheckWriteCoins(SPENT , VALUE2, VALUE2, DIRTY , DIRTY|FRESH, DIRTY );
861 : 1 : CheckWriteCoins(SPENT , VALUE2, VALUE2, DIRTY|FRESH, DIRTY , DIRTY|FRESH);
862 : 1 : CheckWriteCoins(SPENT , VALUE2, VALUE2, DIRTY|FRESH, DIRTY|FRESH, DIRTY|FRESH);
863 : 1 : CheckWriteCoins(VALUE1, ABSENT, VALUE1, 0 , NO_ENTRY , 0 );
864 : 1 : CheckWriteCoins(VALUE1, ABSENT, VALUE1, FRESH , NO_ENTRY , FRESH );
865 : 1 : CheckWriteCoins(VALUE1, ABSENT, VALUE1, DIRTY , NO_ENTRY , DIRTY );
866 : 1 : CheckWriteCoins(VALUE1, ABSENT, VALUE1, DIRTY|FRESH, NO_ENTRY , DIRTY|FRESH);
867 : 1 : CheckWriteCoins(VALUE1, SPENT , SPENT , 0 , DIRTY , DIRTY );
868 : 1 : CheckWriteCoins(VALUE1, SPENT , FAIL , 0 , DIRTY|FRESH, NO_ENTRY );
869 : 1 : CheckWriteCoins(VALUE1, SPENT , ABSENT, FRESH , DIRTY , NO_ENTRY );
870 : 1 : CheckWriteCoins(VALUE1, SPENT , FAIL , FRESH , DIRTY|FRESH, NO_ENTRY );
871 : 1 : CheckWriteCoins(VALUE1, SPENT , SPENT , DIRTY , DIRTY , DIRTY );
872 : 1 : CheckWriteCoins(VALUE1, SPENT , FAIL , DIRTY , DIRTY|FRESH, NO_ENTRY );
873 : 1 : CheckWriteCoins(VALUE1, SPENT , ABSENT, DIRTY|FRESH, DIRTY , NO_ENTRY );
874 : 1 : CheckWriteCoins(VALUE1, SPENT , FAIL , DIRTY|FRESH, DIRTY|FRESH, NO_ENTRY );
875 : 1 : CheckWriteCoins(VALUE1, VALUE2, VALUE2, 0 , DIRTY , DIRTY );
876 : 1 : CheckWriteCoins(VALUE1, VALUE2, FAIL , 0 , DIRTY|FRESH, NO_ENTRY );
877 : 1 : CheckWriteCoins(VALUE1, VALUE2, VALUE2, FRESH , DIRTY , DIRTY|FRESH);
878 : 1 : CheckWriteCoins(VALUE1, VALUE2, FAIL , FRESH , DIRTY|FRESH, NO_ENTRY );
879 : 1 : CheckWriteCoins(VALUE1, VALUE2, VALUE2, DIRTY , DIRTY , DIRTY );
880 : 1 : CheckWriteCoins(VALUE1, VALUE2, FAIL , DIRTY , DIRTY|FRESH, NO_ENTRY );
881 : 1 : CheckWriteCoins(VALUE1, VALUE2, VALUE2, DIRTY|FRESH, DIRTY , DIRTY|FRESH);
882 : 1 : CheckWriteCoins(VALUE1, VALUE2, FAIL , DIRTY|FRESH, DIRTY|FRESH, NO_ENTRY );
883 : :
884 : : // The checks above omit cases where the child flags are not DIRTY, since
885 : : // they would be too repetitive (the parent cache is never updated in these
886 : : // cases). The loop below covers these cases and makes sure the parent cache
887 : : // is always left unchanged.
888 [ + + ]: 4 : for (const CAmount parent_value : {ABSENT, SPENT, VALUE1})
889 [ + + ]: 12 : for (const CAmount child_value : {ABSENT, SPENT, VALUE2})
890 [ + + + + ]: 42 : for (const char parent_flags : parent_value == ABSENT ? ABSENT_FLAGS : FLAGS)
891 [ + + + + ]: 90 : for (const char child_flags : child_value == ABSENT ? ABSENT_FLAGS : CLEAN_FLAGS)
892 : 45 : CheckWriteCoins(parent_value, child_value, parent_value, parent_flags, child_flags, parent_flags);
893 : 1 : }
894 : :
895 : :
896 : 2 : struct FlushTest : BasicTestingSetup {
897 : 12 : Coin MakeCoin()
898 : : {
899 : 12 : Coin coin;
900 : 12 : coin.out.nValue = m_rng.rand32();
901 : 12 : coin.nHeight = m_rng.randrange(4096);
902 : 12 : coin.fCoinBase = 0;
903 : 12 : return coin;
904 : : }
905 : :
906 : :
907 : : //! For CCoinsViewCache instances backed by either another cache instance or
908 : : //! leveldb, test cache behavior and flag state (DIRTY/FRESH) by
909 : : //!
910 : : //! 1. Adding a random coin to the child-most cache,
911 : : //! 2. Flushing all caches (without erasing),
912 : : //! 3. Ensure the entry still exists in the cache and has been written to parent,
913 : : //! 4. (if `do_erasing_flush`) Flushing the caches again (with erasing),
914 : : //! 5. (if `do_erasing_flush`) Ensure the entry has been written to the parent and is no longer in the cache,
915 : : //! 6. Spend the coin, ensure it no longer exists in the parent.
916 : : //!
917 : 4 : void TestFlushBehavior(
918 : : CCoinsViewCacheTest* view,
919 : : CCoinsViewDB& base,
920 : : std::vector<std::unique_ptr<CCoinsViewCacheTest>>& all_caches,
921 : : bool do_erasing_flush)
922 : : {
923 : 4 : CAmount value;
924 : 4 : char flags;
925 : 4 : size_t cache_usage;
926 : 4 : size_t cache_size;
927 : :
928 : 22 : auto flush_all = [this, &all_caches](bool erase) {
929 : : // Flush in reverse order to ensure that flushes happen from children up.
930 [ + + ]: 54 : for (auto i = all_caches.rbegin(); i != all_caches.rend(); ++i) {
931 : 36 : auto& cache = *i;
932 : 36 : cache->SanityCheck();
933 : : // hashBlock must be filled before flushing to disk; value is
934 : : // unimportant here. This is normally done during connect/disconnect block.
935 : 36 : cache->SetBestBlock(m_rng.rand256());
936 [ + + ]: 36 : erase ? cache->Flush() : cache->Sync();
937 : : }
938 : 22 : };
939 : :
940 : 4 : Txid txid = Txid::FromUint256(m_rng.rand256());
941 : 4 : COutPoint outp = COutPoint(txid, 0);
942 : 4 : Coin coin = MakeCoin();
943 : : // Ensure the coins views haven't seen this coin before.
944 [ + - + - : 8 : BOOST_CHECK(!base.HaveCoin(outp));
+ - + - ]
945 [ + - + - : 8 : BOOST_CHECK(!view->HaveCoin(outp));
+ - ]
946 : :
947 : : // --- 1. Adding a random coin to the child cache
948 : : //
949 [ + - ]: 4 : view->AddCoin(outp, Coin(coin), false);
950 : :
951 [ + - ]: 4 : cache_usage = view->DynamicMemoryUsage();
952 [ + - ]: 4 : cache_size = view->map().size();
953 : :
954 : : // `base` shouldn't have coin (no flush yet) but `view` should have cached it.
955 [ + - + - : 8 : BOOST_CHECK(!base.HaveCoin(outp));
+ - + - ]
956 [ + - + - : 8 : BOOST_CHECK(view->HaveCoin(outp));
+ - ]
957 : :
958 : 4 : GetCoinsMapEntry(view->map(), value, flags, outp);
959 [ + - + - ]: 4 : BOOST_CHECK_EQUAL(value, coin.out.nValue);
960 [ + - + - ]: 4 : BOOST_CHECK_EQUAL(flags, DIRTY|FRESH);
961 : :
962 : : // --- 2. Flushing all caches (without erasing)
963 : : //
964 [ + - ]: 4 : flush_all(/*erase=*/ false);
965 : :
966 : : // CoinsMap usage should be unchanged since we didn't erase anything.
967 [ + - + - : 4 : BOOST_CHECK_EQUAL(cache_usage, view->DynamicMemoryUsage());
+ - ]
968 [ + - + - ]: 4 : BOOST_CHECK_EQUAL(cache_size, view->map().size());
969 : :
970 : : // --- 3. Ensuring the entry still exists in the cache and has been written to parent
971 : : //
972 : 4 : GetCoinsMapEntry(view->map(), value, flags, outp);
973 [ + - + - ]: 4 : BOOST_CHECK_EQUAL(value, coin.out.nValue);
974 [ + - + - ]: 4 : BOOST_CHECK_EQUAL(flags, 0); // Flags should have been wiped.
975 : :
976 : : // Both views should now have the coin.
977 [ + - + - : 8 : BOOST_CHECK(base.HaveCoin(outp));
+ - + - ]
978 [ + - + - : 8 : BOOST_CHECK(view->HaveCoin(outp));
+ - + + ]
979 : :
980 [ + + ]: 4 : if (do_erasing_flush) {
981 : : // --- 4. Flushing the caches again (with erasing)
982 : : //
983 [ + - ]: 2 : flush_all(/*erase=*/ true);
984 : :
985 : : // Memory does not necessarily go down due to the map using a memory pool
986 [ + - + - : 4 : BOOST_TEST(view->DynamicMemoryUsage() <= cache_usage);
+ - + - +
- ]
987 : : // Size of the cache must go down though
988 [ + - + - : 4 : BOOST_TEST(view->map().size() < cache_size);
+ - ]
989 : :
990 : : // --- 5. Ensuring the entry is no longer in the cache
991 : : //
992 : 2 : GetCoinsMapEntry(view->map(), value, flags, outp);
993 [ + - + - ]: 2 : BOOST_CHECK_EQUAL(value, ABSENT);
994 [ + - + - ]: 2 : BOOST_CHECK_EQUAL(flags, NO_ENTRY);
995 : :
996 [ + - ]: 2 : view->AccessCoin(outp);
997 : 2 : GetCoinsMapEntry(view->map(), value, flags, outp);
998 [ + - + - ]: 2 : BOOST_CHECK_EQUAL(value, coin.out.nValue);
999 [ + - + - ]: 2 : BOOST_CHECK_EQUAL(flags, 0);
1000 : : }
1001 : :
1002 : : // Can't overwrite an entry without specifying that an overwrite is
1003 : : // expected.
1004 [ + - - + : 12 : BOOST_CHECK_THROW(
- - - - -
+ + - +
- ]
1005 : : view->AddCoin(outp, Coin(coin), /*possible_overwrite=*/ false),
1006 : : std::logic_error);
1007 : :
1008 : : // --- 6. Spend the coin.
1009 : : //
1010 [ + - + - : 8 : BOOST_CHECK(view->SpendCoin(outp));
+ - ]
1011 : :
1012 : : // The coin should be in the cache, but spent and marked dirty.
1013 : 4 : GetCoinsMapEntry(view->map(), value, flags, outp);
1014 [ + - + - ]: 4 : BOOST_CHECK_EQUAL(value, SPENT);
1015 [ + - + - ]: 4 : BOOST_CHECK_EQUAL(flags, DIRTY);
1016 [ + - + - : 8 : BOOST_CHECK(!view->HaveCoin(outp)); // Coin should be considered spent in `view`.
+ - + - ]
1017 [ + - + - : 8 : BOOST_CHECK(base.HaveCoin(outp)); // But coin should still be unspent in `base`.
+ - + - ]
1018 : :
1019 [ + - ]: 4 : flush_all(/*erase=*/ false);
1020 : :
1021 : : // Coin should be considered spent in both views.
1022 [ + - + - : 8 : BOOST_CHECK(!view->HaveCoin(outp));
+ - + - ]
1023 [ + - + - : 8 : BOOST_CHECK(!base.HaveCoin(outp));
+ - + - ]
1024 : :
1025 : : // Spent coin should not be spendable.
1026 [ + - + - : 8 : BOOST_CHECK(!view->SpendCoin(outp));
+ - ]
1027 : :
1028 : : // --- Bonus check: ensure that a coin added to the base view via one cache
1029 : : // can be spent by another cache which has never seen it.
1030 : : //
1031 : 4 : txid = Txid::FromUint256(m_rng.rand256());
1032 : 4 : outp = COutPoint(txid, 0);
1033 : 4 : coin = MakeCoin();
1034 [ + - + - : 8 : BOOST_CHECK(!base.HaveCoin(outp));
+ - + - ]
1035 [ + - + - : 8 : BOOST_CHECK(!all_caches[0]->HaveCoin(outp));
+ - + - ]
1036 [ + - + - : 8 : BOOST_CHECK(!all_caches[1]->HaveCoin(outp));
+ - + - ]
1037 : :
1038 [ + - ]: 4 : all_caches[0]->AddCoin(outp, std::move(coin), false);
1039 [ + - ]: 4 : all_caches[0]->Sync();
1040 [ + - + - : 8 : BOOST_CHECK(base.HaveCoin(outp));
+ - + - ]
1041 [ + - + - : 8 : BOOST_CHECK(all_caches[0]->HaveCoin(outp));
+ - + - ]
1042 [ + - + - : 8 : BOOST_CHECK(!all_caches[1]->HaveCoinInCache(outp));
+ - + - ]
1043 : :
1044 [ + - + - : 8 : BOOST_CHECK(all_caches[1]->SpendCoin(outp));
+ - + - ]
1045 [ + - ]: 4 : flush_all(/*erase=*/ false);
1046 [ + - + - : 8 : BOOST_CHECK(!base.HaveCoin(outp));
+ - + - ]
1047 [ + - + - : 8 : BOOST_CHECK(!all_caches[0]->HaveCoin(outp));
+ - + - ]
1048 [ + - + - : 8 : BOOST_CHECK(!all_caches[1]->HaveCoin(outp));
+ - + - ]
1049 : :
1050 [ + - ]: 4 : flush_all(/*erase=*/ true); // Erase all cache content.
1051 : :
1052 : : // --- Bonus check 2: ensure that a FRESH, spent coin is deleted by Sync()
1053 : : //
1054 : 4 : txid = Txid::FromUint256(m_rng.rand256());
1055 : 4 : outp = COutPoint(txid, 0);
1056 : 4 : coin = MakeCoin();
1057 : 4 : CAmount coin_val = coin.out.nValue;
1058 [ + - + - : 8 : BOOST_CHECK(!base.HaveCoin(outp));
+ - + - ]
1059 [ + - + - : 8 : BOOST_CHECK(!all_caches[0]->HaveCoin(outp));
+ - + - ]
1060 [ + - + - : 8 : BOOST_CHECK(!all_caches[1]->HaveCoin(outp));
+ - + - ]
1061 : :
1062 : : // Add and spend from same cache without flushing.
1063 [ + - ]: 4 : all_caches[0]->AddCoin(outp, std::move(coin), false);
1064 : :
1065 : : // Coin should be FRESH in the cache.
1066 : 4 : GetCoinsMapEntry(all_caches[0]->map(), value, flags, outp);
1067 [ + - + - ]: 4 : BOOST_CHECK_EQUAL(value, coin_val);
1068 [ + - + - ]: 4 : BOOST_CHECK_EQUAL(flags, DIRTY|FRESH);
1069 : :
1070 : : // Base shouldn't have seen coin.
1071 [ + - + - : 8 : BOOST_CHECK(!base.HaveCoin(outp));
+ - + - ]
1072 : :
1073 [ + - + - : 8 : BOOST_CHECK(all_caches[0]->SpendCoin(outp));
+ - + - ]
1074 [ + - ]: 4 : all_caches[0]->Sync();
1075 : :
1076 : : // Ensure there is no sign of the coin after spend/flush.
1077 : 4 : GetCoinsMapEntry(all_caches[0]->map(), value, flags, outp);
1078 [ + - + - ]: 4 : BOOST_CHECK_EQUAL(value, ABSENT);
1079 [ + - + - ]: 4 : BOOST_CHECK_EQUAL(flags, NO_ENTRY);
1080 [ + - + - : 8 : BOOST_CHECK(!all_caches[0]->HaveCoinInCache(outp));
+ - + - ]
1081 [ + - + - : 8 : BOOST_CHECK(!base.HaveCoin(outp));
+ - ]
1082 : 4 : }
1083 : : }; // struct FlushTest
1084 : :
1085 [ + - + - : 7 : BOOST_FIXTURE_TEST_CASE(ccoins_flush_behavior, FlushTest)
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
1086 : : {
1087 : : // Create two in-memory caches atop a leveldb view.
1088 : 0 : CCoinsViewDB base{{.path = "test", .cache_bytes = 1 << 23, .memory_only = true}, {}};
1089 : 1 : std::vector<std::unique_ptr<CCoinsViewCacheTest>> caches;
1090 [ + - ]: 2 : caches.push_back(std::make_unique<CCoinsViewCacheTest>(&base));
1091 [ + - ]: 2 : caches.push_back(std::make_unique<CCoinsViewCacheTest>(caches.back().get()));
1092 : :
1093 [ + + ]: 3 : for (const auto& view : caches) {
1094 [ + - ]: 2 : TestFlushBehavior(view.get(), base, caches, /*do_erasing_flush=*/false);
1095 [ + - ]: 2 : TestFlushBehavior(view.get(), base, caches, /*do_erasing_flush=*/true);
1096 : : }
1097 [ + - ]: 2 : }
1098 : :
1099 [ + - + - : 7 : BOOST_AUTO_TEST_CASE(coins_resource_is_used)
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
1100 : : {
1101 : 1 : CCoinsMapMemoryResource resource;
1102 [ + - ]: 1 : PoolResourceTester::CheckAllDataAccountedFor(resource);
1103 : :
1104 : 1 : {
1105 [ + - + - ]: 1 : CCoinsMap map{0, CCoinsMap::hasher{}, CCoinsMap::key_equal{}, &resource};
1106 [ + - + - : 2 : BOOST_TEST(memusage::DynamicUsage(map) >= resource.ChunkSizeBytes());
+ - + - ]
1107 : :
1108 [ + - ]: 1 : map.reserve(1000);
1109 : :
1110 : : // The resource has preallocated a chunk, so we should have space for at several nodes without the need to allocate anything else.
1111 : 1 : const auto usage_before = memusage::DynamicUsage(map);
1112 : :
1113 : 1 : COutPoint out_point{};
1114 [ + + ]: 1001 : for (size_t i = 0; i < 1000; ++i) {
1115 : 1000 : out_point.n = i;
1116 [ + - ]: 1000 : map[out_point];
1117 : : }
1118 [ + - + - : 2 : BOOST_TEST(usage_before == memusage::DynamicUsage(map));
+ - ]
1119 : 0 : }
1120 : :
1121 [ + - ]: 1 : PoolResourceTester::CheckAllDataAccountedFor(resource);
1122 : 1 : }
1123 : :
1124 : : BOOST_AUTO_TEST_SUITE_END()
|
