moved claimtrie_tests into claimtriebranching_tests

to take advantage of the test fixture there

added counts & hash checks to tests

also ran the code format tool

ran the formatting tool

cleaned up the earlier question on hashes, fixed crash bug

ran formatter

src/Makefile.test.include

@@ -60,7 +60,6 @@ BITCOIN_TESTS =\
   test/merkle_tests.cpp \
   test/miner_tests.cpp \
   test/multisig_tests.cpp \
-  test/claimtrie_tests.cpp \
   test/claimtriecache_tests.cpp \
   test/claimtriebranching_tests.cpp \
   test/nameclaim_tests.cpp \

src/claimtrie.cpp

@@ -2681,7 +2681,7 @@ bool CClaimTrieCache::forkForExpirationChange(bool increment) const
         if (pcursor->GetKey(key))
         {
             int height = key.second;
-            // if we've looked throught this in dirtyExprirationQueueRows, don't use it
+            // if we've looked through this in dirtyExprirationQueueRows, don't use it
             // because its stale
             if ((key.first == EXP_QUEUE_ROW) & (dirtyHeights.count(height) == 0))
             {

src/consensus/params.h

@@ -58,8 +58,11 @@ struct Params {
     bool fPowNoRetargeting;
     int64_t nPowTargetSpacing;
     int64_t nPowTargetTimespan;
+    /** how long it took claims to expire before the hard fork */
     int64_t nOriginalClaimExpirationTime;
+    /** how long it takes claims to expire after the hard fork */
     int64_t nExtendedClaimExpirationTime;
+    /** blocks before the hard fork that changed the expiration time */
     int64_t nExtendedClaimExpirationForkHeight;
     int64_t GetExpirationTime(int64_t nHeight) const {
         return nHeight < nExtendedClaimExpirationForkHeight ?

src/test/claimtriecache_tests.cpp

@@ -34,10 +34,27 @@ public:
 
 };
 
+CMutableTransaction BuildTransaction(const uint256& prevhash)
+{
+    CMutableTransaction tx;
+    tx.nVersion = 1;
+    tx.nLockTime = 0;
+    tx.vin.resize(1);
+    tx.vout.resize(1);
+    tx.vin[0].prevout.hash = prevhash;
+    tx.vin[0].prevout.n = 0;
+    tx.vin[0].scriptSig = CScript();
+    tx.vin[0].nSequence = std::numeric_limits<unsigned int>::max();
+    tx.vout[0].scriptPubKey = CScript();
+    tx.vout[0].nValue = 0;
+
+    return tx;
+}
+
 BOOST_FIXTURE_TEST_SUITE(claimtriecache_tests, RegTestingSetup)
 
 
-BOOST_AUTO_TEST_CASE(merklehash_test)
+BOOST_AUTO_TEST_CASE(merkle_hash_single_test)
 {
     // check empty trie
     uint256 one(uint256S("0000000000000000000000000000000000000000000000000000000000000001"));
@@ -50,7 +67,127 @@ BOOST_AUTO_TEST_CASE(merklehash_test)
     BOOST_CHECK(one == cc.getMerkleHash());
 }
 
-BOOST_AUTO_TEST_CASE(recursiveprune_test)
+BOOST_AUTO_TEST_CASE(merkle_hash_multiple_test)
+{
+    CClaimValue unused;
+    uint256 hash0(uint256S("0000000000000000000000000000000000000000000000000000000000000001"));
+    uint160 hash160;
+    CMutableTransaction tx1 = BuildTransaction(hash0);
+    COutPoint tx1OutPoint(tx1.GetHash(), 0);
+    CMutableTransaction tx2 = BuildTransaction(tx1.GetHash());
+    COutPoint tx2OutPoint(tx2.GetHash(), 0);
+    CMutableTransaction tx3 = BuildTransaction(tx2.GetHash());
+    COutPoint tx3OutPoint(tx3.GetHash(), 0);
+    CMutableTransaction tx4 = BuildTransaction(tx3.GetHash());
+    COutPoint tx4OutPoint(tx4.GetHash(), 0);
+    CMutableTransaction tx5 = BuildTransaction(tx4.GetHash());
+    COutPoint tx5OutPoint(tx5.GetHash(), 0);
+    CMutableTransaction tx6 = BuildTransaction(tx5.GetHash());
+    COutPoint tx6OutPoint(tx6.GetHash(), 0);
+
+    uint256 hash1;
+    hash1.SetHex("71c7b8d35b9a3d7ad9a1272b68972979bbd18589f1efe6f27b0bf260a6ba78fa");
+
+    uint256 hash2;
+    hash2.SetHex("c4fc0e2ad56562a636a0a237a96a5f250ef53495c2cb5edd531f087a8de83722");
+
+    uint256 hash3;
+    hash3.SetHex("baf52472bd7da19fe1e35116cfb3bd180d8770ffbe3ae9243df1fb58a14b0975");
+
+    uint256 hash4;
+    hash4.SetHex("c73232a755bf015f22eaa611b283ff38100f2a23fb6222e86eca363452ba0c51");
+
+    BOOST_CHECK(pclaimTrie->empty());
+
+    CClaimTrieCache ntState(pclaimTrie, false);
+    ntState.insertClaimIntoTrie(std::string("test"), CClaimValue(tx1OutPoint, hash160, 50, 100, 200));
+    ntState.insertClaimIntoTrie(std::string("test2"), CClaimValue(tx2OutPoint, hash160, 50, 100, 200));
+
+    BOOST_CHECK(pclaimTrie->empty());
+    BOOST_CHECK(!ntState.empty());
+    BOOST_CHECK(ntState.getMerkleHash() == hash1);
+
+    ntState.insertClaimIntoTrie(std::string("test"), CClaimValue(tx3OutPoint, hash160, 50, 101, 201));
+    BOOST_CHECK(ntState.getMerkleHash() == hash1);
+    ntState.insertClaimIntoTrie(std::string("tes"), CClaimValue(tx4OutPoint, hash160, 50, 100, 200));
+    BOOST_CHECK(ntState.getMerkleHash() == hash2);
+    ntState.insertClaimIntoTrie(std::string("testtesttesttest"), CClaimValue(tx5OutPoint, hash160, 50, 100, 200));
+    ntState.removeClaimFromTrie(std::string("testtesttesttest"), tx5OutPoint, unused);
+    BOOST_CHECK(ntState.getMerkleHash() == hash2);
+    ntState.flush();
+
+    BOOST_CHECK(!pclaimTrie->empty());
+    BOOST_CHECK(pclaimTrie->getMerkleHash() == hash2);
+    BOOST_CHECK(pclaimTrie->checkConsistency());
+
+    CClaimTrieCache ntState1(pclaimTrie, false);
+    ntState1.removeClaimFromTrie(std::string("test"), tx1OutPoint, unused);
+    ntState1.removeClaimFromTrie(std::string("test2"), tx2OutPoint, unused);
+    ntState1.removeClaimFromTrie(std::string("test"), tx3OutPoint, unused);
+    ntState1.removeClaimFromTrie(std::string("tes"), tx4OutPoint, unused);
+
+    BOOST_CHECK(ntState1.getMerkleHash() == hash0);
+
+    CClaimTrieCache ntState2(pclaimTrie, false);
+    ntState2.insertClaimIntoTrie(std::string("abab"), CClaimValue(tx6OutPoint, hash160, 50, 100, 200));
+    ntState2.removeClaimFromTrie(std::string("test"), tx1OutPoint, unused);
+
+    BOOST_CHECK(ntState2.getMerkleHash() == hash3);
+
+    ntState2.flush();
+
+    BOOST_CHECK(!pclaimTrie->empty());
+    BOOST_CHECK(pclaimTrie->getMerkleHash() == hash3);
+    BOOST_CHECK(pclaimTrie->checkConsistency());
+
+    CClaimTrieCache ntState3(pclaimTrie, false);
+    ntState3.insertClaimIntoTrie(std::string("test"), CClaimValue(tx1OutPoint, hash160, 50, 100, 200));
+    BOOST_CHECK(ntState3.getMerkleHash() == hash4);
+    ntState3.flush();
+    BOOST_CHECK(!pclaimTrie->empty());
+    BOOST_CHECK(pclaimTrie->getMerkleHash() == hash4);
+    BOOST_CHECK(pclaimTrie->checkConsistency());
+
+    CClaimTrieCache ntState4(pclaimTrie, false);
+    ntState4.removeClaimFromTrie(std::string("abab"), tx6OutPoint, unused);
+    BOOST_CHECK(ntState4.getMerkleHash() == hash2);
+    ntState4.flush();
+    BOOST_CHECK(!pclaimTrie->empty());
+    BOOST_CHECK(pclaimTrie->getMerkleHash() == hash2);
+    BOOST_CHECK(pclaimTrie->checkConsistency());
+
+    CClaimTrieCache ntState5(pclaimTrie, false);
+    ntState5.removeClaimFromTrie(std::string("test"), tx3OutPoint, unused);
+
+    BOOST_CHECK(ntState5.getMerkleHash() == hash2);
+    ntState5.flush();
+    BOOST_CHECK(!pclaimTrie->empty());
+    BOOST_CHECK(pclaimTrie->getMerkleHash() == hash2);
+    BOOST_CHECK(pclaimTrie->checkConsistency());
+
+    CClaimTrieCache ntState6(pclaimTrie, false);
+    ntState6.insertClaimIntoTrie(std::string("test"), CClaimValue(tx3OutPoint, hash160, 50, 101, 201));
+
+    BOOST_CHECK(ntState6.getMerkleHash() == hash2);
+    ntState6.flush();
+    BOOST_CHECK(!pclaimTrie->empty());
+    BOOST_CHECK(pclaimTrie->getMerkleHash() == hash2);
+    BOOST_CHECK(pclaimTrie->checkConsistency());
+
+    CClaimTrieCache ntState7(pclaimTrie, false);
+    ntState7.removeClaimFromTrie(std::string("test"), tx3OutPoint, unused);
+    ntState7.removeClaimFromTrie(std::string("test"), tx1OutPoint, unused);
+    ntState7.removeClaimFromTrie(std::string("tes"), tx4OutPoint, unused);
+    ntState7.removeClaimFromTrie(std::string("test2"), tx2OutPoint, unused);
+
+    BOOST_CHECK(ntState7.getMerkleHash() == hash0);
+    ntState7.flush();
+    BOOST_CHECK(pclaimTrie->empty());
+    BOOST_CHECK(pclaimTrie->getMerkleHash() == hash0);
+    BOOST_CHECK(pclaimTrie->checkConsistency());
+}
+
+BOOST_AUTO_TEST_CASE(recursive_prune_test)
 {
     CClaimTrieCacheTest cc(pclaimTrie);
     BOOST_CHECK_EQUAL(0, cc.cacheSize());