kvazar
/
kevacoin
mirror of https://github.com/kvazar-network/kevacoin.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

scripted-diff: Use new naming style for insecure_rand* functions 

-BEGIN VERIFY SCRIPT-
sed -i 's/\<insecure_randbits(/InsecureRandBits(/g' src/test/*.cpp src/test/*.h src/wallet/test/*.cpp
sed -i 's/\<insecure_randbool(/InsecureRandBool(/g' src/test/*.cpp src/test/*.h src/wallet/test/*.cpp
sed -i 's/\<insecure_randrange(/InsecureRandRange(/g' src/test/*.cpp src/test/*.h src/wallet/test/*.cpp
sed -i 's/\<insecure_randbytes(/InsecureRandBytes(/g' src/test/*.cpp src/test/*.h src/wallet/test/*.cpp
sed -i 's/\<insecure_rand256(/InsecureRand256(/g' src/test/*.cpp src/test/*.h src/wallet/test/*.cpp
sed -i 's/\<insecure_rand(/InsecureRand32(/g' src/test/*.cpp src/test/*.h src/wallet/test/*.cpp
sed -i 's/\<seed_insecure_rand(/SeedInsecureRand(/g' src/test/*.cpp src/test/*.h src/wallet/test/*.cpp
-END VERIFY SCRIPT-
0.15
Pieter Wuille 8 years ago
parent
2fcd9cc86b
commit
e945848582
20 changed files with 142 additions and 142 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      src/test/DoS_tests.cpp
  2. 10
      src/test/blockencodings_tests.cpp
  3. 2
      src/test/bloom_tests.cpp
  4. 10
      src/test/checkqueue_tests.cpp
  5. 78
      src/test/coins_tests.cpp
  6. 2
      src/test/crypto_tests.cpp
  7. 20
      src/test/dbwrapper_tests.cpp
  8. 2
      src/test/hash_tests.cpp
  9. 4
      src/test/merkle_tests.cpp
  10. 4
      src/test/miner_tests.cpp
  11. 8
      src/test/pmt_tests.cpp
  12. 6
      src/test/pow_tests.cpp
  13. 64
      src/test/prevector_tests.cpp
  14. 26
      src/test/sighash_tests.cpp
  15. 10
      src/test/skiplist_tests.cpp
  16. 2
      src/test/test_bitcoin.cpp
  17. 14
      src/test/test_bitcoin.h
  18. 4
      src/test/util_tests.cpp
  19. 12
      src/test/versionbits_tests.cpp
  20. 2
      src/wallet/test/crypto_tests.cpp

4
src/test/DoS_tests.cpp
Unescape View File

@ -129,7 +129,7 @@ BOOST_AUTO_TEST_CASE(DoS_bantime)
CTransactionRef RandomOrphan() CTransactionRef RandomOrphan()
{ {
std::map<uint256, COrphanTx>::iterator it; std::map<uint256, COrphanTx>::iterator it;
it = mapOrphanTransactions.lower_bound(insecure_rand256()); it = mapOrphanTransactions.lower_bound(InsecureRand256());
if (it == mapOrphanTransactions.end()) if (it == mapOrphanTransactions.end())
it = mapOrphanTransactions.begin(); it = mapOrphanTransactions.begin();
return it->second.tx; return it->second.tx;
@ -148,7 +148,7 @@ BOOST_AUTO_TEST_CASE(DoS_mapOrphans)
CMutableTransaction tx; CMutableTransaction tx;
tx.vin.resize(1); tx.vin.resize(1);
tx.vin[0].prevout.n = 0; tx.vin[0].prevout.n = 0;
tx.vin[0].prevout.hash = insecure_rand256(); tx.vin[0].prevout.hash = InsecureRand256();
tx.vin[0].scriptSig << OP_1; tx.vin[0].scriptSig << OP_1;
tx.vout.resize(1); tx.vout.resize(1);
tx.vout[0].nValue = 1*CENT; tx.vout[0].nValue = 1*CENT;

10
src/test/blockencodings_tests.cpp
Unescape View File

@ -30,16 +30,16 @@ static CBlock BuildBlockTestCase() {
block.vtx.resize(3); block.vtx.resize(3);
block.vtx[0] = MakeTransactionRef(tx); block.vtx[0] = MakeTransactionRef(tx);
block.nVersion = 42; block.nVersion = 42;
block.hashPrevBlock = insecure_rand256(); block.hashPrevBlock = InsecureRand256();
block.nBits = 0x207fffff; block.nBits = 0x207fffff;
tx.vin[0].prevout.hash = insecure_rand256(); tx.vin[0].prevout.hash = InsecureRand256();
tx.vin[0].prevout.n = 0; tx.vin[0].prevout.n = 0;
block.vtx[1] = MakeTransactionRef(tx); block.vtx[1] = MakeTransactionRef(tx);
tx.vin.resize(10); tx.vin.resize(10);
for (size_t i = 0; i < tx.vin.size(); i++) { for (size_t i = 0; i < tx.vin.size(); i++) {
tx.vin[i].prevout.hash = insecure_rand256(); tx.vin[i].prevout.hash = InsecureRand256();
tx.vin[i].prevout.n = 0; tx.vin[i].prevout.n = 0;
} }
block.vtx[2] = MakeTransactionRef(tx); block.vtx[2] = MakeTransactionRef(tx);
@ -283,7 +283,7 @@ BOOST_AUTO_TEST_CASE(EmptyBlockRoundTripTest)
block.vtx.resize(1); block.vtx.resize(1);
block.vtx[0] = MakeTransactionRef(std::move(coinbase)); block.vtx[0] = MakeTransactionRef(std::move(coinbase));
block.nVersion = 42; block.nVersion = 42;
block.hashPrevBlock = insecure_rand256(); block.hashPrevBlock = InsecureRand256();
block.nBits = 0x207fffff; block.nBits = 0x207fffff;
bool mutated; bool mutated;
@ -316,7 +316,7 @@ BOOST_AUTO_TEST_CASE(EmptyBlockRoundTripTest)
BOOST_AUTO_TEST_CASE(TransactionsRequestSerializationTest) { BOOST_AUTO_TEST_CASE(TransactionsRequestSerializationTest) {
BlockTransactionsRequest req1; BlockTransactionsRequest req1;
req1.blockhash = insecure_rand256(); req1.blockhash = InsecureRand256();
req1.indexes.resize(4); req1.indexes.resize(4);
req1.indexes[0] = 0; req1.indexes[0] = 0;
req1.indexes[1] = 1; req1.indexes[1] = 1;

2
src/test/bloom_tests.cpp
Unescape View File

@ -463,7 +463,7 @@ BOOST_AUTO_TEST_CASE(merkle_block_4_test_update_none)
static std::vector<unsigned char> RandomData() static std::vector<unsigned char> RandomData()
{ {
uint256 r = insecure_rand256(); uint256 r = InsecureRand256();
return std::vector<unsigned char>(r.begin(), r.end()); return std::vector<unsigned char>(r.begin(), r.end());
} }

10
src/test/checkqueue_tests.cpp
Unescape View File

@ -160,7 +160,7 @@ void Correct_Queue_range(std::vector<size_t> range)
FakeCheckCheckCompletion::n_calls = 0; FakeCheckCheckCompletion::n_calls = 0;
CCheckQueueControl<FakeCheckCheckCompletion> control(small_queue.get()); CCheckQueueControl<FakeCheckCheckCompletion> control(small_queue.get());
while (total) { while (total) {
vChecks.resize(std::min(total, (size_t) insecure_randrange(10))); vChecks.resize(std::min(total, (size_t) InsecureRandRange(10)));
total -= vChecks.size(); total -= vChecks.size();
control.Add(vChecks); control.Add(vChecks);
} }
@ -204,7 +204,7 @@ BOOST_AUTO_TEST_CASE(test_CheckQueue_Correct_Random)
{ {
std::vector<size_t> range; std::vector<size_t> range;
range.reserve(100000/1000); range.reserve(100000/1000);
for (size_t i = 2; i < 100000; i += std::max((size_t)1, (size_t)insecure_randrange(std::min((size_t)1000, ((size_t)100000) - i)))) for (size_t i = 2; i < 100000; i += std::max((size_t)1, (size_t)InsecureRandRange(std::min((size_t)1000, ((size_t)100000) - i))))
range.push_back(i); range.push_back(i);
Correct_Queue_range(range); Correct_Queue_range(range);
} }
@ -224,7 +224,7 @@ BOOST_AUTO_TEST_CASE(test_CheckQueue_Catches_Failure)
CCheckQueueControl<FailingCheck> control(fail_queue.get()); CCheckQueueControl<FailingCheck> control(fail_queue.get());
size_t remaining = i; size_t remaining = i;
while (remaining) { while (remaining) {
size_t r = insecure_randrange(10); size_t r = InsecureRandRange(10);
std::vector<FailingCheck> vChecks; std::vector<FailingCheck> vChecks;
vChecks.reserve(r); vChecks.reserve(r);
@ -286,7 +286,7 @@ BOOST_AUTO_TEST_CASE(test_CheckQueue_UniqueCheck)
{ {
CCheckQueueControl<UniqueCheck> control(queue.get()); CCheckQueueControl<UniqueCheck> control(queue.get());
while (total) { while (total) {
size_t r = insecure_randrange(10); size_t r = InsecureRandRange(10);
std::vector<UniqueCheck> vChecks; std::vector<UniqueCheck> vChecks;
for (size_t k = 0; k < r && total; k++) for (size_t k = 0; k < r && total; k++)
vChecks.emplace_back(--total); vChecks.emplace_back(--total);
@ -320,7 +320,7 @@ BOOST_AUTO_TEST_CASE(test_CheckQueue_Memory)
{ {
CCheckQueueControl<MemoryCheck> control(queue.get()); CCheckQueueControl<MemoryCheck> control(queue.get());
while (total) { while (total) {
size_t r = insecure_randrange(10); size_t r = InsecureRandRange(10);
std::vector<MemoryCheck> vChecks; std::vector<MemoryCheck> vChecks;
for (size_t k = 0; k < r && total; k++) { for (size_t k = 0; k < r && total; k++) {
total--; total--;

78
src/test/coins_tests.cpp
Unescape View File

@ -43,7 +43,7 @@ public:
return false; return false;
} }
coin = it->second; coin = it->second;
if (coin.IsSpent() && insecure_randbool() == 0) { if (coin.IsSpent() && InsecureRandBool() == 0) {
// Randomly return false in case of an empty entry. // Randomly return false in case of an empty entry.
return false; return false;
} }
@ -64,7 +64,7 @@ public:
if (it->second.flags & CCoinsCacheEntry::DIRTY) { if (it->second.flags & CCoinsCacheEntry::DIRTY) {
// Same optimization used in CCoinsViewDB is to only write dirty entries. // Same optimization used in CCoinsViewDB is to only write dirty entries.
map_[it->first] = it->second.coin; map_[it->first] = it->second.coin;
if (it->second.coin.IsSpent() && insecure_randrange(3) == 0) { if (it->second.coin.IsSpent() && InsecureRandRange(3) == 0) {
// Randomly delete empty entries on write. // Randomly delete empty entries on write.
map_.erase(it->first); map_.erase(it->first);
} }
@ -139,31 +139,31 @@ BOOST_AUTO_TEST_CASE(coins_cache_simulation_test)
std::vector<uint256> txids; std::vector<uint256> txids;
txids.resize(NUM_SIMULATION_ITERATIONS / 8); txids.resize(NUM_SIMULATION_ITERATIONS / 8);
for (unsigned int i = 0; i < txids.size(); i++) { for (unsigned int i = 0; i < txids.size(); i++) {
txids[i] = insecure_rand256(); txids[i] = InsecureRand256();
} }
for (unsigned int i = 0; i < NUM_SIMULATION_ITERATIONS; i++) { for (unsigned int i = 0; i < NUM_SIMULATION_ITERATIONS; i++) {
// Do a random modification. // Do a random modification.
{ {
uint256 txid = txids[insecure_randrange(txids.size())]; // txid we're going to modify in this iteration. uint256 txid = txids[InsecureRandRange(txids.size())]; // txid we're going to modify in this iteration.
Coin& coin = result[COutPoint(txid, 0)]; Coin& coin = result[COutPoint(txid, 0)];
const Coin& entry = (insecure_randrange(500) == 0) ? AccessByTxid(*stack.back(), txid) : stack.back()->AccessCoin(COutPoint(txid, 0)); const Coin& entry = (InsecureRandRange(500) == 0) ? AccessByTxid(*stack.back(), txid) : stack.back()->AccessCoin(COutPoint(txid, 0));
BOOST_CHECK(coin == entry); BOOST_CHECK(coin == entry);
if (insecure_randrange(5) == 0 || coin.IsSpent()) { if (InsecureRandRange(5) == 0 || coin.IsSpent()) {
Coin newcoin; Coin newcoin;
newcoin.out.nValue = insecure_rand(); newcoin.out.nValue = InsecureRand32();
newcoin.nHeight = 1; newcoin.nHeight = 1;
if (insecure_randrange(16) == 0 && coin.IsSpent()) { if (InsecureRandRange(16) == 0 && coin.IsSpent()) {
newcoin.out.scriptPubKey.assign(1 + insecure_randbits(6), OP_RETURN); newcoin.out.scriptPubKey.assign(1 + InsecureRandBits(6), OP_RETURN);
BOOST_CHECK(newcoin.out.scriptPubKey.IsUnspendable()); BOOST_CHECK(newcoin.out.scriptPubKey.IsUnspendable());
added_an_unspendable_entry = true; added_an_unspendable_entry = true;
} else { } else {
newcoin.out.scriptPubKey.assign(insecure_randbits(6), 0); // Random sizes so we can test memory usage accounting newcoin.out.scriptPubKey.assign(InsecureRandBits(6), 0); // Random sizes so we can test memory usage accounting
(coin.IsSpent() ? added_an_entry : updated_an_entry) = true; (coin.IsSpent() ? added_an_entry : updated_an_entry) = true;
coin = newcoin; coin = newcoin;
} }
stack.back()->AddCoin(COutPoint(txid, 0), std::move(newcoin), !coin.IsSpent() || insecure_rand() & 1); stack.back()->AddCoin(COutPoint(txid, 0), std::move(newcoin), !coin.IsSpent() || InsecureRand32() & 1);
} else { } else {
removed_an_entry = true; removed_an_entry = true;
coin.Clear(); coin.Clear();
@ -172,15 +172,15 @@ BOOST_AUTO_TEST_CASE(coins_cache_simulation_test)
} }
// One every 10 iterations, remove a random entry from the cache // One every 10 iterations, remove a random entry from the cache
if (insecure_randrange(10) == 0) { if (InsecureRandRange(10) == 0) {
COutPoint out(txids[insecure_rand() % txids.size()], 0); COutPoint out(txids[InsecureRand32() % txids.size()], 0);
int cacheid = insecure_rand() % stack.size(); int cacheid = InsecureRand32() % stack.size();
stack[cacheid]->Uncache(out); stack[cacheid]->Uncache(out);
uncached_an_entry |= !stack[cacheid]->HaveCoinInCache(out); uncached_an_entry |= !stack[cacheid]->HaveCoinInCache(out);
} }
// Once every 1000 iterations and at the end, verify the full cache. // Once every 1000 iterations and at the end, verify the full cache.
if (insecure_randrange(1000) == 1 || i == NUM_SIMULATION_ITERATIONS - 1) { if (InsecureRandRange(1000) == 1 || i == NUM_SIMULATION_ITERATIONS - 1) {
for (auto it = result.begin(); it != result.end(); it++) { for (auto it = result.begin(); it != result.end(); it++) {
bool have = stack.back()->HaveCoin(it->first); bool have = stack.back()->HaveCoin(it->first);
const Coin& coin = stack.back()->AccessCoin(it->first); const Coin& coin = stack.back()->AccessCoin(it->first);
@ -198,22 +198,22 @@ BOOST_AUTO_TEST_CASE(coins_cache_simulation_test)
} }
} }
if (insecure_randrange(100) == 0) { if (InsecureRandRange(100) == 0) {
// Every 100 iterations, flush an intermediate cache // Every 100 iterations, flush an intermediate cache
if (stack.size() > 1 && insecure_randbool() == 0) { if (stack.size() > 1 && InsecureRandBool() == 0) {
unsigned int flushIndex = insecure_randrange(stack.size() - 1); unsigned int flushIndex = InsecureRandRange(stack.size() - 1);
stack[flushIndex]->Flush(); stack[flushIndex]->Flush();
} }
} }
if (insecure_randrange(100) == 0) { if (InsecureRandRange(100) == 0) {
// Every 100 iterations, change the cache stack. // Every 100 iterations, change the cache stack.
if (stack.size() > 0 && insecure_randbool() == 0) { if (stack.size() > 0 && InsecureRandBool() == 0) {
//Remove the top cache //Remove the top cache
stack.back()->Flush(); stack.back()->Flush();
delete stack.back(); delete stack.back();
stack.pop_back(); stack.pop_back();
} }
if (stack.size() == 0 || (stack.size() < 4 && insecure_randbool())) { if (stack.size() == 0 || (stack.size() < 4 && InsecureRandBool())) {
//Add a new cache //Add a new cache
CCoinsView* tip = &base; CCoinsView* tip = &base;
if (stack.size() > 0) { if (stack.size() > 0) {
@ -253,7 +253,7 @@ UtxoData utxoData;
UtxoData::iterator FindRandomFrom(const std::set<COutPoint> &utxoSet) { UtxoData::iterator FindRandomFrom(const std::set<COutPoint> &utxoSet) {
assert(utxoSet.size()); assert(utxoSet.size());
auto utxoSetIt = utxoSet.lower_bound(COutPoint(insecure_rand256(), 0)); auto utxoSetIt = utxoSet.lower_bound(COutPoint(InsecureRand256(), 0));
if (utxoSetIt == utxoSet.end()) { if (utxoSetIt == utxoSet.end()) {
utxoSetIt = utxoSet.begin(); utxoSetIt = utxoSet.begin();
} }
@ -286,7 +286,7 @@ BOOST_AUTO_TEST_CASE(updatecoins_simulation_test)
std::set<COutPoint> utxoset; std::set<COutPoint> utxoset;
for (unsigned int i = 0; i < NUM_SIMULATION_ITERATIONS; i++) { for (unsigned int i = 0; i < NUM_SIMULATION_ITERATIONS; i++) {
uint32_t randiter = insecure_rand(); uint32_t randiter = InsecureRand32();
// 19/20 txs add a new transaction // 19/20 txs add a new transaction
if (randiter % 20 < 19) { if (randiter % 20 < 19) {
@ -294,14 +294,14 @@ BOOST_AUTO_TEST_CASE(updatecoins_simulation_test)
tx.vin.resize(1); tx.vin.resize(1);
tx.vout.resize(1); tx.vout.resize(1);
tx.vout[0].nValue = i; //Keep txs unique unless intended to duplicate tx.vout[0].nValue = i; //Keep txs unique unless intended to duplicate
tx.vout[0].scriptPubKey.assign(insecure_rand() & 0x3F, 0); // Random sizes so we can test memory usage accounting tx.vout[0].scriptPubKey.assign(InsecureRand32() & 0x3F, 0); // Random sizes so we can test memory usage accounting
unsigned int height = insecure_rand(); unsigned int height = InsecureRand32();
Coin old_coin; Coin old_coin;
// 2/20 times create a new coinbase // 2/20 times create a new coinbase
if (randiter % 20 < 2 || coinbase_coins.size() < 10) { if (randiter % 20 < 2 || coinbase_coins.size() < 10) {
// 1/10 of those times create a duplicate coinbase // 1/10 of those times create a duplicate coinbase
if (insecure_randrange(10) == 0 && coinbase_coins.size()) { if (InsecureRandRange(10) == 0 && coinbase_coins.size()) {
auto utxod = FindRandomFrom(coinbase_coins); auto utxod = FindRandomFrom(coinbase_coins);
// Reuse the exact same coinbase // Reuse the exact same coinbase
tx = std::get<0>(utxod->second); tx = std::get<0>(utxod->second);
@ -411,7 +411,7 @@ BOOST_AUTO_TEST_CASE(updatecoins_simulation_test)
} }
// Once every 1000 iterations and at the end, verify the full cache. // Once every 1000 iterations and at the end, verify the full cache.
if (insecure_randrange(1000) == 1 || i == NUM_SIMULATION_ITERATIONS - 1) { if (InsecureRandRange(1000) == 1 || i == NUM_SIMULATION_ITERATIONS - 1) {
for (auto it = result.begin(); it != result.end(); it++) { for (auto it = result.begin(); it != result.end(); it++) {
bool have = stack.back()->HaveCoin(it->first); bool have = stack.back()->HaveCoin(it->first);
const Coin& coin = stack.back()->AccessCoin(it->first); const Coin& coin = stack.back()->AccessCoin(it->first);
@ -421,31 +421,31 @@ BOOST_AUTO_TEST_CASE(updatecoins_simulation_test)
} }
// One every 10 iterations, remove a random entry from the cache // One every 10 iterations, remove a random entry from the cache
if (utxoset.size() > 1 && insecure_randrange(30) == 0) { if (utxoset.size() > 1 && InsecureRandRange(30) == 0) {
stack[insecure_rand() % stack.size()]->Uncache(FindRandomFrom(utxoset)->first); stack[InsecureRand32() % stack.size()]->Uncache(FindRandomFrom(utxoset)->first);
} }
if (disconnected_coins.size() > 1 && insecure_randrange(30) == 0) { if (disconnected_coins.size() > 1 && InsecureRandRange(30) == 0) {
stack[insecure_rand() % stack.size()]->Uncache(FindRandomFrom(disconnected_coins)->first); stack[InsecureRand32() % stack.size()]->Uncache(FindRandomFrom(disconnected_coins)->first);
} }
if (duplicate_coins.size() > 1 && insecure_randrange(30) == 0) { if (duplicate_coins.size() > 1 && InsecureRandRange(30) == 0) {
stack[insecure_rand() % stack.size()]->Uncache(FindRandomFrom(duplicate_coins)->first); stack[InsecureRand32() % stack.size()]->Uncache(FindRandomFrom(duplicate_coins)->first);
} }
if (insecure_randrange(100) == 0) { if (InsecureRandRange(100) == 0) {
// Every 100 iterations, flush an intermediate cache // Every 100 iterations, flush an intermediate cache
if (stack.size() > 1 && insecure_randbool() == 0) { if (stack.size() > 1 && InsecureRandBool() == 0) {
unsigned int flushIndex = insecure_randrange(stack.size() - 1); unsigned int flushIndex = InsecureRandRange(stack.size() - 1);
stack[flushIndex]->Flush(); stack[flushIndex]->Flush();
} }
} }
if (insecure_randrange(100) == 0) { if (InsecureRandRange(100) == 0) {
// Every 100 iterations, change the cache stack. // Every 100 iterations, change the cache stack.
if (stack.size() > 0 && insecure_randbool() == 0) { if (stack.size() > 0 && InsecureRandBool() == 0) {
stack.back()->Flush(); stack.back()->Flush();
delete stack.back(); delete stack.back();
stack.pop_back(); stack.pop_back();
} }
if (stack.size() == 0 || (stack.size() < 4 && insecure_randbool())) { if (stack.size() == 0 || (stack.size() < 4 && InsecureRandBool())) {
CCoinsView* tip = &base; CCoinsView* tip = &base;
if (stack.size() > 0) { if (stack.size() > 0) {
tip = stack.back(); tip = stack.back();

2
src/test/crypto_tests.cpp
Unescape View File

@ -38,7 +38,7 @@ void TestVector(const Hasher &h, const In &in, const Out &out) {
Hasher hasher(h); Hasher hasher(h);
size_t pos = 0; size_t pos = 0;
while (pos < in.size()) { while (pos < in.size()) {
size_t len = insecure_randrange((in.size() - pos + 1) / 2 + 1); size_t len = InsecureRandRange((in.size() - pos + 1) / 2 + 1);
hasher.Write((unsigned char*)&in[pos], len); hasher.Write((unsigned char*)&in[pos], len);
pos += len; pos += len;
if (pos > 0 && pos + 2 * out.size() > in.size() && pos < in.size()) { if (pos > 0 && pos + 2 * out.size() > in.size() && pos < in.size()) {

20
src/test/dbwrapper_tests.cpp
Unescape View File

@ -31,7 +31,7 @@ BOOST_AUTO_TEST_CASE(dbwrapper)
fs::path ph = fs::temp_directory_path() / fs::unique_path(); fs::path ph = fs::temp_directory_path() / fs::unique_path();
CDBWrapper dbw(ph, (1 << 20), true, false, obfuscate); CDBWrapper dbw(ph, (1 << 20), true, false, obfuscate);
char key = 'k'; char key = 'k';
uint256 in = insecure_rand256(); uint256 in = InsecureRand256();
uint256 res; uint256 res;
// Ensure that we're doing real obfuscation when obfuscate=true // Ensure that we're doing real obfuscation when obfuscate=true
@ -53,11 +53,11 @@ BOOST_AUTO_TEST_CASE(dbwrapper_batch)
CDBWrapper dbw(ph, (1 << 20), true, false, obfuscate); CDBWrapper dbw(ph, (1 << 20), true, false, obfuscate);
char key = 'i'; char key = 'i';
uint256 in = insecure_rand256(); uint256 in = InsecureRand256();
char key2 = 'j'; char key2 = 'j';
uint256 in2 = insecure_rand256(); uint256 in2 = InsecureRand256();
char key3 = 'k'; char key3 = 'k';
uint256 in3 = insecure_rand256(); uint256 in3 = InsecureRand256();
uint256 res; uint256 res;
CDBBatch batch(dbw); CDBBatch batch(dbw);
@ -91,10 +91,10 @@ BOOST_AUTO_TEST_CASE(dbwrapper_iterator)
// The two keys are intentionally chosen for ordering // The two keys are intentionally chosen for ordering
char key = 'j'; char key = 'j';
uint256 in = insecure_rand256(); uint256 in = InsecureRand256();
BOOST_CHECK(dbw.Write(key, in)); BOOST_CHECK(dbw.Write(key, in));
char key2 = 'k'; char key2 = 'k';
uint256 in2 = insecure_rand256(); uint256 in2 = InsecureRand256();
BOOST_CHECK(dbw.Write(key2, in2)); BOOST_CHECK(dbw.Write(key2, in2));
std::unique_ptr<CDBIterator> it(const_cast<CDBWrapper*>(&dbw)->NewIterator()); std::unique_ptr<CDBIterator> it(const_cast<CDBWrapper*>(&dbw)->NewIterator());
@ -132,7 +132,7 @@ BOOST_AUTO_TEST_CASE(existing_data_no_obfuscate)
// Set up a non-obfuscated wrapper to write some initial data. // Set up a non-obfuscated wrapper to write some initial data.
CDBWrapper* dbw = new CDBWrapper(ph, (1 << 10), false, false, false); CDBWrapper* dbw = new CDBWrapper(ph, (1 << 10), false, false, false);
char key = 'k'; char key = 'k';
uint256 in = insecure_rand256(); uint256 in = InsecureRand256();
uint256 res; uint256 res;
BOOST_CHECK(dbw->Write(key, in)); BOOST_CHECK(dbw->Write(key, in));
@ -155,7 +155,7 @@ BOOST_AUTO_TEST_CASE(existing_data_no_obfuscate)
BOOST_CHECK(!odbw.IsEmpty()); // There should be existing data BOOST_CHECK(!odbw.IsEmpty()); // There should be existing data
BOOST_CHECK(is_null_key(dbwrapper_private::GetObfuscateKey(odbw))); // The key should be an empty string BOOST_CHECK(is_null_key(dbwrapper_private::GetObfuscateKey(odbw))); // The key should be an empty string
uint256 in2 = insecure_rand256(); uint256 in2 = InsecureRand256();
uint256 res3; uint256 res3;
// Check that we can write successfully // Check that we can write successfully
@ -174,7 +174,7 @@ BOOST_AUTO_TEST_CASE(existing_data_reindex)
// Set up a non-obfuscated wrapper to write some initial data. // Set up a non-obfuscated wrapper to write some initial data.
CDBWrapper* dbw = new CDBWrapper(ph, (1 << 10), false, false, false); CDBWrapper* dbw = new CDBWrapper(ph, (1 << 10), false, false, false);
char key = 'k'; char key = 'k';
uint256 in = insecure_rand256(); uint256 in = InsecureRand256();
uint256 res; uint256 res;
BOOST_CHECK(dbw->Write(key, in)); BOOST_CHECK(dbw->Write(key, in));
@ -193,7 +193,7 @@ BOOST_AUTO_TEST_CASE(existing_data_reindex)
BOOST_CHECK(!odbw.Read(key, res2)); BOOST_CHECK(!odbw.Read(key, res2));
BOOST_CHECK(!is_null_key(dbwrapper_private::GetObfuscateKey(odbw))); BOOST_CHECK(!is_null_key(dbwrapper_private::GetObfuscateKey(odbw)));
uint256 in2 = insecure_rand256(); uint256 in2 = InsecureRand256();
uint256 res3; uint256 res3;
// Check that we can write successfully // Check that we can write successfully

2
src/test/hash_tests.cpp
Unescape View File

@ -134,7 +134,7 @@ BOOST_AUTO_TEST_CASE(siphash)
for (int i = 0; i < 16; ++i) { for (int i = 0; i < 16; ++i) {
uint64_t k1 = ctx.rand64(); uint64_t k1 = ctx.rand64();
uint64_t k2 = ctx.rand64(); uint64_t k2 = ctx.rand64();
uint256 x = insecure_rand256(); uint256 x = InsecureRand256();
uint32_t n = ctx.rand32(); uint32_t n = ctx.rand32();
uint8_t nb[4]; uint8_t nb[4];
WriteLE32(nb, n); WriteLE32(nb, n);

4
src/test/merkle_tests.cpp
Unescape View File

@ -67,7 +67,7 @@ BOOST_AUTO_TEST_CASE(merkle_test)
{ {
for (int i = 0; i < 32; i++) { for (int i = 0; i < 32; i++) {
// Try 32 block sizes: all sizes from 0 to 16 inclusive, and then 15 random sizes. // Try 32 block sizes: all sizes from 0 to 16 inclusive, and then 15 random sizes.
int ntx = (i <= 16) ? i : 17 + (insecure_randrange(4000)); int ntx = (i <= 16) ? i : 17 + (InsecureRandRange(4000));
// Try up to 3 mutations. // Try up to 3 mutations.
for (int mutate = 0; mutate <= 3; mutate++) { for (int mutate = 0; mutate <= 3; mutate++) {
int duplicate1 = mutate >= 1 ? 1 << ctz(ntx) : 0; // The last how many transactions to duplicate first. int duplicate1 = mutate >= 1 ? 1 << ctz(ntx) : 0; // The last how many transactions to duplicate first.
@ -120,7 +120,7 @@ BOOST_AUTO_TEST_CASE(merkle_test)
// If ntx <= 16, try all branches. Otherwise, try 16 random ones. // If ntx <= 16, try all branches. Otherwise, try 16 random ones.
int mtx = loop; int mtx = loop;
if (ntx > 16) { if (ntx > 16) {
mtx = insecure_randrange(ntx); mtx = InsecureRandRange(ntx);
} }
std::vector<uint256> newBranch = BlockMerkleBranch(block, mtx); std::vector<uint256> newBranch = BlockMerkleBranch(block, mtx);
std::vector<uint256> oldBranch = BlockGetMerkleBranch(block, merkleTree, mtx); std::vector<uint256> oldBranch = BlockGetMerkleBranch(block, merkleTree, mtx);

4
src/test/miner_tests.cpp
Unescape View File

@ -372,7 +372,7 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
while (chainActive.Tip()->nHeight < 209999) { while (chainActive.Tip()->nHeight < 209999) {
CBlockIndex* prev = chainActive.Tip(); CBlockIndex* prev = chainActive.Tip();
CBlockIndex* next = new CBlockIndex(); CBlockIndex* next = new CBlockIndex();
next->phashBlock = new uint256(insecure_rand256()); next->phashBlock = new uint256(InsecureRand256());
pcoinsTip->SetBestBlock(next->GetBlockHash()); pcoinsTip->SetBestBlock(next->GetBlockHash());
next->pprev = prev; next->pprev = prev;
next->nHeight = prev->nHeight + 1; next->nHeight = prev->nHeight + 1;
@ -384,7 +384,7 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
while (chainActive.Tip()->nHeight < 210000) { while (chainActive.Tip()->nHeight < 210000) {
CBlockIndex* prev = chainActive.Tip(); CBlockIndex* prev = chainActive.Tip();
CBlockIndex* next = new CBlockIndex(); CBlockIndex* next = new CBlockIndex();
next->phashBlock = new uint256(insecure_rand256()); next->phashBlock = new uint256(InsecureRand256());
pcoinsTip->SetBestBlock(next->GetBlockHash()); pcoinsTip->SetBestBlock(next->GetBlockHash());
next->pprev = prev; next->pprev = prev;
next->nHeight = prev->nHeight + 1; next->nHeight = prev->nHeight + 1;

8
src/test/pmt_tests.cpp
Unescape View File

@ -21,8 +21,8 @@ class CPartialMerkleTreeTester : public CPartialMerkleTree
public: public:
// flip one bit in one of the hashes - this should break the authentication // flip one bit in one of the hashes - this should break the authentication
void Damage() { void Damage() {
unsigned int n = insecure_randrange(vHash.size()); unsigned int n = InsecureRandRange(vHash.size());
int bit = insecure_randbits(8); int bit = InsecureRandBits(8);
*(vHash[n].begin() + (bit>>3)) ^= 1<<(bit&7); *(vHash[n].begin() + (bit>>3)) ^= 1<<(bit&7);
} }
}; };
@ -31,7 +31,7 @@ BOOST_FIXTURE_TEST_SUITE(pmt_tests, BasicTestingSetup)
BOOST_AUTO_TEST_CASE(pmt_test1) BOOST_AUTO_TEST_CASE(pmt_test1)
{ {
seed_insecure_rand(false); SeedInsecureRand(false);
static const unsigned int nTxCounts[] = {1, 4, 7, 17, 56, 100, 127, 256, 312, 513, 1000, 4095}; static const unsigned int nTxCounts[] = {1, 4, 7, 17, 56, 100, 127, 256, 312, 513, 1000, 4095};
for (int i = 0; i < 12; i++) { for (int i = 0; i < 12; i++) {
@ -62,7 +62,7 @@ BOOST_AUTO_TEST_CASE(pmt_test1)
std::vector<bool> vMatch(nTx, false); std::vector<bool> vMatch(nTx, false);
std::vector<uint256> vMatchTxid1; std::vector<uint256> vMatchTxid1;
for (unsigned int j=0; j<nTx; j++) { for (unsigned int j=0; j<nTx; j++) {
bool fInclude = insecure_randbits(att / 2) == 0; bool fInclude = InsecureRandBits(att / 2) == 0;
vMatch[j] = fInclude; vMatch[j] = fInclude;
if (fInclude) if (fInclude)
vMatchTxid1.push_back(vTxid[j]); vMatchTxid1.push_back(vTxid[j]);

6
src/test/pow_tests.cpp
Unescape View File

@ -74,9 +74,9 @@ BOOST_AUTO_TEST_CASE(GetBlockProofEquivalentTime_test)
} }
for (int j = 0; j < 1000; j++) { for (int j = 0; j < 1000; j++) {
CBlockIndex *p1 = &blocks[insecure_randrange(10000)]; CBlockIndex *p1 = &blocks[InsecureRandRange(10000)];
CBlockIndex *p2 = &blocks[insecure_randrange(10000)]; CBlockIndex *p2 = &blocks[InsecureRandRange(10000)];
CBlockIndex *p3 = &blocks[insecure_randrange(10000)]; CBlockIndex *p3 = &blocks[InsecureRandRange(10000)];
int64_t tdiff = GetBlockProofEquivalentTime(*p1, *p2, *p3, chainParams->GetConsensus()); int64_t tdiff = GetBlockProofEquivalentTime(*p1, *p2, *p3, chainParams->GetConsensus());
BOOST_CHECK_EQUAL(tdiff, p1->GetBlockTime() - p2->GetBlockTime()); BOOST_CHECK_EQUAL(tdiff, p1->GetBlockTime() - p2->GetBlockTime());

64
src/test/prevector_tests.cpp
Unescape View File

@ -187,7 +187,7 @@ public:
} }
prevector_tester() { prevector_tester() {
seed_insecure_rand(); SeedInsecureRand();
rand_seed = insecure_rand_seed; rand_seed = insecure_rand_seed;
rand_cache = insecure_rand_ctx; rand_cache = insecure_rand_ctx;
} }
@ -198,65 +198,65 @@ BOOST_AUTO_TEST_CASE(PrevectorTestInt)
for (int j = 0; j < 64; j++) { for (int j = 0; j < 64; j++) {
prevector_tester<8, int> test; prevector_tester<8, int> test;
for (int i = 0; i < 2048; i++) { for (int i = 0; i < 2048; i++) {
if (insecure_randbits(2) == 0) { if (InsecureRandBits(2) == 0) {
test.insert(insecure_randrange(test.size() + 1), insecure_rand()); test.insert(InsecureRandRange(test.size() + 1), InsecureRand32());
} }
if (test.size() > 0 && insecure_randbits(2) == 1) { if (test.size() > 0 && InsecureRandBits(2) == 1) {
test.erase(insecure_randrange(test.size())); test.erase(InsecureRandRange(test.size()));
} }
if (insecure_randbits(3) == 2) { if (InsecureRandBits(3) == 2) {
int new_size = std::max<int>(0, std::min<int>(30, test.size() + (insecure_randrange(5)) - 2)); int new_size = std::max<int>(0, std::min<int>(30, test.size() + (InsecureRandRange(5)) - 2));
test.resize(new_size); test.resize(new_size);
} }
if (insecure_randbits(3) == 3) { if (InsecureRandBits(3) == 3) {
test.insert(insecure_randrange(test.size() + 1), 1 + insecure_randbool(), insecure_rand()); test.insert(InsecureRandRange(test.size() + 1), 1 + InsecureRandBool(), InsecureRand32());
} }
if (insecure_randbits(3) == 4) { if (InsecureRandBits(3) == 4) {
int del = std::min<int>(test.size(), 1 + (insecure_randbool())); int del = std::min<int>(test.size(), 1 + (InsecureRandBool()));
int beg = insecure_randrange(test.size() + 1 - del); int beg = InsecureRandRange(test.size() + 1 - del);
test.erase(beg, beg + del); test.erase(beg, beg + del);
} }
if (insecure_randbits(4) == 5) { if (InsecureRandBits(4) == 5) {
test.push_back(insecure_rand()); test.push_back(InsecureRand32());
} }
if (test.size() > 0 && insecure_randbits(4) == 6) { if (test.size() > 0 && InsecureRandBits(4) == 6) {
test.pop_back(); test.pop_back();
} }
if (insecure_randbits(5) == 7) { if (InsecureRandBits(5) == 7) {
int values[4]; int values[4];
int num = 1 + (insecure_randbits(2)); int num = 1 + (InsecureRandBits(2));
for (int k = 0; k < num; k++) { for (int k = 0; k < num; k++) {
values[k] = insecure_rand(); values[k] = InsecureRand32();
} }
test.insert_range(insecure_randrange(test.size() + 1), values, values + num); test.insert_range(InsecureRandRange(test.size() + 1), values, values + num);
} }
if (insecure_randbits(5) == 8) { if (InsecureRandBits(5) == 8) {
int del = std::min<int>(test.size(), 1 + (insecure_randbits(2))); int del = std::min<int>(test.size(), 1 + (InsecureRandBits(2)));
int beg = insecure_randrange(test.size() + 1 - del); int beg = InsecureRandRange(test.size() + 1 - del);
test.erase(beg, beg + del); test.erase(beg, beg + del);
} }
if (insecure_randbits(5) == 9) { if (InsecureRandBits(5) == 9) {
test.reserve(insecure_randbits(5)); test.reserve(InsecureRandBits(5));
} }
if (insecure_randbits(6) == 10) { if (InsecureRandBits(6) == 10) {
test.shrink_to_fit(); test.shrink_to_fit();
} }
if (test.size() > 0) { if (test.size() > 0) {
test.update(insecure_randrange(test.size()), insecure_rand()); test.update(InsecureRandRange(test.size()), InsecureRand32());
} }
if (insecure_randbits(10) == 11) { if (InsecureRandBits(10) == 11) {
test.clear(); test.clear();
} }
if (insecure_randbits(9) == 12) { if (InsecureRandBits(9) == 12) {
test.assign(insecure_randbits(5), insecure_rand()); test.assign(InsecureRandBits(5), InsecureRand32());
} }
if (insecure_randbits(3) == 3) { if (InsecureRandBits(3) == 3) {
test.swap(); test.swap();
} }
if (insecure_randbits(4) == 8) { if (InsecureRandBits(4) == 8) {
test.copy(); test.copy();
} }
if (insecure_randbits(5) == 18) { if (InsecureRandBits(5) == 18) {
test.move(); test.move();
} }
} }

26
src/test/sighash_tests.cpp
Unescape View File

@ -89,30 +89,30 @@ uint256 static SignatureHashOld(CScript scriptCode, const CTransaction& txTo, un
void static RandomScript(CScript &script) { void static RandomScript(CScript &script) {
static const opcodetype oplist[] = {OP_FALSE, OP_1, OP_2, OP_3, OP_CHECKSIG, OP_IF, OP_VERIF, OP_RETURN, OP_CODESEPARATOR}; static const opcodetype oplist[] = {OP_FALSE, OP_1, OP_2, OP_3, OP_CHECKSIG, OP_IF, OP_VERIF, OP_RETURN, OP_CODESEPARATOR};
script = CScript(); script = CScript();
int ops = (insecure_randrange(10)); int ops = (InsecureRandRange(10));
for (int i=0; i<ops; i++) for (int i=0; i<ops; i++)
script << oplist[insecure_randrange(sizeof(oplist)/sizeof(oplist[0]))]; script << oplist[InsecureRandRange(sizeof(oplist)/sizeof(oplist[0]))];
} }
void static RandomTransaction(CMutableTransaction &tx, bool fSingle) { void static RandomTransaction(CMutableTransaction &tx, bool fSingle) {
tx.nVersion = insecure_rand(); tx.nVersion = InsecureRand32();
tx.vin.clear(); tx.vin.clear();
tx.vout.clear(); tx.vout.clear();
tx.nLockTime = (insecure_randbool()) ? insecure_rand() : 0; tx.nLockTime = (InsecureRandBool()) ? InsecureRand32() : 0;
int ins = (insecure_randbits(2)) + 1; int ins = (InsecureRandBits(2)) + 1;
int outs = fSingle ? ins : (insecure_randbits(2)) + 1; int outs = fSingle ? ins : (InsecureRandBits(2)) + 1;
for (int in = 0; in < ins; in++) { for (int in = 0; in < ins; in++) {
tx.vin.push_back(CTxIn()); tx.vin.push_back(CTxIn());
CTxIn &txin = tx.vin.back(); CTxIn &txin = tx.vin.back();
txin.prevout.hash = insecure_rand256(); txin.prevout.hash = InsecureRand256();
txin.prevout.n = insecure_randbits(2); txin.prevout.n = InsecureRandBits(2);
RandomScript(txin.scriptSig); RandomScript(txin.scriptSig);
txin.nSequence = (insecure_randbool()) ? insecure_rand() : (unsigned int)-1; txin.nSequence = (InsecureRandBool()) ? InsecureRand32() : (unsigned int)-1;
} }
for (int out = 0; out < outs; out++) { for (int out = 0; out < outs; out++) {
tx.vout.push_back(CTxOut()); tx.vout.push_back(CTxOut());
CTxOut &txout = tx.vout.back(); CTxOut &txout = tx.vout.back();
txout.nValue = insecure_randrange(100000000); txout.nValue = InsecureRandRange(100000000);
RandomScript(txout.scriptPubKey); RandomScript(txout.scriptPubKey);
} }
} }
@ -121,7 +121,7 @@ BOOST_FIXTURE_TEST_SUITE(sighash_tests, BasicTestingSetup)
BOOST_AUTO_TEST_CASE(sighash_test) BOOST_AUTO_TEST_CASE(sighash_test)
{ {
seed_insecure_rand(false); SeedInsecureRand(false);
#if defined(PRINT_SIGHASH_JSON) #if defined(PRINT_SIGHASH_JSON)
std::cout << "[\n"; std::cout << "[\n";
@ -133,12 +133,12 @@ BOOST_AUTO_TEST_CASE(sighash_test)
nRandomTests = 500; nRandomTests = 500;
#endif #endif
for (int i=0; i<nRandomTests; i++) { for (int i=0; i<nRandomTests; i++) {
int nHashType = insecure_rand(); int nHashType = InsecureRand32();
CMutableTransaction txTo; CMutableTransaction txTo;
RandomTransaction(txTo, (nHashType & 0x1f) == SIGHASH_SINGLE); RandomTransaction(txTo, (nHashType & 0x1f) == SIGHASH_SINGLE);
CScript scriptCode; CScript scriptCode;
RandomScript(scriptCode); RandomScript(scriptCode);
int nIn = insecure_randrange(txTo.vin.size()); int nIn = InsecureRandRange(txTo.vin.size());
uint256 sh, sho; uint256 sh, sho;
sho = SignatureHashOld(scriptCode, txTo, nIn, nHashType); sho = SignatureHashOld(scriptCode, txTo, nIn, nHashType);

10
src/test/skiplist_tests.cpp
Unescape View File

@ -34,8 +34,8 @@ BOOST_AUTO_TEST_CASE(skiplist_test)
} }
for (int i=0; i < 1000; i++) { for (int i=0; i < 1000; i++) {
int from = insecure_randrange(SKIPLIST_LENGTH - 1); int from = InsecureRandRange(SKIPLIST_LENGTH - 1);
int to = insecure_randrange(from + 1); int to = InsecureRandRange(from + 1);
BOOST_CHECK(vIndex[SKIPLIST_LENGTH - 1].GetAncestor(from) == &vIndex[from]); BOOST_CHECK(vIndex[SKIPLIST_LENGTH - 1].GetAncestor(from) == &vIndex[from]);
BOOST_CHECK(vIndex[from].GetAncestor(to) == &vIndex[to]); BOOST_CHECK(vIndex[from].GetAncestor(to) == &vIndex[to]);
@ -77,7 +77,7 @@ BOOST_AUTO_TEST_CASE(getlocator_test)
// Test 100 random starting points for locators. // Test 100 random starting points for locators.
for (int n=0; n<100; n++) { for (int n=0; n<100; n++) {
int r = insecure_randrange(150000); int r = InsecureRandRange(150000);
CBlockIndex* tip = (r < 100000) ? &vBlocksMain[r] : &vBlocksSide[r - 100000]; CBlockIndex* tip = (r < 100000) ? &vBlocksMain[r] : &vBlocksSide[r - 100000];
CBlockLocator locator = chain.GetLocator(tip); CBlockLocator locator = chain.GetLocator(tip);
@ -115,7 +115,7 @@ BOOST_AUTO_TEST_CASE(findearliestatleast_test)
} else { } else {
// randomly choose something in the range [MTP, MTP*2] // randomly choose something in the range [MTP, MTP*2]
int64_t medianTimePast = vBlocksMain[i].GetMedianTimePast(); int64_t medianTimePast = vBlocksMain[i].GetMedianTimePast();
int r = insecure_randrange(medianTimePast); int r = InsecureRandRange(medianTimePast);
vBlocksMain[i].nTime = r + medianTimePast; vBlocksMain[i].nTime = r + medianTimePast;
vBlocksMain[i].nTimeMax = std::max(vBlocksMain[i].nTime, vBlocksMain[i-1].nTimeMax); 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. // Verify that FindEarliestAtLeast is correct.
for (unsigned int i=0; i<10000; ++i) { for (unsigned int i=0; i<10000; ++i) {
// Pick a random element in vBlocksMain. // Pick a random element in vBlocksMain.
int r = insecure_randrange(vBlocksMain.size()); int r = InsecureRandRange(vBlocksMain.size());
int64_t test_time = vBlocksMain[r].nTime; int64_t test_time = vBlocksMain[r].nTime;
CBlockIndex *ret = chain.FindEarliestAtLeast(test_time); CBlockIndex *ret = chain.FindEarliestAtLeast(test_time);
BOOST_CHECK(ret->nTimeMax >= test_time); BOOST_CHECK(ret->nTimeMax >= test_time);

2
src/test/test_bitcoin.cpp
Unescape View File

@ -59,7 +59,7 @@ TestingSetup::TestingSetup(const std::string& chainName) : BasicTestingSetup(cha
RegisterAllCoreRPCCommands(tableRPC); RegisterAllCoreRPCCommands(tableRPC);
ClearDatadirCache(); ClearDatadirCache();
pathTemp = GetTempPath() / strprintf("test_bitcoin_%lu_%i", (unsigned long)GetTime(), (int)(insecure_randrange(100000))); pathTemp = GetTempPath() / strprintf("test_bitcoin_%lu_%i", (unsigned long)GetTime(), (int)(InsecureRandRange(100000)));
fs::create_directories(pathTemp); fs::create_directories(pathTemp);
ForceSetArg("-datadir", pathTemp.string()); ForceSetArg("-datadir", pathTemp.string());
mempool.setSanityCheck(1.0); mempool.setSanityCheck(1.0);

14
src/test/test_bitcoin.h
Unescape View File

@ -18,7 +18,7 @@
extern uint256 insecure_rand_seed; extern uint256 insecure_rand_seed;
extern FastRandomContext insecure_rand_ctx; extern FastRandomContext insecure_rand_ctx;
static inline void seed_insecure_rand(bool fDeterministic = false) static inline void SeedInsecureRand(bool fDeterministic = false)
{ {
if (fDeterministic) { if (fDeterministic) {
insecure_rand_seed = uint256(); insecure_rand_seed = uint256();
@ -28,12 +28,12 @@ static inline void seed_insecure_rand(bool fDeterministic = false)
insecure_rand_ctx = FastRandomContext(insecure_rand_seed); insecure_rand_ctx = FastRandomContext(insecure_rand_seed);
} }
static inline uint32_t insecure_rand() { return insecure_rand_ctx.rand32(); } static inline uint32_t InsecureRand32() { return insecure_rand_ctx.rand32(); }
static inline uint256 insecure_rand256() { return insecure_rand_ctx.rand256(); } static inline uint256 InsecureRand256() { return insecure_rand_ctx.rand256(); }
static inline uint64_t insecure_randbits(int bits) { return insecure_rand_ctx.randbits(bits); } static inline uint64_t InsecureRandBits(int bits) { return insecure_rand_ctx.randbits(bits); }
static inline uint64_t insecure_randrange(uint64_t range) { return insecure_rand_ctx.randrange(range); } static inline uint64_t InsecureRandRange(uint64_t range) { return insecure_rand_ctx.randrange(range); }
static inline bool insecure_randbool() { return insecure_rand_ctx.randbool(); } static inline bool InsecureRandBool() { return insecure_rand_ctx.randbool(); }
static inline std::vector<unsigned char> insecure_randbytes(size_t len) { return insecure_rand_ctx.randbytes(len); } static inline std::vector<unsigned char> InsecureRandBytes(size_t len) { return insecure_rand_ctx.randbytes(len); }
/** Basic testing setup. /** Basic testing setup.
* This just configures logging and chain parameters. * This just configures logging and chain parameters.

4
src/test/util_tests.cpp
Unescape View File

@ -255,7 +255,7 @@ BOOST_AUTO_TEST_CASE(util_IsHex)
BOOST_AUTO_TEST_CASE(util_seed_insecure_rand) BOOST_AUTO_TEST_CASE(util_seed_insecure_rand)
{ {
seed_insecure_rand(true); SeedInsecureRand(true);
for (int mod=2;mod<11;mod++) for (int mod=2;mod<11;mod++)
{ {
int mask = 1; int mask = 1;
@ -269,7 +269,7 @@ BOOST_AUTO_TEST_CASE(util_seed_insecure_rand)
for (int i = 0; i < 10000; i++) { for (int i = 0; i < 10000; i++) {
uint32_t rval; uint32_t rval;
do{ do{
rval=insecure_rand()&mask; rval=InsecureRand32()&mask;
}while(rval>=(uint32_t)mod); }while(rval>=(uint32_t)mod);
count += rval==0; count += rval==0;
} }

12
src/test/versionbits_tests.cpp
Unescape View File

@ -80,7 +80,7 @@ public:
VersionBitsTester& TestStateSinceHeight(int height) { VersionBitsTester& TestStateSinceHeight(int height) {
for (int i = 0; i < CHECKERS; i++) { for (int i = 0; i < CHECKERS; i++) {
if (insecure_randbits(i) == 0) { if (InsecureRandBits(i) == 0) {
BOOST_CHECK_MESSAGE(checker[i].GetStateSinceHeightFor(vpblock.empty() ? NULL : vpblock.back()) == height, strprintf("Test %i for StateSinceHeight", num)); BOOST_CHECK_MESSAGE(checker[i].GetStateSinceHeightFor(vpblock.empty() ? NULL : vpblock.back()) == height, strprintf("Test %i for StateSinceHeight", num));
} }
} }
@ -90,7 +90,7 @@ public:
VersionBitsTester& TestDefined() { VersionBitsTester& TestDefined() {
for (int i = 0; i < CHECKERS; i++) { for (int i = 0; i < CHECKERS; i++) {
if (insecure_randbits(i) == 0) { if (InsecureRandBits(i) == 0) {
BOOST_CHECK_MESSAGE(checker[i].GetStateFor(vpblock.empty() ? NULL : vpblock.back()) == THRESHOLD_DEFINED, strprintf("Test %i for DEFINED", num)); BOOST_CHECK_MESSAGE(checker[i].GetStateFor(vpblock.empty() ? NULL : vpblock.back()) == THRESHOLD_DEFINED, strprintf("Test %i for DEFINED", num));
} }
} }
@ -100,7 +100,7 @@ public:
VersionBitsTester& TestStarted() { VersionBitsTester& TestStarted() {
for (int i = 0; i < CHECKERS; i++) { for (int i = 0; i < CHECKERS; i++) {
if (insecure_randbits(i) == 0) { if (InsecureRandBits(i) == 0) {
BOOST_CHECK_MESSAGE(checker[i].GetStateFor(vpblock.empty() ? NULL : vpblock.back()) == THRESHOLD_STARTED, strprintf("Test %i for STARTED", num)); BOOST_CHECK_MESSAGE(checker[i].GetStateFor(vpblock.empty() ? NULL : vpblock.back()) == THRESHOLD_STARTED, strprintf("Test %i for STARTED", num));
} }
} }
@ -110,7 +110,7 @@ public:
VersionBitsTester& TestLockedIn() { VersionBitsTester& TestLockedIn() {
for (int i = 0; i < CHECKERS; i++) { for (int i = 0; i < CHECKERS; i++) {
if (insecure_randbits(i) == 0) { if (InsecureRandBits(i) == 0) {
BOOST_CHECK_MESSAGE(checker[i].GetStateFor(vpblock.empty() ? NULL : vpblock.back()) == THRESHOLD_LOCKED_IN, strprintf("Test %i for LOCKED_IN", num)); BOOST_CHECK_MESSAGE(checker[i].GetStateFor(vpblock.empty() ? NULL : vpblock.back()) == THRESHOLD_LOCKED_IN, strprintf("Test %i for LOCKED_IN", num));
} }
} }
@ -120,7 +120,7 @@ public:
VersionBitsTester& TestActive() { VersionBitsTester& TestActive() {
for (int i = 0; i < CHECKERS; i++) { for (int i = 0; i < CHECKERS; i++) {
if (insecure_randbits(i) == 0) { if (InsecureRandBits(i) == 0) {
BOOST_CHECK_MESSAGE(checker[i].GetStateFor(vpblock.empty() ? NULL : vpblock.back()) == THRESHOLD_ACTIVE, strprintf("Test %i for ACTIVE", num)); BOOST_CHECK_MESSAGE(checker[i].GetStateFor(vpblock.empty() ? NULL : vpblock.back()) == THRESHOLD_ACTIVE, strprintf("Test %i for ACTIVE", num));
} }
} }
@ -130,7 +130,7 @@ public:
VersionBitsTester& TestFailed() { VersionBitsTester& TestFailed() {
for (int i = 0; i < CHECKERS; i++) { for (int i = 0; i < CHECKERS; i++) {
if (insecure_randbits(i) == 0) { if (InsecureRandBits(i) == 0) {
BOOST_CHECK_MESSAGE(checker[i].GetStateFor(vpblock.empty() ? NULL : vpblock.back()) == THRESHOLD_FAILED, strprintf("Test %i for FAILED", num)); BOOST_CHECK_MESSAGE(checker[i].GetStateFor(vpblock.empty() ? NULL : vpblock.back()) == THRESHOLD_FAILED, strprintf("Test %i for FAILED", num));
} }
} }

2
src/wallet/test/crypto_tests.cpp
Unescape View File

@ -192,7 +192,7 @@ BOOST_AUTO_TEST_CASE(passphrase) {
std::string hash(GetRandHash().ToString()); std::string hash(GetRandHash().ToString());
std::vector<unsigned char> vchSalt(8); std::vector<unsigned char> vchSalt(8);
GetRandBytes(&vchSalt[0], vchSalt.size()); GetRandBytes(&vchSalt[0], vchSalt.size());
uint32_t rounds = insecure_rand(); uint32_t rounds = InsecureRand32();
if (rounds > 30000) if (rounds > 30000)
rounds = 30000; rounds = 30000;
TestCrypter::TestPassphrase(vchSalt, SecureString(hash.begin(), hash.end()), rounds); TestCrypter::TestPassphrase(vchSalt, SecureString(hash.begin(), hash.end()), rounds);

Write Preview
Loading…
Cancel
Save