108 lines
4.2 KiB
C++
108 lines
4.2 KiB
C++
// Copyright (c) 2014-2018 Zano Project
|
|
// Copyright (c) 2014-2018 The Louisdor Project
|
|
// Distributed under the MIT/X11 software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#include "chaingen.h"
|
|
#include "random_helper.h"
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool random_state_manupulation_test()
|
|
{
|
|
// This test checks that random generator can be manipulated by random_helper routines in predictable way.
|
|
// NOTE: If the test fails, it's most likely that random state permutation procedure was changed OR the state can't be correctly stored/loaded.
|
|
|
|
static const uint64_t my_own_random_seed = 4669201609102990671;
|
|
static const char* my_random_str = "760af2b78894c6a441731e2b354011da6ac98ddc";
|
|
static const size_t rnd_buf_len = 20;
|
|
|
|
uint64_t first_random_after_state_saved = 0;
|
|
{
|
|
random_state_test_restorer rstr; // <- here random state is saved
|
|
first_random_after_state_saved = crypto::rand<uint64_t>();
|
|
|
|
random_state_test_restorer::reset_random(my_own_random_seed); // random seeded, entering deterministic mode...
|
|
|
|
std::string rnd_buf(rnd_buf_len, '\x00');
|
|
for (size_t i = 0; i < rnd_buf_len; ++i)
|
|
rnd_buf[i] = crypto::rand<char>();
|
|
|
|
std::string hex = epee::string_tools::buff_to_hex_nodelimer(rnd_buf);
|
|
CHECK_AND_ASSERT_MES(hex == my_random_str, false, "Incorrect random data after seeding. Expected: " << my_random_str << " Fetched: " << hex);
|
|
|
|
// here rstr dtor is called and random state should be restored
|
|
}
|
|
|
|
// make sure random state is correctly restored
|
|
uint64_t first_random_after_state_restored = crypto::rand<uint64_t>();
|
|
CHECK_AND_ASSERT_MES(first_random_after_state_saved == first_random_after_state_restored, false, "Core random generator state wasn't restored correctly");
|
|
|
|
return true;
|
|
}
|
|
|
|
bool check_random_evenness(size_t modulus = 11, size_t count = 10000, double allowed_deviation = 0.05)
|
|
{
|
|
std::vector<size_t> m;
|
|
m.resize(modulus);
|
|
for (size_t i = 0; i < count; ++i)
|
|
{
|
|
size_t r = crypto::rand<size_t>() % modulus;
|
|
++m[r];
|
|
}
|
|
|
|
double mean = 0;
|
|
double variance = 0;
|
|
for (size_t i = 0; i < modulus; ++i)
|
|
{
|
|
mean += static_cast<double>(i)* m[i] / count;
|
|
variance += static_cast<double>(i)* i * m[i] / count;
|
|
}
|
|
variance -= mean * mean;
|
|
|
|
double estimated_mean = (static_cast<double>(modulus)-1) / 2;
|
|
double estimated_variance = (static_cast<double>(modulus)* modulus - 1) / 12;
|
|
|
|
LOG_PRINT_L0("Random test for modulus " << modulus << ", trials count " << count << std::endl <<
|
|
"Estimated mean: " << std::fixed << std::setw(10) << std::setprecision(5) << estimated_mean << " Mean: " << std::fixed << std::setw(10) << std::setprecision(5) << mean << std::endl <<
|
|
"Estimated variance: " << std::fixed << std::setw(10) << std::setprecision(5) << estimated_variance << " Variance: " << std::fixed << std::setw(10) << std::setprecision(5) << variance);
|
|
|
|
CHECK_AND_ASSERT_MES(fabs(mean - estimated_mean) < allowed_deviation * estimated_mean, false, "Mean deviation is more than " << allowed_deviation);
|
|
CHECK_AND_ASSERT_MES(fabs(variance - estimated_variance) < allowed_deviation * estimated_variance, false, "Variance deviation is more than " << allowed_deviation);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool random_evenness_test()
|
|
{
|
|
bool r = true;
|
|
r = r & check_random_evenness(5, 10000);
|
|
r = r & check_random_evenness(11, 11000);
|
|
r = r & check_random_evenness(37, 50000);
|
|
r = r & check_random_evenness(97, 97000);
|
|
r = r & check_random_evenness(113, 113000);
|
|
return r;
|
|
}
|
|
|
|
bool get_random_text_test()
|
|
{
|
|
random_state_test_restorer rstr; // to restore random generator state afterwards
|
|
random_state_test_restorer::reset_random(0); // to make the test determinictic
|
|
|
|
TIME_MEASURE_START(time_total);
|
|
|
|
size_t max_len = 16 * 1024;
|
|
size_t trials_count = 500;
|
|
for (size_t i = 0; i < trials_count; ++i)
|
|
{
|
|
size_t sz = crypto::rand<size_t>() % max_len;
|
|
std::string r = get_random_text(sz);
|
|
CHECK_AND_ASSERT_MES(r.size() == sz, false, "get_random_text(" << sz << ") returned " << r.size() << " bytes:" << ENDL << r);
|
|
}
|
|
|
|
TIME_MEASURE_FINISH(time_total);
|
|
|
|
LOG_PRINT_L0("Random text test: trials: " << trials_count << ", total time: " << time_total << " ms.");
|
|
|
|
return true;
|
|
}
|