use fresh local test txs pool for each test

Author: Franziska-Mueller

test/pending_txs_pool.cpp

@@ -72,69 +72,69 @@ class TestPendingTxsPool : public PendingTxsPool
 
         return add(transaction);
     }
-};
 
-TestPendingTxsPool pendingTxsPool;
+    unsigned int addTickTransactions(unsigned int tick, unsigned long long seed, unsigned int maxTransactions)
+    {
+        // use pseudo-random sequence
+        std::mt19937_64 gen64(seed);
 
-unsigned int addTickTransactions(unsigned int tick, unsigned long long seed, unsigned int maxTransactions)
-{
-    // use pseudo-random sequence
-    std::mt19937_64 gen64(seed);
+        unsigned int numTransactionsAdded = 0;
 
-    unsigned int numTransactionsAdded = 0;
+        // add transactions of tick
+        unsigned int transactionNum = gen64() % (maxTransactions + 1);
+        for (unsigned int transaction = 0; transaction < transactionNum; ++transaction)
+        {
+            unsigned int inputSize = gen64() % MAX_INPUT_SIZE;
+            long long amount = gen64() % MAX_AMOUNT;
+            m256i srcPublicKey = m256i{ 0, 0, 0, (gen64() % NUM_INITIALIZED_ENTITIES) + 1 };
+            if (addTransaction(tick, amount, inputSize, /*dest=*/nullptr, &srcPublicKey))
+                numTransactionsAdded++;
+        }
+        checkStateConsistencyWithAssert();
 
-    // add transactions of tick
-    unsigned int transactionNum = gen64() % (maxTransactions + 1);
-    for (unsigned int transaction = 0; transaction < transactionNum; ++transaction)
-    {
-        unsigned int inputSize = gen64() % MAX_INPUT_SIZE;
-        long long amount = gen64() % MAX_AMOUNT;
-        m256i srcPublicKey = m256i{ 0, 0, 0, (gen64() % NUM_INITIALIZED_ENTITIES) + 1 };
-        if (pendingTxsPool.addTransaction(tick, amount, inputSize, /*dest=*/nullptr, &srcPublicKey))
-            numTransactionsAdded++;
+        return numTransactionsAdded;
     }
-    pendingTxsPool.checkStateConsistencyWithAssert();
-
-    return numTransactionsAdded;
-}
 
-void checkTickTransactions(unsigned int tick, unsigned long long seed, unsigned int maxTransactions)
-{
-    // use pseudo-random sequence
-    std::mt19937_64 gen64(seed);
+    void checkTickTransactions(unsigned int tick, unsigned long long seed, unsigned int maxTransactions)
+    {
+        // use pseudo-random sequence
+        std::mt19937_64 gen64(seed);
 
-    // check transactions of tick
-    unsigned int transactionNum = gen64() % (maxTransactions + 1);
+        // check transactions of tick
+        unsigned int transactionNum = gen64() % (maxTransactions + 1);
 
-    for (unsigned int transaction = 0; transaction < transactionNum; ++transaction)
-    {
-        unsigned int expectedInputSize = gen64() % MAX_INPUT_SIZE;
-        long long expectedAmount = gen64() % MAX_AMOUNT;
-        m256i expectedSrcPublicKey = m256i{ 0, 0, 0, (gen64() % NUM_INITIALIZED_ENTITIES) + 1 };
+        for (unsigned int transaction = 0; transaction < transactionNum; ++transaction)
+        {
+            unsigned int expectedInputSize = gen64() % MAX_INPUT_SIZE;
+            long long expectedAmount = gen64() % MAX_AMOUNT;
+            m256i expectedSrcPublicKey = m256i{ 0, 0, 0, (gen64() % NUM_INITIALIZED_ENTITIES) + 1 };
 
-        Transaction* tp = pendingTxsPool.getTx(tick, transaction);
+            Transaction* tp = getTx(tick, transaction);
 
-        ASSERT_NE(tp, nullptr);
+            ASSERT_NE(tp, nullptr);
 
-        EXPECT_TRUE(tp->checkValidity());
-        EXPECT_EQ(tp->tick, tick);
-        EXPECT_EQ(static_cast<unsigned int>(tp->inputSize), expectedInputSize);
-        EXPECT_EQ(tp->amount, expectedAmount);
-        EXPECT_TRUE(tp->sourcePublicKey == expectedSrcPublicKey);
+            EXPECT_TRUE(tp->checkValidity());
+            EXPECT_EQ(tp->tick, tick);
+            EXPECT_EQ(static_cast<unsigned int>(tp->inputSize), expectedInputSize);
+            EXPECT_EQ(tp->amount, expectedAmount);
+            EXPECT_TRUE(tp->sourcePublicKey == expectedSrcPublicKey);
 
-        m256i* digest = pendingTxsPool.getDigest(tick, transaction);
+            m256i* digest = getDigest(tick, transaction);
 
-        ASSERT_NE(digest, nullptr);
+            ASSERT_NE(digest, nullptr);
 
-        m256i tpDigest;
-        KangarooTwelve(tp, tp->totalSize(), &tpDigest, 32);
-        EXPECT_EQ(*digest, tpDigest);
+            m256i tpDigest;
+            KangarooTwelve(tp, tp->totalSize(), &tpDigest, 32);
+            EXPECT_EQ(*digest, tpDigest);
+        }
     }
-}
+};
 
 
 TEST(TestPendingTxsPool, EpochTransition) 
 {
+    TestPendingTxsPool pendingTxsPool;
+
     unsigned long long seed = 42;
 
     // use pseudo-random sequence
@@ -176,11 +176,11 @@ TEST(TestPendingTxsPool, EpochTransition)
 
         // add ticks transactions
         for (int i = 0; i < firstEpochTicks; ++i)
-            numAdded = addTickTransactions(firstEpochTick0 + i, firstEpochSeeds[i], maxTransactions);
+            numAdded = pendingTxsPool.addTickTransactions(firstEpochTick0 + i, firstEpochSeeds[i], maxTransactions);
 
         // check ticks transactions
         for (int i = 0; i < firstEpochTicks; ++i)
-            checkTickTransactions(firstEpochTick0 + i, firstEpochSeeds[i], maxTransactions);
+            pendingTxsPool.checkTickTransactions(firstEpochTick0 + i, firstEpochSeeds[i], maxTransactions);
 
         pendingTxsPool.checkStateConsistencyWithAssert();
 
@@ -192,14 +192,14 @@ TEST(TestPendingTxsPool, EpochTransition)
 
         // add ticks transactions
         for (int i = 0; i < secondEpochTicks; ++i)
-            numAdded = addTickTransactions(secondEpochTick0 + i, secondEpochSeeds[i], maxTransactions);
+            numAdded = pendingTxsPool.addTickTransactions(secondEpochTick0 + i, secondEpochSeeds[i], maxTransactions);
 
         // check ticks transactions
         for (int i = 0; i < secondEpochTicks; ++i)
-            checkTickTransactions(secondEpochTick0 + i, secondEpochSeeds[i], maxTransactions);
+            pendingTxsPool.checkTickTransactions(secondEpochTick0 + i, secondEpochSeeds[i], maxTransactions);
 
         // add a transaction for the next epoch
-        numAdded = addTickTransactions(thirdEpochTick0 + 1, thirdEpochSeeds[1], maxTransactions);
+        numAdded = pendingTxsPool.addTickTransactions(thirdEpochTick0 + 1, thirdEpochSeeds[1], maxTransactions);
 
         pendingTxsPool.checkStateConsistencyWithAssert();
 
@@ -211,14 +211,14 @@ TEST(TestPendingTxsPool, EpochTransition)
 
         // add ticks transactions
         for (int i = 2; i < thirdEpochTicks; ++i)
-            numAdded = addTickTransactions(thirdEpochTick0 + i, thirdEpochSeeds[i], maxTransactions);
+            numAdded = pendingTxsPool.addTickTransactions(thirdEpochTick0 + i, thirdEpochSeeds[i], maxTransactions);
 
         // check ticks transactions
         for (int i = 1; i < thirdEpochTicks; ++i)
-            checkTickTransactions(thirdEpochTick0 + i, thirdEpochSeeds[i], maxTransactions);
+            pendingTxsPool.checkTickTransactions(thirdEpochTick0 + i, thirdEpochSeeds[i], maxTransactions);
 
         // add a transaction for the next epoch
-        numAdded = addTickTransactions(fourthEpochTick0 + 1, /*seed=*/42, maxTransactions);
+        numAdded = pendingTxsPool.addTickTransactions(fourthEpochTick0 + 1, /*seed=*/42, maxTransactions);
 
         pendingTxsPool.checkStateConsistencyWithAssert();
 
@@ -234,6 +234,7 @@ TEST(TestPendingTxsPool, EpochTransition)
 
 TEST(TestPendingTxsPool, TotalNumberOfPendingTxs) 
 {
+    TestPendingTxsPool pendingTxsPool;
     unsigned long long seed = 1337;
 
     // use pseudo-random sequence
@@ -262,7 +263,7 @@ TEST(TestPendingTxsPool, TotalNumberOfPendingTxs)
         std::vector<unsigned short> numPendingTransactions(firstEpochTicks, 0);
         for (int i = firstEpochTicks - 1; i >= 0; --i)
         {
-            numTransactionsAdded[i] = addTickTransactions(firstEpochTick0 + i, firstEpochSeeds[i], maxTransactions);
+            numTransactionsAdded[i] = pendingTxsPool.addTickTransactions(firstEpochTick0 + i, firstEpochSeeds[i], maxTransactions);
             if (i > 0)
             {
                 numPendingTransactions[i - 1] = numPendingTransactions[i] + numTransactionsAdded[i];
@@ -281,6 +282,7 @@ TEST(TestPendingTxsPool, TotalNumberOfPendingTxs)
 
 TEST(TestPendingTxsPool, NumberOfPendingTickTxs) 
 {
+    TestPendingTxsPool pendingTxsPool;
     unsigned long long seed = 67534;
 
     // use pseudo-random sequence
@@ -308,7 +310,7 @@ TEST(TestPendingTxsPool, NumberOfPendingTickTxs)
         std::vector<unsigned short> numTransactionsAdded(firstEpochTicks);
         for (int i = firstEpochTicks - 1; i >= 0; --i)
         {
-            numTransactionsAdded[i] = addTickTransactions(firstEpochTick0 + i, firstEpochSeeds[i], maxTransactions);
+            numTransactionsAdded[i] = pendingTxsPool.addTickTransactions(firstEpochTick0 + i, firstEpochSeeds[i], maxTransactions);
         }
 
         EXPECT_EQ(pendingTxsPool.getNumberOfPendingTickTxs(firstEpochTick0 - 1), 0);
@@ -323,6 +325,7 @@ TEST(TestPendingTxsPool, NumberOfPendingTickTxs)
 
 TEST(TestPendingTxsPool, IncrementFirstStoredTick)
 {
+    TestPendingTxsPool pendingTxsPool;
     unsigned long long seed = 84129;
 
     // use pseudo-random sequence
@@ -351,7 +354,7 @@ TEST(TestPendingTxsPool, IncrementFirstStoredTick)
         std::vector<unsigned short> numPendingTransactions(firstEpochTicks, 0);
         for (int i = firstEpochTicks - 1; i >= 0; --i)
         {
-            numTransactionsAdded[i] = addTickTransactions(firstEpochTick0 + i, firstEpochSeeds[i], maxTransactions);
+            numTransactionsAdded[i] = pendingTxsPool.addTickTransactions(firstEpochTick0 + i, firstEpochSeeds[i], maxTransactions);
             if (i > 0)
             {
                 numPendingTransactions[i - 1] = numPendingTransactions[i] + numTransactionsAdded[i];
@@ -376,6 +379,7 @@ TEST(TestPendingTxsPool, IncrementFirstStoredTick)
 
 TEST(TestPendingTxsPool, TxsPrioritizationMoreThanMaxTxs)
 {
+    TestPendingTxsPool pendingTxsPool;
     unsigned long long seed = 9532;
 
     // use pseudo-random sequence
@@ -418,6 +422,7 @@ TEST(TestPendingTxsPool, TxsPrioritizationMoreThanMaxTxs)
 
 TEST(TestPendingTxsPool, TxsPrioritizationDuplicateTxs)
 {
+    TestPendingTxsPool pendingTxsPool;
     unsigned long long seed = 9532;
 
     // use pseudo-random sequence
@@ -457,6 +462,7 @@ TEST(TestPendingTxsPool, TxsPrioritizationDuplicateTxs)
 
 TEST(TestPendingTxsPool, ProtocolLevelTxsMaxPriority)
 {
+    TestPendingTxsPool pendingTxsPool;
     unsigned long long seed = 9532;
 
     // use pseudo-random sequence
@@ -499,6 +505,7 @@ TEST(TestPendingTxsPool, ProtocolLevelTxsMaxPriority)
 
 TEST(TestPendingTxsPool, TxsWithSrcBalance0AreRejected)
 {
+    TestPendingTxsPool pendingTxsPool;
     unsigned long long seed = 3452;
 
     // use pseudo-random sequence