Inside Bitcoin

751     */
752    for (auto base_value : {ABSENT, SPENT, VALUE1}) {
753        CheckAddCoin(base_value, MISSING,            VALUE3, VALUE3_DIRTY_FRESH,   false);
754        CheckAddCoin(base_value, MISSING,            VALUE3, VALUE3_DIRTY,         true );
755
756        CheckAddCoin(base_value, SPENT_CLEAN,        VALUE3, VALUE3_DIRTY_FRESH,   false);
757        CheckAddCoin(base_value, SPENT_CLEAN,        VALUE3, VALUE3_DIRTY,         true );
758        CheckAddCoin(base_value, SPENT_FRESH,        VALUE3, VALUE3_DIRTY_FRESH,   false);
759        CheckAddCoin(base_value, SPENT_FRESH,        VALUE3, VALUE3_DIRTY_FRESH,   true );
760        CheckAddCoin(base_value, SPENT_DIRTY,        VALUE3, VALUE3_DIRTY,         false);
761        CheckAddCoin(base_value, SPENT_DIRTY,        VALUE3, VALUE3_DIRTY,         true );
762        CheckAddCoin(base_value, SPENT_DIRTY_FRESH,  VALUE3, VALUE3_DIRTY_FRESH,   false);
763        CheckAddCoin(base_value, SPENT_DIRTY_FRESH,  VALUE3, VALUE3_DIRTY_FRESH,   true );
764
765        CheckAddCoin(base_value, VALUE2_CLEAN,       VALUE3, EX_OVERWRITE_UNSPENT, false);
766        CheckAddCoin(base_value, VALUE2_CLEAN,       VALUE3, VALUE3_DIRTY,         true );
767        CheckAddCoin(base_value, VALUE2_FRESH,       VALUE3, EX_OVERWRITE_UNSPENT, false);
768        CheckAddCoin(base_value, VALUE2_FRESH,       VALUE3, VALUE3_DIRTY_FRESH,   true );
769        CheckAddCoin(base_value, VALUE2_DIRTY,       VALUE3, EX_OVERWRITE_UNSPENT, false);
770        CheckAddCoin(base_value, VALUE2_DIRTY,       VALUE3, VALUE3_DIRTY,         true );
771        CheckAddCoin(base_value, VALUE2_DIRTY_FRESH, VALUE3, EX_OVERWRITE_UNSPENT, false);
772        CheckAddCoin(base_value, VALUE2_DIRTY_FRESH, VALUE3, VALUE3_DIRTY_FRESH,   true );
773    }
774}
775
776static void CheckWriteCoins(const MaybeCoin& parent, const MaybeCoin& child, const CoinOrError& expected)
777{
778    SingleEntryCacheTest test{ABSENT, parent};
779    auto write_coins{[&] { WriteCoinsViewEntry(test.cache, child); }};
780    if (auto* expected_coin{std::get_if<MaybeCoin>(&expected)}) {
781        write_coins();
782        test.cache.SelfTest(/*sanity_check=*/false);
783        BOOST_CHECK_EQUAL(GetCoinsMapEntry(test.cache.map()), *expected_coin);
784    } else {
785        BOOST_CHECK_EXCEPTION(write_coins(), std::logic_error, HasReason(std::get<std::string>(expected)));
786    }
787}
788
789BOOST_AUTO_TEST_CASE(ccoins_write)
790{
791    /* Check BatchWrite behavior, flushing one entry from a child cache to a
792     * parent cache, and checking the resulting entry in the parent cache
793     * after the write.
794     *              Parent              Child               Expected
795     */
796    CheckWriteCoins(MISSING,            MISSING,            MISSING            );
797    CheckWriteCoins(MISSING,            SPENT_DIRTY,        SPENT_DIRTY        );
798    CheckWriteCoins(MISSING,            SPENT_DIRTY_FRESH,  MISSING            );
799    CheckWriteCoins(MISSING,            VALUE2_DIRTY,       VALUE2_DIRTY       );
800    CheckWriteCoins(MISSING,            VALUE2_DIRTY_FRESH, VALUE2_DIRTY_FRESH );
801    CheckWriteCoins(SPENT_CLEAN,        MISSING,            SPENT_CLEAN        );
802    CheckWriteCoins(SPENT_FRESH,        MISSING,            SPENT_FRESH        );
803    CheckWriteCoins(SPENT_DIRTY,        MISSING,            SPENT_DIRTY        );
804    CheckWriteCoins(SPENT_DIRTY_FRESH,  MISSING,            SPENT_DIRTY_FRESH  );
805
806    CheckWriteCoins(SPENT_CLEAN,        SPENT_DIRTY,        SPENT_DIRTY        );
807    CheckWriteCoins(SPENT_CLEAN,        SPENT_DIRTY_FRESH,  SPENT_DIRTY        );
808    CheckWriteCoins(SPENT_FRESH,        SPENT_DIRTY,        MISSING            );
809    CheckWriteCoins(SPENT_FRESH,        SPENT_DIRTY_FRESH,  MISSING            );
810    CheckWriteCoins(SPENT_DIRTY,        SPENT_DIRTY,        SPENT_DIRTY        );
811    CheckWriteCoins(SPENT_DIRTY,        SPENT_DIRTY_FRESH,  SPENT_DIRTY        );
812    CheckWriteCoins(SPENT_DIRTY_FRESH,  SPENT_DIRTY,        MISSING            );
813    CheckWriteCoins(SPENT_DIRTY_FRESH,  SPENT_DIRTY_FRESH,  MISSING            );
814
815    CheckWriteCoins(SPENT_CLEAN,        VALUE2_DIRTY,       VALUE2_DIRTY       );
816    CheckWriteCoins(SPENT_CLEAN,        VALUE2_DIRTY_FRESH, VALUE2_DIRTY       );
817    CheckWriteCoins(SPENT_FRESH,        VALUE2_DIRTY,       VALUE2_DIRTY_FRESH );
818    CheckWriteCoins(SPENT_FRESH,        VALUE2_DIRTY_FRESH, VALUE2_DIRTY_FRESH );
819    CheckWriteCoins(SPENT_DIRTY,        VALUE2_DIRTY,       VALUE2_DIRTY       );
820    CheckWriteCoins(SPENT_DIRTY,        VALUE2_DIRTY_FRESH, VALUE2_DIRTY       );
821    CheckWriteCoins(SPENT_DIRTY_FRESH,  VALUE2_DIRTY,       VALUE2_DIRTY_FRESH );
822    CheckWriteCoins(SPENT_DIRTY_FRESH,  VALUE2_DIRTY_FRESH, VALUE2_DIRTY_FRESH );
823
824    CheckWriteCoins(VALUE1_CLEAN,       MISSING,            VALUE1_CLEAN       );
825    CheckWriteCoins(VALUE1_FRESH,       MISSING,            VALUE1_FRESH       );
826    CheckWriteCoins(VALUE1_DIRTY,       MISSING,            VALUE1_DIRTY       );
827    CheckWriteCoins(VALUE1_DIRTY_FRESH, MISSING,            VALUE1_DIRTY_FRESH );
828    CheckWriteCoins(VALUE1_CLEAN,       SPENT_DIRTY,        SPENT_DIRTY        );
829    CheckWriteCoins(VALUE1_CLEAN,       SPENT_DIRTY_FRESH,  EX_FRESH_MISAPPLIED);
830    CheckWriteCoins(VALUE1_FRESH,       SPENT_DIRTY,        MISSING            );
831    CheckWriteCoins(VALUE1_FRESH,       SPENT_DIRTY_FRESH,  EX_FRESH_MISAPPLIED);
832    CheckWriteCoins(VALUE1_DIRTY,       SPENT_DIRTY,        SPENT_DIRTY        );
833    CheckWriteCoins(VALUE1_DIRTY,       SPENT_DIRTY_FRESH,  EX_FRESH_MISAPPLIED);
834    CheckWriteCoins(VALUE1_DIRTY_FRESH, SPENT_DIRTY,        MISSING            );
835    CheckWriteCoins(VALUE1_DIRTY_FRESH, SPENT_DIRTY_FRESH,  EX_FRESH_MISAPPLIED);
836
837    CheckWriteCoins(VALUE1_CLEAN,       VALUE2_DIRTY,       VALUE2_DIRTY       );
838    CheckWriteCoins(VALUE1_CLEAN,       VALUE2_DIRTY_FRESH, EX_FRESH_MISAPPLIED);
839    CheckWriteCoins(VALUE1_FRESH,       VALUE2_DIRTY,       VALUE2_DIRTY_FRESH );
840    CheckWriteCoins(VALUE1_FRESH,       VALUE2_DIRTY_FRESH, EX_FRESH_MISAPPLIED);
841    CheckWriteCoins(VALUE1_DIRTY,       VALUE2_DIRTY,       VALUE2_DIRTY       );
842    CheckWriteCoins(VALUE1_DIRTY,       VALUE2_DIRTY_FRESH, EX_FRESH_MISAPPLIED);
843    CheckWriteCoins(VALUE1_DIRTY_FRESH, VALUE2_DIRTY,       VALUE2_DIRTY_FRESH );
844    CheckWriteCoins(VALUE1_DIRTY_FRESH, VALUE2_DIRTY_FRESH, EX_FRESH_MISAPPLIED);
845
846    // The checks above omit cases where the child state is not DIRTY, since
847    // they would be too repetitive (the parent cache is never updated in these
848    // cases). The loop below covers these cases and makes sure the parent cache
849    // is always left unchanged.
850    for (const MaybeCoin& parent : {MISSING,
851                                    SPENT_CLEAN, SPENT_DIRTY, SPENT_FRESH, SPENT_DIRTY_FRESH,
852                                    VALUE1_CLEAN, VALUE1_DIRTY, VALUE1_FRESH, VALUE1_DIRTY_FRESH}) {
853        for (const MaybeCoin& child : {MISSING,
854                                       SPENT_CLEAN, SPENT_FRESH,
855                                       VALUE2_CLEAN, VALUE2_FRESH}) {
856            auto expected{CoinOrError{parent}}; // TODO test failure cases as well
857            CheckWriteCoins(parent, child, expected);
858        }
859    }
860}
861
862struct FlushTest : BasicTestingSetup {
863Coin MakeCoin()
864{
865    Coin coin;
866    coin.out.nValue = m_rng.rand32();
867    coin.nHeight = m_rng.randrange(4096);
868    coin.fCoinBase = false;
869    return coin;
870}
871
872
873//! For CCoinsViewCache instances backed by either another cache instance or
874//! leveldb, test cache behavior and flag state (DIRTY/FRESH) by
875//!
876//! 1. Adding a random coin to the child-most cache,
877//! 2. Flushing all caches (without erasing),
878//! 3. Ensure the entry still exists in the cache and has been written to parent,
879//! 4. (if `do_erasing_flush`) Flushing the caches again (with erasing),
880//! 5. (if `do_erasing_flush`) Ensure the entry has been written to the parent and is no longer in the cache,
881//! 6. Spend the coin, ensure it no longer exists in the parent.
882//!
883void TestFlushBehavior(
884    CCoinsViewCacheTest* view,
885    CCoinsViewDB& base,
886    std::vector<std::unique_ptr<CCoinsViewCacheTest>>& all_caches,
887    bool do_erasing_flush)
888{
889    size_t cache_usage;
890    size_t cache_size;
891
892    auto flush_all = [this, &all_caches](bool erase) {
893        // Flush in reverse order to ensure that flushes happen from children up.
894        for (auto i = all_caches.rbegin(); i != all_caches.rend(); ++i) {
895            auto& cache = *i;
896            cache->SanityCheck();
897            // block_hash must be filled before flushing to disk; value is
898            // unimportant here. This is normally done during connect/disconnect block.
899            cache->SetBestBlock(m_rng.rand256());
900            erase ? cache->Flush() : cache->Sync();
901        }
902    };
903
904    Txid txid = Txid::FromUint256(m_rng.rand256());
905    COutPoint outp = COutPoint(txid, 0);
906    Coin coin = MakeCoin();
907    // Ensure the coins views haven't seen this coin before.
908    BOOST_CHECK(!base.HaveCoin(outp));
909    BOOST_CHECK(!view->HaveCoin(outp));
910
911    // --- 1. Adding a random coin to the child cache
912    //
913    view->AddCoin(outp, Coin(coin), false);
914
915    cache_usage = view->DynamicMemoryUsage();
916    cache_size = view->map().size();
917
918    // `base` shouldn't have coin (no flush yet) but `view` should have cached it.
919    BOOST_CHECK(!base.HaveCoin(outp));
920    BOOST_CHECK(view->HaveCoin(outp));
921
922    BOOST_CHECK_EQUAL(GetCoinsMapEntry(view->map(), outp), CoinEntry(coin.out.nValue, CoinEntry::State::DIRTY_FRESH));
923
924    // --- 2. Flushing all caches (without erasing)
925    //
926    flush_all(/*erase=*/ false);
927
928    // CoinsMap usage should be unchanged since we didn't erase anything.
929    BOOST_CHECK_EQUAL(cache_usage, view->DynamicMemoryUsage());
930    BOOST_CHECK_EQUAL(cache_size, view->map().size());
931
932    // --- 3. Ensuring the entry still exists in the cache and has been written to parent
933    //
934    BOOST_CHECK_EQUAL(GetCoinsMapEntry(view->map(), outp), CoinEntry(coin.out.nValue, CoinEntry::State::CLEAN)); // State should have been wiped.
935
936    // Both views should now have the coin.
937    BOOST_CHECK(base.HaveCoin(outp));
938    BOOST_CHECK(view->HaveCoin(outp));
939
940    if (do_erasing_flush) {
941        // --- 4. Flushing the caches again (with erasing)
942        //
943        flush_all(/*erase=*/ true);
944
945        // Memory does not necessarily go down due to the map using a memory pool
946        BOOST_TEST(view->DynamicMemoryUsage() <= cache_usage);
947        // Size of the cache must go down though
948        BOOST_TEST(view->map().size() < cache_size);
949
950        // --- 5. Ensuring the entry is no longer in the cache
951        //
952        BOOST_CHECK(!GetCoinsMapEntry(view->map(), outp));
953        view->AccessCoin(outp);
954        BOOST_CHECK_EQUAL(GetCoinsMapEntry(view->map(), outp), CoinEntry(coin.out.nValue, CoinEntry::State::CLEAN));
955    }
956
957    // Can't overwrite an entry without specifying that an overwrite is
958    // expected.
959    BOOST_CHECK_THROW(
960        view->AddCoin(outp, Coin(coin), /*possible_overwrite=*/ false),
961        std::logic_error);
962
963    // --- 6. Spend the coin.
964    //
965    BOOST_CHECK(view->SpendCoin(outp));
966
967    // The coin should be in the cache, but spent and marked dirty.
968    BOOST_CHECK_EQUAL(GetCoinsMapEntry(view->map(), outp), SPENT_DIRTY);
969    BOOST_CHECK(!view->HaveCoin(outp)); // Coin should be considered spent in `view`.
970    BOOST_CHECK(base.HaveCoin(outp));  // But coin should still be unspent in `base`.
971
972    flush_all(/*erase=*/ false);
973
974    // Coin should be considered spent in both views.
975    BOOST_CHECK(!view->HaveCoin(outp));
976    BOOST_CHECK(!base.HaveCoin(outp));
977
978    // Spent coin should not be spendable.
979    BOOST_CHECK(!view->SpendCoin(outp));
980
981    // --- Bonus check: ensure that a coin added to the base view via one cache
982    //     can be spent by another cache which has never seen it.
983    //
984    txid = Txid::FromUint256(m_rng.rand256());
985    outp = COutPoint(txid, 0);
986    coin = MakeCoin();
987    BOOST_CHECK(!base.HaveCoin(outp));
988    BOOST_CHECK(!all_caches[0]->HaveCoin(outp));
989    BOOST_CHECK(!all_caches[1]->HaveCoin(outp));
990
991    all_caches[0]->AddCoin(outp, std::move(coin), false);
992    all_caches[0]->Sync();
993    BOOST_CHECK(base.HaveCoin(outp));
994    BOOST_CHECK(all_caches[0]->HaveCoin(outp));
995    BOOST_CHECK(!all_caches[1]->HaveCoinInCache(outp));
996
997    BOOST_CHECK(all_caches[1]->SpendCoin(outp));
998    flush_all(/*erase=*/ false);
999    BOOST_CHECK(!base.HaveCoin(outp));
1000    BOOST_CHECK(!all_caches[0]->HaveCoin(outp));