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