[refactor] remove access to mapTx in validation_block_tests

sedited · sedited · commit 4dd94ca18f6f · 2023-11-10T16:44:47.000+01:00
Use the helper function instead of reaching into the mapTx member
object.
diff --git a/src/test/validation_block_tests.cpp b/src/test/validation_block_tests.cpp
@@ -283,8 +283,7 @@ BOOST_AUTO_TEST_CASE(mempool_locks_reorg)
 
         // Check that all txs are in the pool
         {
-            LOCK(m_node.mempool->cs);
-            BOOST_CHECK_EQUAL(m_node.mempool->mapTx.size(), txs.size());
+            BOOST_CHECK_EQUAL(m_node.mempool->size(), txs.size());
         }
 
         // Run a thread that simulates an RPC caller that is polling while
@@ -295,7 +294,7 @@ BOOST_AUTO_TEST_CASE(mempool_locks_reorg)
             // not some intermediate amount.
             while (true) {
                 LOCK(m_node.mempool->cs);
-                if (m_node.mempool->mapTx.size() == 0) {
+                if (m_node.mempool->size() == 0) {
                     // We are done with the reorg
                     break;
                 }
@@ -304,7 +303,7 @@ BOOST_AUTO_TEST_CASE(mempool_locks_reorg)
                 // be atomic. So the caller assumes that the returned mempool
                 // is consistent. That is, it has all txs that were there
                 // before the reorg.
-                assert(m_node.mempool->mapTx.size() == txs.size());
+                assert(m_node.mempool->size() == txs.size());
                 continue;
             }
             LOCK(cs_main);

Original file line number	Diff line number	Diff line change
`@@ -283,8 +283,7 @@ BOOST_AUTO_TEST_CASE(mempool_locks_reorg)`
`283`	`283`
`284`	`284`	`// Check that all txs are in the pool`
`285`	`285`	`{`
`286`		`- LOCK(m_node.mempool->cs);`
`287`		`- BOOST_CHECK_EQUAL(m_node.mempool->mapTx.size(), txs.size());`
	`286`	`+ BOOST_CHECK_EQUAL(m_node.mempool->size(), txs.size());`
`288`	`287`	`}`
`289`	`288`
`290`	`289`	`// Run a thread that simulates an RPC caller that is polling while`
`@@ -295,7 +294,7 @@ BOOST_AUTO_TEST_CASE(mempool_locks_reorg)`
`295`	`294`	`// not some intermediate amount.`
`296`	`295`	`while (true) {`
`297`	`296`	`LOCK(m_node.mempool->cs);`
`298`		`- if (m_node.mempool->mapTx.size() == 0) {`
	`297`	`+ if (m_node.mempool->size() == 0) {`
`299`	`298`	`// We are done with the reorg`
`300`	`299`	`break;`
`301`	`300`	`}`
`@@ -304,7 +303,7 @@ BOOST_AUTO_TEST_CASE(mempool_locks_reorg)`
`304`	`303`	`// be atomic. So the caller assumes that the returned mempool`
`305`	`304`	`// is consistent. That is, it has all txs that were there`
`306`	`305`	`// before the reorg.`
`307`		`- assert(m_node.mempool->mapTx.size() == txs.size());`
	`306`	`+ assert(m_node.mempool->size() == txs.size());`
`308`	`307`	`continue;`
`309`	`308`	`}`
`310`	`309`	`LOCK(cs_main);`