From 1d184d53e1d2768837e42a973336b2aab94c9c58 Mon Sep 17 00:00:00 2001 From: Sean Bowe Date: Thu, 14 Jul 2016 16:51:36 -0600 Subject: [PATCH] Rename cacheSerials to cacheNullifiers and fix tests. --- src/coins.cpp | 20 ++++++++++---------- src/coins.h | 2 +- src/gtest/test_checktransaction.cpp | 20 ++++++++++---------- src/test/coins_tests.cpp | 2 +- 4 files changed, 22 insertions(+), 22 deletions(-) diff --git a/src/coins.cpp b/src/coins.cpp index 71893e895..f7a205bb8 100644 --- a/src/coins.cpp +++ b/src/coins.cpp @@ -82,7 +82,7 @@ CCoinsViewCache::~CCoinsViewCache() size_t CCoinsViewCache::DynamicMemoryUsage() const { return memusage::DynamicUsage(cacheCoins) + memusage::DynamicUsage(cacheAnchors) + - memusage::DynamicUsage(cacheSerials) + + memusage::DynamicUsage(cacheNullifiers) + cachedCoinsUsage; } @@ -129,15 +129,15 @@ bool CCoinsViewCache::GetAnchorAt(const uint256 &rt, ZCIncrementalMerkleTree &tr } bool CCoinsViewCache::GetNullifier(const uint256 &serial) const { - CNullifiersMap::iterator it = cacheSerials.find(serial); - if (it != cacheSerials.end()) + CNullifiersMap::iterator it = cacheNullifiers.find(serial); + if (it != cacheNullifiers.end()) return it->second.entered; CSerialsCacheEntry entry; bool tmp = base->GetNullifier(serial); entry.entered = tmp; - cacheSerials.insert(std::make_pair(serial, entry)); + cacheNullifiers.insert(std::make_pair(serial, entry)); return tmp; } @@ -186,7 +186,7 @@ void CCoinsViewCache::PopAnchor(const uint256 &newrt) { } void CCoinsViewCache::SetNullifier(const uint256 &serial, bool spent) { - std::pair ret = cacheSerials.insert(std::make_pair(serial, CSerialsCacheEntry())); + std::pair ret = cacheNullifiers.insert(std::make_pair(serial, CSerialsCacheEntry())); ret.first->second.entered = spent; ret.first->second.flags |= CSerialsCacheEntry::DIRTY; } @@ -329,14 +329,14 @@ bool CCoinsViewCache::BatchWrite(CCoinsMap &mapCoins, for (CNullifiersMap::iterator child_it = mapNullifiers.begin(); child_it != mapNullifiers.end();) { if (child_it->second.flags & CSerialsCacheEntry::DIRTY) { // Ignore non-dirty entries (optimization). - CNullifiersMap::iterator parent_it = cacheSerials.find(child_it->first); + CNullifiersMap::iterator parent_it = cacheNullifiers.find(child_it->first); - if (parent_it == cacheSerials.end()) { + if (parent_it == cacheNullifiers.end()) { if (child_it->second.entered) { // Parent doesn't have an entry, but child has a SPENT serial. // Move the spent serial up. - CSerialsCacheEntry& entry = cacheSerials[child_it->first]; + CSerialsCacheEntry& entry = cacheNullifiers[child_it->first]; entry.entered = true; entry.flags = CSerialsCacheEntry::DIRTY; } @@ -357,10 +357,10 @@ bool CCoinsViewCache::BatchWrite(CCoinsMap &mapCoins, } bool CCoinsViewCache::Flush() { - bool fOk = base->BatchWrite(cacheCoins, hashBlock, hashAnchor, cacheAnchors, cacheSerials); + bool fOk = base->BatchWrite(cacheCoins, hashBlock, hashAnchor, cacheAnchors, cacheNullifiers); cacheCoins.clear(); cacheAnchors.clear(); - cacheSerials.clear(); + cacheNullifiers.clear(); cachedCoinsUsage = 0; return fOk; } diff --git a/src/coins.h b/src/coins.h index cd8cc7bdf..f92529f4b 100644 --- a/src/coins.h +++ b/src/coins.h @@ -440,7 +440,7 @@ protected: mutable CCoinsMap cacheCoins; mutable uint256 hashAnchor; mutable CAnchorsMap cacheAnchors; - mutable CNullifiersMap cacheSerials; + mutable CNullifiersMap cacheNullifiers; /* Cached dynamic memory usage for the inner CCoins objects. */ mutable size_t cachedCoinsUsage; diff --git a/src/gtest/test_checktransaction.cpp b/src/gtest/test_checktransaction.cpp index 7b97511fd..be45eb97d 100644 --- a/src/gtest/test_checktransaction.cpp +++ b/src/gtest/test_checktransaction.cpp @@ -11,15 +11,15 @@ TEST(checktransaction_tests, check_vpub_not_both_nonzero) { tx.nVersion = 2; { - // Ensure that values within the pour are well-formed. + // Ensure that values within the joinsplit are well-formed. CMutableTransaction newTx(tx); CValidationState state; newTx.vjoinsplit.push_back(JSDescription()); - JSDescription *pourtx = &newTx.vjoinsplit[0]; - pourtx->vpub_old = 1; - pourtx->vpub_new = 1; + JSDescription *jsdesc = &newTx.vjoinsplit[0]; + jsdesc->vpub_old = 1; + jsdesc->vpub_new = 1; EXPECT_FALSE(CheckTransactionWithoutProofVerification(newTx, state)); EXPECT_EQ(state.GetRejectReason(), "bad-txns-vpubs-both-nonzero"); @@ -248,7 +248,7 @@ TEST(checktransaction_tests, bad_txns_inputs_duplicate) { CheckTransactionWithoutProofVerification(tx, state); } -TEST(checktransaction_tests, bad_pours_nullifiers_duplicate_same_pour) { +TEST(checktransaction_tests, bad_joinsplits_nullifiers_duplicate_same_joinsplit) { CMutableTransaction mtx = GetValidTransaction(); mtx.vjoinsplit[0].nullifiers.at(0) = uint256S("0000000000000000000000000000000000000000000000000000000000000000"); mtx.vjoinsplit[0].nullifiers.at(1) = uint256S("0000000000000000000000000000000000000000000000000000000000000000"); @@ -256,11 +256,11 @@ TEST(checktransaction_tests, bad_pours_nullifiers_duplicate_same_pour) { CTransaction tx(mtx); MockCValidationState state; - EXPECT_CALL(state, DoS(100, false, REJECT_INVALID, "bad-pours-nullifiers-duplicate", false)).Times(1); + EXPECT_CALL(state, DoS(100, false, REJECT_INVALID, "bad-joinsplits-nullifiers-duplicate", false)).Times(1); CheckTransactionWithoutProofVerification(tx, state); } -TEST(checktransaction_tests, bad_pours_nullifiers_duplicate_different_pour) { +TEST(checktransaction_tests, bad_joinsplits_nullifiers_duplicate_different_joinsplit) { CMutableTransaction mtx = GetValidTransaction(); mtx.vjoinsplit[0].nullifiers.at(0) = uint256S("0000000000000000000000000000000000000000000000000000000000000000"); mtx.vjoinsplit[1].nullifiers.at(0) = uint256S("0000000000000000000000000000000000000000000000000000000000000000"); @@ -268,11 +268,11 @@ TEST(checktransaction_tests, bad_pours_nullifiers_duplicate_different_pour) { CTransaction tx(mtx); MockCValidationState state; - EXPECT_CALL(state, DoS(100, false, REJECT_INVALID, "bad-pours-nullifiers-duplicate", false)).Times(1); + EXPECT_CALL(state, DoS(100, false, REJECT_INVALID, "bad-joinsplits-nullifiers-duplicate", false)).Times(1); CheckTransactionWithoutProofVerification(tx, state); } -TEST(checktransaction_tests, bad_cb_has_pours) { +TEST(checktransaction_tests, bad_cb_has_joinsplits) { CMutableTransaction mtx = GetValidTransaction(); // Make it a coinbase. mtx.vin.resize(1); @@ -284,7 +284,7 @@ TEST(checktransaction_tests, bad_cb_has_pours) { EXPECT_TRUE(tx.IsCoinBase()); MockCValidationState state; - EXPECT_CALL(state, DoS(100, false, REJECT_INVALID, "bad-cb-has-pours", false)).Times(1); + EXPECT_CALL(state, DoS(100, false, REJECT_INVALID, "bad-cb-has-joinsplits", false)).Times(1); CheckTransactionWithoutProofVerification(tx, state); } diff --git a/src/test/coins_tests.cpp b/src/test/coins_tests.cpp index 4e6d8fe04..6ca42ca6b 100644 --- a/src/test/coins_tests.cpp +++ b/src/test/coins_tests.cpp @@ -138,7 +138,7 @@ public: // Manually recompute the dynamic usage of the whole data, and compare it. size_t ret = memusage::DynamicUsage(cacheCoins) + memusage::DynamicUsage(cacheAnchors) + - memusage::DynamicUsage(cacheSerials); + memusage::DynamicUsage(cacheNullifiers); for (CCoinsMap::iterator it = cacheCoins.begin(); it != cacheCoins.end(); it++) { ret += memusage::DynamicUsage(it->second.coins); }