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