Replace more rand() % NUM by randranges

sipa · sipa · commit 3ecabae36364 · 2017-06-07T11:34:55.000-07:00
diff --git a/src/test/coins_tests.cpp b/src/test/coins_tests.cpp
@@ -145,7 +145,7 @@ BOOST_AUTO_TEST_CASE(coins_cache_simulation_test)
     for (unsigned int i = 0; i < NUM_SIMULATION_ITERATIONS; i++) {
         // Do a random modification.
         {
-            uint256 txid = txids[insecure_rand() % txids.size()]; // txid we're going to modify in this iteration.
+            uint256 txid = txids[insecure_randrange(txids.size())]; // txid we're going to modify in this iteration.
             Coin& coin = result[COutPoint(txid, 0)];
             const Coin& entry = (insecure_randrange(500) == 0) ? AccessByTxid(*stack.back(), txid) : stack.back()->AccessCoin(COutPoint(txid, 0));
             BOOST_CHECK(coin == entry);
@@ -201,7 +201,7 @@ BOOST_AUTO_TEST_CASE(coins_cache_simulation_test)
         if (insecure_randrange(100) == 0) {
             // Every 100 iterations, flush an intermediate cache
             if (stack.size() > 1 && insecure_randrange(2) == 0) {
-                unsigned int flushIndex = insecure_rand() % (stack.size() - 1);
+                unsigned int flushIndex = insecure_randrange(stack.size() - 1);
                 stack[flushIndex]->Flush();
             }
         }
@@ -434,7 +434,7 @@ BOOST_AUTO_TEST_CASE(updatecoins_simulation_test)
         if (insecure_randrange(100) == 0) {
             // Every 100 iterations, flush an intermediate cache
             if (stack.size() > 1 && insecure_randrange(2) == 0) {
-                unsigned int flushIndex = insecure_rand() % (stack.size() - 1);
+                unsigned int flushIndex = insecure_randrange(stack.size() - 1);
                 stack[flushIndex]->Flush();
             }
         }
diff --git a/src/test/crypto_tests.cpp b/src/test/crypto_tests.cpp
@@ -38,7 +38,7 @@ void TestVector(const Hasher &h, const In &in, const Out &out) {
         Hasher hasher(h);
         size_t pos = 0;
         while (pos < in.size()) {
-            size_t len = insecure_rand() % ((in.size() - pos + 1) / 2 + 1);
+            size_t len = insecure_randrange((in.size() - pos + 1) / 2 + 1);
             hasher.Write((unsigned char*)&in[pos], len);
             pos += len;
             if (pos > 0 && pos + 2 * out.size() > in.size() && pos < in.size()) {
diff --git a/src/test/merkle_tests.cpp b/src/test/merkle_tests.cpp
@@ -120,7 +120,7 @@ BOOST_AUTO_TEST_CASE(merkle_test)
                     // If ntx <= 16, try all branches. Otherwise, try 16 random ones.
                     int mtx = loop;
                     if (ntx > 16) {
-                        mtx = insecure_rand() % ntx;
+                        mtx = insecure_randrange(ntx);
                     }
                     std::vector<uint256> newBranch = BlockMerkleBranch(block, mtx);
                     std::vector<uint256> oldBranch = BlockGetMerkleBranch(block, merkleTree, mtx);
diff --git a/src/test/pmt_tests.cpp b/src/test/pmt_tests.cpp
@@ -21,7 +21,7 @@ class CPartialMerkleTreeTester : public CPartialMerkleTree
 public:
     // flip one bit in one of the hashes - this should break the authentication
     void Damage() {
-        unsigned int n = insecure_rand() % vHash.size();
+        unsigned int n = insecure_randrange(vHash.size());
         int bit = insecure_randrange(256);
         *(vHash[n].begin() + (bit>>3)) ^= 1<<(bit&7);
     }
diff --git a/src/test/prevector_tests.cpp b/src/test/prevector_tests.cpp
@@ -200,21 +200,21 @@ BOOST_AUTO_TEST_CASE(PrevectorTestInt)
         for (int i = 0; i < 2048; i++) {
             int r = insecure_rand();
             if ((r % 4) == 0) {
-                test.insert(insecure_rand() % (test.size() + 1), insecure_rand());
+                test.insert(insecure_randrange(test.size() + 1), insecure_rand());
             }
             if (test.size() > 0 && ((r >> 2) % 4) == 1) {
-                test.erase(insecure_rand() % test.size());
+                test.erase(insecure_randrange(test.size()));
             }
             if (((r >> 4) % 8) == 2) {
                 int new_size = std::max<int>(0, std::min<int>(30, test.size() + (insecure_randrange(5)) - 2));
                 test.resize(new_size);
             }
             if (((r >> 7) % 8) == 3) {
-                test.insert(insecure_rand() % (test.size() + 1), 1 + (insecure_randrange(2)), insecure_rand());
+                test.insert(insecure_randrange(test.size() + 1), 1 + insecure_randrange(2), insecure_rand());
             }
             if (((r >> 10) % 8) == 4) {
                 int del = std::min<int>(test.size(), 1 + (insecure_randrange(2)));
-                int beg = insecure_rand() % (test.size() + 1 - del);
+                int beg = insecure_randrange(test.size() + 1 - del);
                 test.erase(beg, beg + del);
             }
             if (((r >> 13) % 16) == 5) {
@@ -229,11 +229,11 @@ BOOST_AUTO_TEST_CASE(PrevectorTestInt)
                 for (int k = 0; k < num; k++) {
                     values[k] = insecure_rand();
                 }
-                test.insert_range(insecure_rand() % (test.size() + 1), values, values + num);
+                test.insert_range(insecure_randrange(test.size() + 1), values, values + num);
             }
             if (((r >> 26) % 32) == 8) {
                 int del = std::min<int>(test.size(), 1 + (insecure_randrange(4)));
-                int beg = insecure_rand() % (test.size() + 1 - del);
+                int beg = insecure_randrange(test.size() + 1 - del);
                 test.erase(beg, beg + del);
             }
             r = insecure_rand();
@@ -244,7 +244,7 @@ BOOST_AUTO_TEST_CASE(PrevectorTestInt)
                 test.shrink_to_fit();
             }
             if (test.size() > 0) {
-                test.update(insecure_rand() % test.size(), insecure_rand());
+                test.update(insecure_randrange(test.size()), insecure_rand());
             }
             if (((r >> 11) % 1024) == 11) {
                 test.clear();
diff --git a/src/test/sighash_tests.cpp b/src/test/sighash_tests.cpp
@@ -91,7 +91,7 @@ void static RandomScript(CScript &script) {
     script = CScript();
     int ops = (insecure_randrange(10));
     for (int i=0; i<ops; i++)
-        script << oplist[insecure_rand() % (sizeof(oplist)/sizeof(oplist[0]))];
+        script << oplist[insecure_randrange(sizeof(oplist)/sizeof(oplist[0]))];
 }
 
 void static RandomTransaction(CMutableTransaction &tx, bool fSingle) {
@@ -138,7 +138,7 @@ BOOST_AUTO_TEST_CASE(sighash_test)
         RandomTransaction(txTo, (nHashType & 0x1f) == SIGHASH_SINGLE);
         CScript scriptCode;
         RandomScript(scriptCode);
-        int nIn = insecure_rand() % txTo.vin.size();
+        int nIn = insecure_randrange(txTo.vin.size());
 
         uint256 sh, sho;
         sho = SignatureHashOld(scriptCode, txTo, nIn, nHashType);
diff --git a/src/test/skiplist_tests.cpp b/src/test/skiplist_tests.cpp
@@ -34,8 +34,8 @@ BOOST_AUTO_TEST_CASE(skiplist_test)
     }
 
     for (int i=0; i < 1000; i++) {
-        int from = insecure_rand() % (SKIPLIST_LENGTH - 1);
-        int to = insecure_rand() % (from + 1);
+        int from = insecure_randrange(SKIPLIST_LENGTH - 1);
+        int to = insecure_randrange(from + 1);
 
         BOOST_CHECK(vIndex[SKIPLIST_LENGTH - 1].GetAncestor(from) == &vIndex[from]);
         BOOST_CHECK(vIndex[from].GetAncestor(to) == &vIndex[to]);
@@ -115,7 +115,7 @@ BOOST_AUTO_TEST_CASE(findearliestatleast_test)
         } else {
             // randomly choose something in the range [MTP, MTP*2]
             int64_t medianTimePast = vBlocksMain[i].GetMedianTimePast();
-            int r = insecure_rand() % medianTimePast;
+            int r = insecure_randrange(medianTimePast);
             vBlocksMain[i].nTime = r + medianTimePast;
             vBlocksMain[i].nTimeMax = std::max(vBlocksMain[i].nTime, vBlocksMain[i-1].nTimeMax);
         }
@@ -134,7 +134,7 @@ BOOST_AUTO_TEST_CASE(findearliestatleast_test)
     // Verify that FindEarliestAtLeast is correct.
     for (unsigned int i=0; i<10000; ++i) {
         // Pick a random element in vBlocksMain.
-        int r = insecure_rand() % vBlocksMain.size();
+        int r = insecure_randrange(vBlocksMain.size());
         int64_t test_time = vBlocksMain[r].nTime;
         CBlockIndex *ret = chain.FindEarliestAtLeast(test_time);
         BOOST_CHECK(ret->nTimeMax >= test_time);

Original file line number	Diff line number	Diff line change
`@@ -145,7 +145,7 @@ BOOST_AUTO_TEST_CASE(coins_cache_simulation_test)`
`145`	`145`	`for (unsigned int i = 0; i < NUM_SIMULATION_ITERATIONS; i++) {`
`146`	`146`	`// Do a random modification.`
`147`	`147`	`{`
`148`		`- uint256 txid = txids[insecure_rand() % txids.size()]; // txid we're going to modify in this iteration.`
	`148`	`+ uint256 txid = txids[insecure_randrange(txids.size())]; // txid we're going to modify in this iteration.`
`149`	`149`	`Coin& coin = result[COutPoint(txid, 0)];`
`150`	`150`	`const Coin& entry = (insecure_randrange(500) == 0) ? AccessByTxid(*stack.back(), txid) : stack.back()->AccessCoin(COutPoint(txid, 0));`
`151`	`151`	`BOOST_CHECK(coin == entry);`
`@@ -201,7 +201,7 @@ BOOST_AUTO_TEST_CASE(coins_cache_simulation_test)`
`201`	`201`	`if (insecure_randrange(100) == 0) {`
`202`	`202`	`// Every 100 iterations, flush an intermediate cache`
`203`	`203`	`if (stack.size() > 1 && insecure_randrange(2) == 0) {`
`204`		`- unsigned int flushIndex = insecure_rand() % (stack.size() - 1);`
	`204`	`+ unsigned int flushIndex = insecure_randrange(stack.size() - 1);`
`205`	`205`	`stack[flushIndex]->Flush();`
`206`	`206`	`}`
`207`	`207`	`}`
`@@ -434,7 +434,7 @@ BOOST_AUTO_TEST_CASE(updatecoins_simulation_test)`
`434`	`434`	`if (insecure_randrange(100) == 0) {`
`435`	`435`	`// Every 100 iterations, flush an intermediate cache`
`436`	`436`	`if (stack.size() > 1 && insecure_randrange(2) == 0) {`
`437`		`- unsigned int flushIndex = insecure_rand() % (stack.size() - 1);`
	`437`	`+ unsigned int flushIndex = insecure_randrange(stack.size() - 1);`
`438`	`438`	`stack[flushIndex]->Flush();`
`439`	`439`	`}`
`440`	`440`	`}`
Original file line number	Diff line number	Diff line change
`@@ -120,7 +120,7 @@ BOOST_AUTO_TEST_CASE(merkle_test)`
`120`	`120`	`// If ntx <= 16, try all branches. Otherwise, try 16 random ones.`
`121`	`121`	`int mtx = loop;`
`122`	`122`	`if (ntx > 16) {`
`123`		`- mtx = insecure_rand() % ntx;`
	`123`	`+ mtx = insecure_randrange(ntx);`
`124`	`124`	`}`
`125`	`125`	`std::vector<uint256> newBranch = BlockMerkleBranch(block, mtx);`
`126`	`126`	`std::vector<uint256> oldBranch = BlockGetMerkleBranch(block, merkleTree, mtx);`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ class CPartialMerkleTreeTester : public CPartialMerkleTree`
`21`	`21`	`public:`
`22`	`22`	`// flip one bit in one of the hashes - this should break the authentication`
`23`	`23`	`void Damage() {`
`24`		`- unsigned int n = insecure_rand() % vHash.size();`
	`24`	`+ unsigned int n = insecure_randrange(vHash.size());`
`25`	`25`	`int bit = insecure_randrange(256);`
`26`	`26`	`*(vHash[n].begin() + (bit>>3)) ^= 1<<(bit&7);`
`27`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -200,21 +200,21 @@ BOOST_AUTO_TEST_CASE(PrevectorTestInt)`
`200`	`200`	`for (int i = 0; i < 2048; i++) {`
`201`	`201`	`int r = insecure_rand();`
`202`	`202`	`if ((r % 4) == 0) {`
`203`		`- test.insert(insecure_rand() % (test.size() + 1), insecure_rand());`
	`203`	`+ test.insert(insecure_randrange(test.size() + 1), insecure_rand());`
`204`	`204`	`}`
`205`	`205`	`if (test.size() > 0 && ((r >> 2) % 4) == 1) {`
`206`		`- test.erase(insecure_rand() % test.size());`
	`206`	`+ test.erase(insecure_randrange(test.size()));`
`207`	`207`	`}`
`208`	`208`	`if (((r >> 4) % 8) == 2) {`
`209`	`209`	`int new_size = std::max<int>(0, std::min<int>(30, test.size() + (insecure_randrange(5)) - 2));`
`210`	`210`	`test.resize(new_size);`
`211`	`211`	`}`
`212`	`212`	`if (((r >> 7) % 8) == 3) {`
`213`		`- test.insert(insecure_rand() % (test.size() + 1), 1 + (insecure_randrange(2)), insecure_rand());`
	`213`	`+ test.insert(insecure_randrange(test.size() + 1), 1 + insecure_randrange(2), insecure_rand());`
`214`	`214`	`}`
`215`	`215`	`if (((r >> 10) % 8) == 4) {`
`216`	`216`	`int del = std::min<int>(test.size(), 1 + (insecure_randrange(2)));`
`217`		`- int beg = insecure_rand() % (test.size() + 1 - del);`
	`217`	`+ int beg = insecure_randrange(test.size() + 1 - del);`
`218`	`218`	`test.erase(beg, beg + del);`
`219`	`219`	`}`
`220`	`220`	`if (((r >> 13) % 16) == 5) {`
`@@ -229,11 +229,11 @@ BOOST_AUTO_TEST_CASE(PrevectorTestInt)`
`229`	`229`	`for (int k = 0; k < num; k++) {`
`230`	`230`	`values[k] = insecure_rand();`
`231`	`231`	`}`
`232`		`- test.insert_range(insecure_rand() % (test.size() + 1), values, values + num);`
	`232`	`+ test.insert_range(insecure_randrange(test.size() + 1), values, values + num);`
`233`	`233`	`}`
`234`	`234`	`if (((r >> 26) % 32) == 8) {`
`235`	`235`	`int del = std::min<int>(test.size(), 1 + (insecure_randrange(4)));`
`236`		`- int beg = insecure_rand() % (test.size() + 1 - del);`
	`236`	`+ int beg = insecure_randrange(test.size() + 1 - del);`
`237`	`237`	`test.erase(beg, beg + del);`
`238`	`238`	`}`
`239`	`239`	`r = insecure_rand();`
`@@ -244,7 +244,7 @@ BOOST_AUTO_TEST_CASE(PrevectorTestInt)`
`244`	`244`	`test.shrink_to_fit();`
`245`	`245`	`}`
`246`	`246`	`if (test.size() > 0) {`
`247`		`- test.update(insecure_rand() % test.size(), insecure_rand());`
	`247`	`+ test.update(insecure_randrange(test.size()), insecure_rand());`
`248`	`248`	`}`
`249`	`249`	`if (((r >> 11) % 1024) == 11) {`
`250`	`250`	`test.clear();`