diff --git a/include/boost/random/detail/generator_bits.hpp b/include/boost/random/detail/generator_bits.hpp index 4846ff255..1bf6a0ba4 100644 --- a/include/boost/random/detail/generator_bits.hpp +++ b/include/boost/random/detail/generator_bits.hpp @@ -24,7 +24,7 @@ namespace detail { // compatibility. template struct generator_bits { - static std::size_t value() { + static int value() { return std::numeric_limits::digits; } }; diff --git a/include/boost/random/discrete_distribution.hpp b/include/boost/random/discrete_distribution.hpp index 877cbf2bd..847f735d4 100644 --- a/include/boost/random/discrete_distribution.hpp +++ b/include/boost/random/discrete_distribution.hpp @@ -456,7 +456,7 @@ class discrete_distribution { { sum += *iter; if(sum > val) { - return result; + return static_cast(result); } } // This shouldn't be reachable, but round-off error @@ -501,7 +501,7 @@ class discrete_distribution { { WeightType val = iter->first; result[i] += val; - result[static_cast(iter->second)] += _impl.get_weight(i) - val; + result[static_cast(iter->second)] += _impl.get_weight(static_cast(i)) - val; } impl_type::normalize(result); return(result); diff --git a/include/boost/random/mixmax.hpp b/include/boost/random/mixmax.hpp index 670b92a86..2a3945f8a 100644 --- a/include/boost/random/mixmax.hpp +++ b/include/boost/random/mixmax.hpp @@ -144,7 +144,7 @@ class mixmax_engine{ sum=me.MOD_MERSENNE(sum+v); } if (sum == savedsum && counter>0 && counter(counter); me.S.sumtot=savedsum; }else{ in.setstate(std::ios::failbit); } diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 015f456fa..2e1cd5262 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -25,14 +25,14 @@ if(HAVE_BOOST_TEST) foreach(part IN ITEMS ${parts}) if(part MATCHES "^[./a-zA-Z0-9_]+\.cpp+$") list(APPEND sources ${part}) - elseif(part STREQUAL "/boost/assign//boost_assign") - list(APPEND extra_libs Boost::assign) elseif(part STREQUAL "/boost/iterator//boost_iterator") list(APPEND extra_libs Boost::iterator) + elseif(part STREQUAL "/boost/range//boost_range") + list(APPEND extra_libs Boost::range) elseif(part STREQUAL "/boost/test//boost_unit_test_framework") list(APPEND extra_libs Boost::unit_test_framework) elseif(part STREQUAL "math_test") - list(APPEND extra_libs Boost::assign Boost::bind Boost::exception Boost::lexical_cast Boost::math Boost::numeric_conversion) + list(APPEND extra_libs Boost::exception Boost::lexical_cast Boost::math Boost::numeric_conversion Boost::range) else() boost_message(SEND_ERROR "Unknown dependency '${part}'") endif() @@ -55,4 +55,4 @@ boost_test(TYPE compile SOURCES multiprecision_float_test.cpp LINK_LIBRARIES Boost::random Boost::unit_test_framework Boost::multiprecision COMPILE_FEATURES cxx_std_14) boost_test(TYPE compile SOURCES statistic_tests.cpp - LINK_LIBRARIES Boost::random Boost::bind Boost::math) + LINK_LIBRARIES Boost::random Boost::math) diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index b4db865db..414b1c2a7 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -103,22 +103,21 @@ explicit test_lagged_fibonacci1279 test_lagged_fibonacci2281 test_lagged_fibonacci44497 ; alias math_test : - /boost/assign//boost_assign - /boost/bind//boost_bind /boost/exception//boost_exception /boost/lexical_cast//boost_lexical_cast /boost/math//boost_math_tr1 /boost/numeric_conversion//boost_numeric_conversion + /boost/range//boost_range ; -run test_seed_seq.cpp /boost/assign//boost_assign /boost/test//boost_unit_test_framework ; +run test_seed_seq.cpp /boost/test//boost_unit_test_framework ; run test_binomial.cpp math_test ; run test_binomial_distribution.cpp /boost/test//boost_unit_test_framework ; run test_poisson.cpp math_test ; run test_poisson_distribution.cpp /boost/test//boost_unit_test_framework ; run test_discrete.cpp math_test ; -run test_discrete_distribution.cpp /boost/assign//boost_assign /boost/test//boost_unit_test_framework ; +run test_discrete_distribution.cpp /boost/test//boost_unit_test_framework ; run test_gamma.cpp math_test ; run test_gamma_distribution.cpp /boost/test//boost_unit_test_framework ; run test_weibull.cpp math_test ; @@ -136,9 +135,9 @@ run test_student_t_distribution.cpp /boost/test//boost_unit_test_framework ; run test_normal.cpp math_test ; run test_normal_distribution.cpp /boost/test//boost_unit_test_framework ; run test_piecewise_constant.cpp math_test ; -run test_piecewise_constant_distribution.cpp /boost/assign//boost_assign /boost/test//boost_unit_test_framework ; +run test_piecewise_constant_distribution.cpp /boost/test//boost_unit_test_framework ; run test_piecewise_linear.cpp math_test ; -run test_piecewise_linear_distribution.cpp /boost/assign//boost_assign /boost/test//boost_unit_test_framework ; +run test_piecewise_linear_distribution.cpp /boost/test//boost_unit_test_framework ; run test_exponential.cpp math_test ; run test_exponential_distribution.cpp /boost/test//boost_unit_test_framework ; run test_bernoulli.cpp math_test ; diff --git a/test/concepts.hpp b/test/concepts.hpp index fd0eb1e61..12f34f186 100644 --- a/test/concepts.hpp +++ b/test/concepts.hpp @@ -37,6 +37,7 @@ #include #include #include +#include #ifdef BOOST_MSVC #pragma warning(push) @@ -211,4 +212,9 @@ struct RandomNumberDistribution : #pragma warning(pop) #endif +template +std::vector make_vector(const T t1, U... u){ + return std::vector{ t1, static_cast(u)... }; +} + #endif diff --git a/test/integrate.hpp b/test/integrate.hpp index c98d731df..3864c984d 100644 --- a/test/integrate.hpp +++ b/test/integrate.hpp @@ -1,19 +1,20 @@ /* integrate.hpp header file * * Copyright Jens Maurer 2000 + * Copyright Alexander Grund 2026 * Distributed under the Boost Software License, Version 1.0. (See * accompanying file LICENSE_1_0.txt or copy at * http://www.boost.org/LICENSE_1_0.txt) * * $Id$ * - * Revision history - * 01 April 2001: Modified to use new header. (JMaddock) */ #ifndef INTEGRATE_HPP #define INTEGRATE_HPP +#include + #include template @@ -45,7 +46,7 @@ simpson(UnaryFunction f, typename UnaryFunction::argument_type a, // compute b so that f(b) = y; assume f is monotone increasing template inline T -invert_monotone_inc(UnaryFunction f, typename UnaryFunction::result_type y, +invert_monotone_inc(UnaryFunction f, typename boost::result_of::type y, T lower = -1, T upper = 1) { diff --git a/test/multiprecision_int_test.cpp b/test/multiprecision_int_test.cpp index e837f4484..0fe030c2b 100644 --- a/test/multiprecision_int_test.cpp +++ b/test/multiprecision_int_test.cpp @@ -161,10 +161,10 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(distributions, distribution_type, uniform_distribu distribution_type d(a, b); boost::random::mt19937 gen; - BOOST_CHECK_EQUAL(d.a(), a); - BOOST_CHECK_EQUAL(d.b(), b); - BOOST_CHECK_EQUAL((d.min)(), a); - BOOST_CHECK_EQUAL((d.max)(), b); + BOOST_TEST(d.a() == a); + BOOST_TEST(d.b() == b); + BOOST_TEST((d.min)() == a); + BOOST_TEST((d.max)() == b); for(unsigned i = 0; i < 200; ++i) { diff --git a/test/statistic_tests.hpp b/test/statistic_tests.hpp index 1b8c483f1..224c5503a 100644 --- a/test/statistic_tests.hpp +++ b/test/statistic_tests.hpp @@ -12,15 +12,15 @@ #ifndef STATISTIC_TESTS_HPP #define STATISTIC_TESTS_HPP -#include -#include -#include -#include #include #include +#include +#include +#include +#include +#include #include -#include #include #include @@ -491,8 +491,8 @@ inline double cdf(const kolmogorov_smirnov_probability& dist, double val) inline double quantile(const kolmogorov_smirnov_probability& dist, double val) { - using namespace boost::placeholders; - return invert_monotone_inc(boost::bind(&cdf, dist, _1), val, 0.0, 1000.0); + using namespace std::placeholders; + return invert_monotone_inc(std::bind(&cdf, dist, _1), val, 0.0, 1000.0); } /* @@ -645,8 +645,8 @@ double run_experiment(const Experiment & experiment, Generator & gen, int n) generic_counter > v(experiment.classes()); experiment.run(gen, v, n); return chi_square_value(v.begin(), v.end(), - boost::bind(&Experiment::probability, - experiment, boost::placeholders::_1)); + std::bind(&Experiment::probability, + experiment, std::placeholders::_1)); } // chi_square test @@ -656,8 +656,8 @@ double run_experiment(const Experiment & experiment, const Generator & gen, int generic_counter > v(experiment.classes()); experiment.run(gen, v, n); return chi_square_value(v.begin(), v.end(), - boost::bind(&Experiment::probability, - experiment, boost::placeholders::_1)); + std::bind(&Experiment::probability, + experiment, std::placeholders::_1)); } // number generator with experiment results (for nesting) diff --git a/test/test_const_mod.cpp b/test/test_const_mod.cpp index cf5ef4991..c2ea83d40 100644 --- a/test/test_const_mod.cpp +++ b/test/test_const_mod.cpp @@ -26,13 +26,13 @@ typedef boost::mpl::vector< BOOST_AUTO_TEST_CASE_TEMPLATE(test_mult8, IntType, int8_types) { for(int i = 0; i < 127; ++i) { for(int j = 0; j < 127; ++j) { - BOOST_CHECK_EQUAL((boost::random::const_mod::mult(IntType(i), IntType(j))), i * j % 127); + BOOST_TEST((boost::random::const_mod::mult(IntType(i), IntType(j))) == i * j % 127); } } int modulus = (std::numeric_limits::max)() + 1; for(int i = 0; i < modulus; ++i) { for(int j = 0; j < modulus; ++j) { - BOOST_CHECK_EQUAL((boost::random::const_mod::mult(IntType(i), IntType(j))), i * j % modulus); + BOOST_TEST((boost::random::const_mod::mult(IntType(i), IntType(j))) == i * j % modulus); } } } @@ -40,14 +40,14 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_mult8, IntType, int8_types) { BOOST_AUTO_TEST_CASE_TEMPLATE(test_add8, IntType, int8_types) { for(int i = 0; i < 127; ++i) { for(int j = 0; j < 127; ++j) { - BOOST_CHECK_EQUAL((boost::random::const_mod::add(IntType(i), IntType(j))), (i + j) % 127); + BOOST_TEST((boost::random::const_mod::add(IntType(i), IntType(j))) == (i + j) % 127); } } { const int modulus = boost::integer_traits::const_max; for(int i = 0; i < modulus; ++i) { for(int j = 0; j < modulus; ++j) { - BOOST_CHECK_EQUAL((boost::random::const_mod::add(IntType(i), IntType(j))), (i + j) % modulus); + BOOST_TEST((boost::random::const_mod::add(IntType(i), IntType(j))) == (i + j) % modulus); } } } @@ -55,7 +55,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_add8, IntType, int8_types) { int modulus = (std::numeric_limits::max)() + 1; for(int i = 0; i < modulus; ++i) { for(int j = 0; j < modulus; ++j) { - BOOST_CHECK_EQUAL((boost::random::const_mod::add(IntType(i), IntType(j))), (i + j) % modulus); + BOOST_TEST((boost::random::const_mod::add(IntType(i), IntType(j))) == (i + j) % modulus); } } } @@ -65,7 +65,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_mult_add8, IntType, int8_types) { for(int i = 0; i < 127; i += 5) { for(int j = 0; j < 127; j += 3) { for(int k = 0; k < 127; k += 3) { - BOOST_CHECK_EQUAL((boost::random::const_mod::mult_add(IntType(i), IntType(j), IntType(k))), (i * j + k) % 127); + BOOST_TEST((boost::random::const_mod::mult_add(IntType(i), IntType(j), IntType(k))) == (i * j + k) % 127); } } } @@ -74,7 +74,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_mult_add8, IntType, int8_types) { for(int i = 0; i < modulus; i += 5) { for(int j = 0; j < modulus; j += 3) { for(int k = 0; k < modulus; k += 3) { - BOOST_CHECK_EQUAL((boost::random::const_mod::mult_add(IntType(i), IntType(j), IntType(k))), (i * j + k) % modulus); + BOOST_TEST((boost::random::const_mod::mult_add(IntType(i), IntType(j), IntType(k))) == (i * j + k) % modulus); } } } @@ -84,12 +84,12 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_mult_add8, IntType, int8_types) { BOOST_AUTO_TEST_CASE_TEMPLATE(test_invert8, IntType, int8_types) { for(int i = 1; i < 127; ++i) { IntType inverse = boost::random::const_mod::invert(IntType(i)); - BOOST_CHECK_EQUAL((boost::random::const_mod::mult(IntType(i), inverse)), 1); + BOOST_TEST((boost::random::const_mod::mult(IntType(i), inverse)) == 1); } int modulus = (std::numeric_limits::max)() + 1; for(int i = 1; i < modulus; i += 2) { IntType inverse = boost::random::const_mod::invert(IntType(i)); - BOOST_CHECK_EQUAL((boost::random::const_mod::mult(IntType(i), inverse)), 1); + BOOST_TEST((boost::random::const_mod::mult(IntType(i), inverse)) == 1); } } @@ -99,37 +99,37 @@ typedef boost::mpl::vector< > int32_types; BOOST_AUTO_TEST_CASE_TEMPLATE(test_mult32, IntType, int32_types) { - BOOST_CHECK_EQUAL((boost::random::const_mod::mult(0, 0)), IntType(0)); - BOOST_CHECK_EQUAL((boost::random::const_mod::mult(0, 2147483562)), IntType(0)); - BOOST_CHECK_EQUAL((boost::random::const_mod::mult(2147483562, 0)), IntType(0)); - BOOST_CHECK_EQUAL((boost::random::const_mod::mult(2147483562, 2147483562)), IntType(1)); - BOOST_CHECK_EQUAL((boost::random::const_mod::mult(1234567890, 1234657890)), IntType(813106682)); + BOOST_TEST((boost::random::const_mod::mult(0, 0)) == IntType(0)); + BOOST_TEST((boost::random::const_mod::mult(0, 2147483562)) == IntType(0)); + BOOST_TEST((boost::random::const_mod::mult(2147483562, 0)) == IntType(0)); + BOOST_TEST((boost::random::const_mod::mult(2147483562, 2147483562)) == IntType(1)); + BOOST_TEST((boost::random::const_mod::mult(1234567890, 1234657890)) == IntType(813106682)); } BOOST_AUTO_TEST_CASE_TEMPLATE(test_add32, IntType, int32_types) { - BOOST_CHECK_EQUAL((boost::random::const_mod::add(0, 0)), IntType(0)); - BOOST_CHECK_EQUAL((boost::random::const_mod::add(0, 2147483562)), IntType(2147483562)); - BOOST_CHECK_EQUAL((boost::random::const_mod::add(2147483562, 0)), IntType(2147483562)); - BOOST_CHECK_EQUAL((boost::random::const_mod::add(2147483562, 2147483562)), IntType(2147483561)); - BOOST_CHECK_EQUAL((boost::random::const_mod::add(1234567890, 1234657890)), IntType(321742217)); + BOOST_TEST((boost::random::const_mod::add(0, 0)) == IntType(0)); + BOOST_TEST((boost::random::const_mod::add(0, 2147483562)) == IntType(2147483562)); + BOOST_TEST((boost::random::const_mod::add(2147483562, 0)) == IntType(2147483562)); + BOOST_TEST((boost::random::const_mod::add(2147483562, 2147483562)) == IntType(2147483561)); + BOOST_TEST((boost::random::const_mod::add(1234567890, 1234657890)) == IntType(321742217)); } BOOST_AUTO_TEST_CASE_TEMPLATE(test_mult_add32, IntType, int32_types) { - BOOST_CHECK_EQUAL((boost::random::const_mod::mult_add(0, 0, 0)), IntType(0)); - BOOST_CHECK_EQUAL((boost::random::const_mod::mult_add(0, 2147483562, 827364)), IntType(827364)); - BOOST_CHECK_EQUAL((boost::random::const_mod::mult_add(2147483562, 0, 827364)), IntType(827364)); - BOOST_CHECK_EQUAL((boost::random::const_mod::mult_add(2147483562, 2147483562, 2147483562)), IntType(0)); - BOOST_CHECK_EQUAL((boost::random::const_mod::mult_add(1234567890, 1234657890, 1726384759)), IntType(392007878)); + BOOST_TEST((boost::random::const_mod::mult_add(0, 0, 0)) == IntType(0)); + BOOST_TEST((boost::random::const_mod::mult_add(0, 2147483562, 827364)) == IntType(827364)); + BOOST_TEST((boost::random::const_mod::mult_add(2147483562, 0, 827364)) == IntType(827364)); + BOOST_TEST((boost::random::const_mod::mult_add(2147483562, 2147483562, 2147483562)) == IntType(0)); + BOOST_TEST((boost::random::const_mod::mult_add(1234567890, 1234657890, 1726384759)) == IntType(392007878)); } BOOST_AUTO_TEST_CASE_TEMPLATE(test_invert32, IntType, int32_types) { - BOOST_CHECK_EQUAL((boost::random::const_mod::invert(0)), IntType(0)); - BOOST_CHECK_EQUAL((boost::random::const_mod::mult_add(0, 0, 0)), IntType(0)); + BOOST_TEST((boost::random::const_mod::invert(0)) == IntType(0)); + BOOST_TEST((boost::random::const_mod::mult_add(0, 0, 0)) == IntType(0)); IntType inverse; inverse = boost::random::const_mod::invert(2147483562); - BOOST_CHECK_EQUAL((boost::random::const_mod::mult(2147483562, inverse)), IntType(1)); + BOOST_TEST((boost::random::const_mod::mult(2147483562, inverse)) == IntType(1)); inverse = boost::random::const_mod::invert(1234567890); - BOOST_CHECK_EQUAL((boost::random::const_mod::mult(1234567890, inverse)), IntType(1)); + BOOST_TEST((boost::random::const_mod::mult(1234567890, inverse)) == IntType(1)); } #if !defined(BOOST_NO_INT64_T) @@ -141,44 +141,44 @@ typedef boost::mpl::vector< BOOST_AUTO_TEST_CASE_TEMPLATE(test_mult64, IntType, int64_types) { typedef boost::random::const_mod const_mod_type; - BOOST_CHECK_EQUAL((const_mod_type::mult(0, 0)), IntType(0)); - BOOST_CHECK_EQUAL((const_mod_type::mult(0, 2147483562)), IntType(0)); - BOOST_CHECK_EQUAL((const_mod_type::mult(2147483562, 0)), IntType(0)); - BOOST_CHECK_EQUAL((const_mod_type::mult(2147483562, 2147483562)), IntType(INT64_C(316718521754730848))); - BOOST_CHECK_EQUAL((const_mod_type::mult(1234567890, 1234657890)), IntType(INT64_C(1524268986129152100))); - BOOST_CHECK_EQUAL((const_mod_type::mult(INT64_C(1234567890726352938), INT64_C(1234657890736453927))), IntType(INT64_C(88656187017794672))); + BOOST_TEST((const_mod_type::mult(0, 0)) == IntType(0)); + BOOST_TEST((const_mod_type::mult(0, 2147483562)) == IntType(0)); + BOOST_TEST((const_mod_type::mult(2147483562, 0)) == IntType(0)); + BOOST_TEST((const_mod_type::mult(2147483562, 2147483562)) == IntType(INT64_C(316718521754730848))); + BOOST_TEST((const_mod_type::mult(1234567890, 1234657890)) == IntType(INT64_C(1524268986129152100))); + BOOST_TEST((const_mod_type::mult(INT64_C(1234567890726352938), INT64_C(1234657890736453927))) == IntType(INT64_C(88656187017794672))); } BOOST_AUTO_TEST_CASE_TEMPLATE(test_add64, IntType, int64_types) { typedef boost::random::const_mod const_mod_type; - BOOST_CHECK_EQUAL((const_mod_type::add(0, 0)), IntType(0)); - BOOST_CHECK_EQUAL((const_mod_type::add(0, 2147483562)), IntType(2147483562)); - BOOST_CHECK_EQUAL((const_mod_type::add(2147483562, 0)), IntType(2147483562)); - BOOST_CHECK_EQUAL((const_mod_type::add(2147483562, 2147483562)), IntType(4294967124U)); - BOOST_CHECK_EQUAL((const_mod_type::add(1234567890, 1234657890)), IntType(2469225780U)); - BOOST_CHECK_EQUAL((const_mod_type::add(INT64_C(1234567890726352938), INT64_C(1234657890736453927))), IntType(INT64_C(321742217810068367))); - BOOST_CHECK_EQUAL((const_mod_type::add(INT64_C(2147483563652738490), 8)), IntType(0)); + BOOST_TEST((const_mod_type::add(0, 0)) == IntType(0)); + BOOST_TEST((const_mod_type::add(0, 2147483562)) == IntType(2147483562)); + BOOST_TEST((const_mod_type::add(2147483562, 0)) == IntType(2147483562)); + BOOST_TEST((const_mod_type::add(2147483562, 2147483562)) == IntType(4294967124U)); + BOOST_TEST((const_mod_type::add(1234567890, 1234657890)) == IntType(2469225780U)); + BOOST_TEST((const_mod_type::add(INT64_C(1234567890726352938), INT64_C(1234657890736453927))) == IntType(INT64_C(321742217810068367))); + BOOST_TEST((const_mod_type::add(INT64_C(2147483563652738490), 8)) == IntType(0)); } BOOST_AUTO_TEST_CASE_TEMPLATE(test_mult_add64, IntType, int64_types) { typedef boost::random::const_mod const_mod_type; - BOOST_CHECK_EQUAL((const_mod_type::mult_add(0, 0, 0)), IntType(0)); - BOOST_CHECK_EQUAL((const_mod_type::mult_add(0, 2147483562, 827364)), IntType(827364)); - BOOST_CHECK_EQUAL((const_mod_type::mult_add(2147483562, 0, 827364)), IntType(827364)); - BOOST_CHECK_EQUAL((const_mod_type::mult_add(2147483562, 2147483562, 2147483562)), IntType(INT64_C(316718523902214410))); - BOOST_CHECK_EQUAL((const_mod_type::mult_add(1234567890, 1234657890, 1726384759)), IntType(INT64_C(1524268987855536859))); - BOOST_CHECK_EQUAL((const_mod_type::mult_add(INT64_C(1234567890726352938), INT64_C(1234657890736453927), INT64_C(1726384759726488649))), IntType(INT64_C(1815040946744283321))); + BOOST_TEST((const_mod_type::mult_add(0, 0, 0)) == IntType(0)); + BOOST_TEST((const_mod_type::mult_add(0, 2147483562, 827364)) == IntType(827364)); + BOOST_TEST((const_mod_type::mult_add(2147483562, 0, 827364)) == IntType(827364)); + BOOST_TEST((const_mod_type::mult_add(2147483562, 2147483562, 2147483562)) == IntType(INT64_C(316718523902214410))); + BOOST_TEST((const_mod_type::mult_add(1234567890, 1234657890, 1726384759)) == IntType(INT64_C(1524268987855536859))); + BOOST_TEST((const_mod_type::mult_add(INT64_C(1234567890726352938), INT64_C(1234657890736453927), INT64_C(1726384759726488649))) == IntType(INT64_C(1815040946744283321))); } BOOST_AUTO_TEST_CASE_TEMPLATE(test_invert64, IntType, int64_types) { typedef boost::random::const_mod const_mod_type; - BOOST_CHECK_EQUAL((const_mod_type::invert(0)), IntType(0)); - BOOST_CHECK_EQUAL((const_mod_type::mult_add(0, 0, 0)), IntType(0)); + BOOST_TEST((const_mod_type::invert(0)) == IntType(0)); + BOOST_TEST((const_mod_type::mult_add(0, 0, 0)) == IntType(0)); IntType inverse; inverse = const_mod_type::invert(INT64_C(7362947769)); - BOOST_CHECK_EQUAL((const_mod_type::mult(INT64_C(7362947769), inverse)), IntType(1)); + BOOST_TEST((const_mod_type::mult(INT64_C(7362947769), inverse)) == IntType(1)); inverse = const_mod_type::invert(INT64_C(1263142436887493875)); - BOOST_CHECK_EQUAL((const_mod_type::mult(INT64_C(1263142436887493875), inverse)), IntType(1)); + BOOST_TEST((const_mod_type::mult(INT64_C(1263142436887493875), inverse)) == IntType(1)); } #endif diff --git a/test/test_discrete_distribution.cpp b/test/test_discrete_distribution.cpp index e14bc6430..809a65332 100644 --- a/test/test_discrete_distribution.cpp +++ b/test/test_discrete_distribution.cpp @@ -11,7 +11,6 @@ #include #include -#include #include #include #include "concepts.hpp" @@ -34,100 +33,96 @@ struct gen { } }; -#define CHECK_PROBABILITIES(actual, expected) \ - do { \ - std::vector _actual = (actual); \ - std::vector _expected = (expected); \ - BOOST_CHECK_EQUAL_COLLECTIONS( \ - _actual.begin(), _actual.end(), \ - _expected.begin(), _expected.end()); \ +#define CHECK_PROBABILITIES(actual, expected) \ + do { \ + std::vector actual_ = (actual); \ + std::vector expected_ = make_vectorexpected; \ + BOOST_TEST(actual_ == expected_, boost::test_tools::per_element()); \ } while(false) -using boost::assign::list_of; - BOOST_AUTO_TEST_CASE(test_constructors) { boost::random::discrete_distribution<> dist; - CHECK_PROBABILITIES(dist.probabilities(), list_of(1.0)); + CHECK_PROBABILITIES(dist.probabilities(), (1.0)); #ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST boost::random::discrete_distribution<> dist_il = { 1, 2, 1, 4 }; - CHECK_PROBABILITIES(dist_il.probabilities(), list_of(.125)(.25)(.125)(.5)); + CHECK_PROBABILITIES(dist_il.probabilities(), (.125, .25, .125, .5)); #endif - std::vector probs = boost::assign::list_of(1.0)(2.0)(1.0)(4.0); + std::vector probs{ 1.0, 2.0, 1.0, 4.0 }; boost::random::discrete_distribution<> dist_r(probs); - CHECK_PROBABILITIES(dist_r.probabilities(), list_of(.125)(.25)(.125)(.5)); + CHECK_PROBABILITIES(dist_r.probabilities(), (.125, .25, .125, .5)); boost::random::discrete_distribution<> dist_it(probs.begin(), probs.end()); - CHECK_PROBABILITIES(dist_it.probabilities(), list_of(.125)(.25)(.125)(.5)); + CHECK_PROBABILITIES(dist_it.probabilities(), (.125, .25, .125, .5)); boost::random::discrete_distribution<> dist_fun(4, 99, 115, gen()); - CHECK_PROBABILITIES(dist_fun.probabilities(), list_of(.125)(.25)(.125)(.5)); + CHECK_PROBABILITIES(dist_fun.probabilities(), (.125, .25, .125, .5)); boost::random::discrete_distribution<> copy(dist); - BOOST_CHECK_EQUAL(dist, copy); + BOOST_TEST(dist == copy); boost::random::discrete_distribution<> copy_r(dist_r); - BOOST_CHECK_EQUAL(dist_r, copy_r); + BOOST_TEST(dist_r == copy_r); boost::random::discrete_distribution<> notpow2(3, 99, 111, gen()); BOOST_REQUIRE_EQUAL(notpow2.probabilities().size(), 3u); - BOOST_CHECK_CLOSE_FRACTION(notpow2.probabilities()[0], 0.25, 0.00000000001); - BOOST_CHECK_CLOSE_FRACTION(notpow2.probabilities()[1], 0.50, 0.00000000001); - BOOST_CHECK_CLOSE_FRACTION(notpow2.probabilities()[2], 0.25, 0.00000000001); + BOOST_TEST(notpow2.probabilities()[0] == 0.25, boost::test_tools::tolerance(0.00000000001)); + BOOST_TEST(notpow2.probabilities()[1] == 0.50, boost::test_tools::tolerance(0.00000000001)); + BOOST_TEST(notpow2.probabilities()[2] == 0.25, boost::test_tools::tolerance(0.00000000001)); boost::random::discrete_distribution<> copy_notpow2(notpow2); - BOOST_CHECK_EQUAL(notpow2, copy_notpow2); + BOOST_TEST(notpow2 == copy_notpow2); } BOOST_AUTO_TEST_CASE(test_param) { - std::vector probs = boost::assign::list_of(1.0)(2.0)(1.0)(4.0); + std::vector probs{ 1.0, 2.0, 1.0, 4.0 }; boost::random::discrete_distribution<> dist(probs); boost::random::discrete_distribution<>::param_type param = dist.param(); - CHECK_PROBABILITIES(param.probabilities(), list_of(.125)(.25)(.125)(.5)); + CHECK_PROBABILITIES(param.probabilities(), (.125, .25, .125, .5)); boost::random::discrete_distribution<> copy1(param); - BOOST_CHECK_EQUAL(dist, copy1); + BOOST_TEST(dist == copy1); boost::random::discrete_distribution<> copy2; copy2.param(param); - BOOST_CHECK_EQUAL(dist, copy2); + BOOST_TEST(dist == copy2); boost::random::discrete_distribution<>::param_type param_copy = param; - BOOST_CHECK_EQUAL(param, param_copy); + BOOST_TEST(param == param_copy); BOOST_CHECK(param == param_copy); BOOST_CHECK(!(param != param_copy)); boost::random::discrete_distribution<>::param_type param_default; - CHECK_PROBABILITIES(param_default.probabilities(), list_of(1.0)); + CHECK_PROBABILITIES(param_default.probabilities(), (1.0)); BOOST_CHECK(param != param_default); BOOST_CHECK(!(param == param_default)); #ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST boost::random::discrete_distribution<>::param_type parm_il = { 1, 2, 1, 4 }; - CHECK_PROBABILITIES(parm_il.probabilities(), list_of(.125)(.25)(.125)(.5)); + CHECK_PROBABILITIES(parm_il.probabilities(), (.125, .25, .125, .5)); #endif boost::random::discrete_distribution<>::param_type parm_r(probs); - CHECK_PROBABILITIES(parm_r.probabilities(), list_of(.125)(.25)(.125)(.5)); + CHECK_PROBABILITIES(parm_r.probabilities(), (.125, .25, .125, .5)); boost::random::discrete_distribution<>::param_type parm_it(probs.begin(), probs.end()); - CHECK_PROBABILITIES(parm_it.probabilities(), list_of(.125)(.25)(.125)(.5)); + CHECK_PROBABILITIES(parm_it.probabilities(), (.125, .25, .125, .5)); boost::random::discrete_distribution<>::param_type parm_fun(4, 99, 115, gen()); - CHECK_PROBABILITIES(parm_fun.probabilities(), list_of(.125)(.25)(.125)(.5)); + CHECK_PROBABILITIES(parm_fun.probabilities(), (.125, .25, .125, .5)); } BOOST_AUTO_TEST_CASE(test_min_max) { - std::vector probs = boost::assign::list_of(1.0)(2.0)(1.0); + std::vector probs{ 1.0, 2.0, 1.0 }; boost::random::discrete_distribution<> dist; - BOOST_CHECK_EQUAL((dist.min)(), 0); - BOOST_CHECK_EQUAL((dist.max)(), 0); + BOOST_TEST((dist.min)() == 0); + BOOST_TEST((dist.max)() == 0); boost::random::discrete_distribution<> dist_r(probs); - BOOST_CHECK_EQUAL((dist_r.min)(), 0); - BOOST_CHECK_EQUAL((dist_r.max)(), 2); + BOOST_TEST((dist_r.min)() == 0); + BOOST_TEST((dist_r.max)() == 2); } BOOST_AUTO_TEST_CASE(test_comparison) { - std::vector probs = boost::assign::list_of(1.0)(2.0)(1.0)(4.0); + std::vector probs{ 1.0, 2.0, 1.0, 4.0 }; boost::random::discrete_distribution<> dist; boost::random::discrete_distribution<> dist_copy(dist); boost::random::discrete_distribution<> dist_r(probs); @@ -141,28 +136,28 @@ BOOST_AUTO_TEST_CASE(test_comparison) { } BOOST_AUTO_TEST_CASE(test_streaming) { - std::vector probs = boost::assign::list_of(1.0)(2.0)(1.0)(4.0); + std::vector probs{ 1.0, 2.0, 1.0, 4.0 }; boost::random::discrete_distribution<> dist(probs); std::stringstream stream; stream << dist; boost::random::discrete_distribution<> restored_dist; stream >> restored_dist; - BOOST_CHECK_EQUAL(dist, restored_dist); + BOOST_TEST(dist == restored_dist); } BOOST_AUTO_TEST_CASE(test_generation) { - std::vector probs = boost::assign::list_of(0.0)(1.0); + std::vector probs{ 0.0, 1.0 }; boost::minstd_rand0 gen; boost::random::discrete_distribution<> dist; boost::random::discrete_distribution<> dist_r(probs); for(int i = 0; i < 10; ++i) { int value = dist(gen); - BOOST_CHECK_EQUAL(value, 0); + BOOST_TEST(value == 0); int value_r = dist_r(gen); - BOOST_CHECK_EQUAL(value_r, 1); + BOOST_TEST(value_r == 1); int value_param = dist_r(gen, dist.param()); - BOOST_CHECK_EQUAL(value_param, 0); + BOOST_TEST(value_param == 0); int value_r_param = dist(gen, dist_r.param()); - BOOST_CHECK_EQUAL(value_r_param, 1); + BOOST_TEST(value_r_param == 1); } } diff --git a/test/test_distribution.ipp b/test/test_distribution.ipp index 6699af150..7299300d7 100644 --- a/test/test_distribution.ipp +++ b/test/test_distribution.ipp @@ -22,46 +22,46 @@ BOOST_CONCEPT_ASSERT((RandomNumberDistribution< BOOST_RANDOM_DISTRIBUTION >)); BOOST_AUTO_TEST_CASE(test_constructors) { BOOST_RANDOM_DISTRIBUTION dist; - BOOST_CHECK_EQUAL(dist.BOOST_RANDOM_ARG1(), BOOST_RANDOM_ARG1_DEFAULT); + BOOST_TEST(dist.BOOST_RANDOM_ARG1() == BOOST_RANDOM_ARG1_DEFAULT); #ifdef BOOST_RANDOM_ARG2 - BOOST_CHECK_EQUAL(dist.BOOST_RANDOM_ARG2(), BOOST_RANDOM_ARG2_DEFAULT); + BOOST_TEST(dist.BOOST_RANDOM_ARG2() == BOOST_RANDOM_ARG2_DEFAULT); #endif #ifdef BOOST_RANDOM_ARG3 - BOOST_CHECK_EQUAL(dist.BOOST_RANDOM_ARG3(), BOOST_RANDOM_ARG3_DEFAULT); + BOOST_TEST(dist.BOOST_RANDOM_ARG3() == BOOST_RANDOM_ARG3_DEFAULT); #endif BOOST_RANDOM_DISTRIBUTION dist_one(BOOST_RANDOM_ARG1_VALUE); - BOOST_CHECK_EQUAL(dist_one.BOOST_RANDOM_ARG1(), BOOST_RANDOM_ARG1_VALUE); + BOOST_TEST(dist_one.BOOST_RANDOM_ARG1() == BOOST_RANDOM_ARG1_VALUE); #ifdef BOOST_RANDOM_ARG2 - BOOST_CHECK_EQUAL(dist_one.BOOST_RANDOM_ARG2(), BOOST_RANDOM_ARG2_DEFAULT); + BOOST_TEST(dist_one.BOOST_RANDOM_ARG2() == BOOST_RANDOM_ARG2_DEFAULT); #endif #ifdef BOOST_RANDOM_ARG3 - BOOST_CHECK_EQUAL(dist_one.BOOST_RANDOM_ARG3(), BOOST_RANDOM_ARG3_DEFAULT); + BOOST_TEST(dist_one.BOOST_RANDOM_ARG3() == BOOST_RANDOM_ARG3_DEFAULT); #endif #ifdef BOOST_RANDOM_ARG2 BOOST_RANDOM_DISTRIBUTION dist_two(BOOST_RANDOM_ARG1_VALUE, BOOST_RANDOM_ARG2_VALUE); - BOOST_CHECK_EQUAL(dist_two.BOOST_RANDOM_ARG1(), BOOST_RANDOM_ARG1_VALUE); - BOOST_CHECK_EQUAL(dist_two.BOOST_RANDOM_ARG2(), BOOST_RANDOM_ARG2_VALUE); + BOOST_TEST(dist_two.BOOST_RANDOM_ARG1() == BOOST_RANDOM_ARG1_VALUE); + BOOST_TEST(dist_two.BOOST_RANDOM_ARG2() == BOOST_RANDOM_ARG2_VALUE); #ifdef BOOST_RANDOM_ARG3 - BOOST_CHECK_EQUAL(dist_two.BOOST_RANDOM_ARG3(), BOOST_RANDOM_ARG3_DEFAULT); + BOOST_TEST(dist_two.BOOST_RANDOM_ARG3() == BOOST_RANDOM_ARG3_DEFAULT); #endif #endif #ifdef BOOST_RANDOM_ARG3 BOOST_RANDOM_DISTRIBUTION dist_three(BOOST_RANDOM_ARG1_VALUE, BOOST_RANDOM_ARG2_VALUE, BOOST_RANDOM_ARG3_VALUE); - BOOST_CHECK_EQUAL(dist_three.BOOST_RANDOM_ARG1(), BOOST_RANDOM_ARG1_VALUE); - BOOST_CHECK_EQUAL(dist_three.BOOST_RANDOM_ARG2(), BOOST_RANDOM_ARG2_VALUE); - BOOST_CHECK_EQUAL(dist_three.BOOST_RANDOM_ARG3(), BOOST_RANDOM_ARG3_VALUE); + BOOST_TEST(dist_three.BOOST_RANDOM_ARG1() == BOOST_RANDOM_ARG1_VALUE); + BOOST_TEST(dist_three.BOOST_RANDOM_ARG2() == BOOST_RANDOM_ARG2_VALUE); + BOOST_TEST(dist_three.BOOST_RANDOM_ARG3() == BOOST_RANDOM_ARG3_VALUE); #endif BOOST_RANDOM_DISTRIBUTION copy(dist); - BOOST_CHECK_EQUAL(dist, copy); + BOOST_TEST(dist == copy); BOOST_RANDOM_DISTRIBUTION copy_one(dist_one); - BOOST_CHECK_EQUAL(dist_one, copy_one); + BOOST_TEST(dist_one == copy_one); #ifdef BOOST_RANDOM_ARG2 BOOST_RANDOM_DISTRIBUTION copy_two(dist_two); - BOOST_CHECK_EQUAL(dist_two, copy_two); + BOOST_TEST(dist_two == copy_two); #endif #ifdef BOOST_RANDOM_ARG3 BOOST_RANDOM_DISTRIBUTION copy_three(dist_three); - BOOST_CHECK_EQUAL(dist_three, copy_three); + BOOST_TEST(dist_three == copy_three); #endif } @@ -74,40 +74,40 @@ BOOST_AUTO_TEST_CASE(test_param) { BOOST_RANDOM_DISTRIBUTION dist(BOOST_RANDOM_ARG1_VALUE); #endif BOOST_RANDOM_DISTRIBUTION::param_type param = dist.param(); - BOOST_CHECK_EQUAL(param.BOOST_RANDOM_ARG1(), BOOST_RANDOM_ARG1_VALUE); + BOOST_TEST(param.BOOST_RANDOM_ARG1() == BOOST_RANDOM_ARG1_VALUE); #ifdef BOOST_RANDOM_ARG2 - BOOST_CHECK_EQUAL(param.BOOST_RANDOM_ARG2(), BOOST_RANDOM_ARG2_VALUE); + BOOST_TEST(param.BOOST_RANDOM_ARG2() == BOOST_RANDOM_ARG2_VALUE); #endif #ifdef BOOST_RANDOM_ARG3 - BOOST_CHECK_EQUAL(param.BOOST_RANDOM_ARG3(), BOOST_RANDOM_ARG3_VALUE); + BOOST_TEST(param.BOOST_RANDOM_ARG3() == BOOST_RANDOM_ARG3_VALUE); #endif BOOST_RANDOM_DISTRIBUTION copy1(param); - BOOST_CHECK_EQUAL(dist, copy1); + BOOST_TEST(dist == copy1); BOOST_RANDOM_DISTRIBUTION copy2; copy2.param(param); - BOOST_CHECK_EQUAL(dist, copy2); + BOOST_TEST(dist == copy2); BOOST_RANDOM_DISTRIBUTION::param_type param_copy = param; - BOOST_CHECK_EQUAL(param, param_copy); + BOOST_TEST(param == param_copy); BOOST_CHECK(param == param_copy); BOOST_CHECK(!(param != param_copy)); BOOST_RANDOM_DISTRIBUTION::param_type param_default; - BOOST_CHECK_EQUAL(param_default.BOOST_RANDOM_ARG1(), BOOST_RANDOM_ARG1_DEFAULT); + BOOST_TEST(param_default.BOOST_RANDOM_ARG1() == BOOST_RANDOM_ARG1_DEFAULT); #ifdef BOOST_RANDOM_ARG2 - BOOST_CHECK_EQUAL(param_default.BOOST_RANDOM_ARG2(), BOOST_RANDOM_ARG2_DEFAULT); + BOOST_TEST(param_default.BOOST_RANDOM_ARG2() == BOOST_RANDOM_ARG2_DEFAULT); #endif #ifdef BOOST_RANDOM_ARG3 - BOOST_CHECK_EQUAL(param_default.BOOST_RANDOM_ARG3(), BOOST_RANDOM_ARG3_DEFAULT); + BOOST_TEST(param_default.BOOST_RANDOM_ARG3() == BOOST_RANDOM_ARG3_DEFAULT); #endif BOOST_CHECK(param != param_default); BOOST_CHECK(!(param == param_default)); BOOST_RANDOM_DISTRIBUTION::param_type param_one(BOOST_RANDOM_ARG1_VALUE); - BOOST_CHECK_EQUAL(param_one.BOOST_RANDOM_ARG1(), BOOST_RANDOM_ARG1_VALUE); + BOOST_TEST(param_one.BOOST_RANDOM_ARG1() == BOOST_RANDOM_ARG1_VALUE); #ifdef BOOST_RANDOM_ARG2 - BOOST_CHECK_EQUAL(param_one.BOOST_RANDOM_ARG2(), BOOST_RANDOM_ARG2_DEFAULT); + BOOST_TEST(param_one.BOOST_RANDOM_ARG2() == BOOST_RANDOM_ARG2_DEFAULT); #endif #ifdef BOOST_RANDOM_ARG3 - BOOST_CHECK_EQUAL(param_one.BOOST_RANDOM_ARG3(), BOOST_RANDOM_ARG3_DEFAULT); + BOOST_TEST(param_one.BOOST_RANDOM_ARG3() == BOOST_RANDOM_ARG3_DEFAULT); #endif #ifdef BOOST_RANDOM_ARG2 BOOST_CHECK(param != param_one); @@ -117,36 +117,36 @@ BOOST_AUTO_TEST_CASE(test_param) { BOOST_CHECK(!(param_default == param_one)); #ifdef BOOST_RANDOM_ARG2 BOOST_RANDOM_DISTRIBUTION::param_type param_two(BOOST_RANDOM_ARG1_VALUE, BOOST_RANDOM_ARG2_VALUE); - BOOST_CHECK_EQUAL(param_two.BOOST_RANDOM_ARG1(), BOOST_RANDOM_ARG1_VALUE); - BOOST_CHECK_EQUAL(param_two.BOOST_RANDOM_ARG2(), BOOST_RANDOM_ARG2_VALUE); + BOOST_TEST(param_two.BOOST_RANDOM_ARG1() == BOOST_RANDOM_ARG1_VALUE); + BOOST_TEST(param_two.BOOST_RANDOM_ARG2() == BOOST_RANDOM_ARG2_VALUE); #ifdef BOOST_RANDOM_ARG3 - BOOST_CHECK_EQUAL(param_two.BOOST_RANDOM_ARG3(), BOOST_RANDOM_ARG3_DEFAULT); + BOOST_TEST(param_two.BOOST_RANDOM_ARG3() == BOOST_RANDOM_ARG3_DEFAULT); #endif #endif #ifdef BOOST_RANDOM_ARG3 BOOST_RANDOM_DISTRIBUTION::param_type param_three(BOOST_RANDOM_ARG1_VALUE, BOOST_RANDOM_ARG2_VALUE, BOOST_RANDOM_ARG3_VALUE); - BOOST_CHECK_EQUAL(param_three.BOOST_RANDOM_ARG1(), BOOST_RANDOM_ARG1_VALUE); - BOOST_CHECK_EQUAL(param_three.BOOST_RANDOM_ARG2(), BOOST_RANDOM_ARG2_VALUE); - BOOST_CHECK_EQUAL(param_three.BOOST_RANDOM_ARG3(), BOOST_RANDOM_ARG3_VALUE); + BOOST_TEST(param_three.BOOST_RANDOM_ARG1() == BOOST_RANDOM_ARG1_VALUE); + BOOST_TEST(param_three.BOOST_RANDOM_ARG2() == BOOST_RANDOM_ARG2_VALUE); + BOOST_TEST(param_three.BOOST_RANDOM_ARG3() == BOOST_RANDOM_ARG3_VALUE); #endif } BOOST_AUTO_TEST_CASE(test_min_max) { BOOST_RANDOM_DISTRIBUTION dist; - BOOST_CHECK_EQUAL((dist.min)(), BOOST_RANDOM_DIST0_MIN); - BOOST_CHECK_EQUAL((dist.max)(), BOOST_RANDOM_DIST0_MAX); + BOOST_TEST((dist.min)() == BOOST_RANDOM_DIST0_MIN); + BOOST_TEST((dist.max)() == BOOST_RANDOM_DIST0_MAX); BOOST_RANDOM_DISTRIBUTION dist_one(BOOST_RANDOM_ARG1_VALUE); - BOOST_CHECK_EQUAL((dist_one.min)(), BOOST_RANDOM_DIST1_MIN); - BOOST_CHECK_EQUAL((dist_one.max)(), BOOST_RANDOM_DIST1_MAX); + BOOST_TEST((dist_one.min)() == BOOST_RANDOM_DIST1_MIN); + BOOST_TEST((dist_one.max)() == BOOST_RANDOM_DIST1_MAX); #ifdef BOOST_RANDOM_ARG2 BOOST_RANDOM_DISTRIBUTION dist_two(BOOST_RANDOM_ARG1_VALUE, BOOST_RANDOM_ARG2_VALUE); - BOOST_CHECK_EQUAL((dist_two.min)(), BOOST_RANDOM_DIST2_MIN); - BOOST_CHECK_EQUAL((dist_two.max)(), BOOST_RANDOM_DIST2_MAX); + BOOST_TEST((dist_two.min)() == BOOST_RANDOM_DIST2_MIN); + BOOST_TEST((dist_two.max)() == BOOST_RANDOM_DIST2_MAX); #endif #ifdef BOOST_RANDOM_ARG3 BOOST_RANDOM_DISTRIBUTION dist_three(BOOST_RANDOM_ARG1_VALUE, BOOST_RANDOM_ARG2_VALUE, BOOST_RANDOM_ARG3_VALUE); - BOOST_CHECK_EQUAL((dist_three.min)(), BOOST_RANDOM_DIST3_MIN); - BOOST_CHECK_EQUAL((dist_three.max)(), BOOST_RANDOM_DIST3_MAX); + BOOST_TEST((dist_three.min)() == BOOST_RANDOM_DIST3_MIN); + BOOST_TEST((dist_three.max)() == BOOST_RANDOM_DIST3_MAX); #endif } @@ -201,7 +201,7 @@ BOOST_AUTO_TEST_CASE(test_streaming) { stream << dist; BOOST_RANDOM_DISTRIBUTION restored_dist; stream >> restored_dist; - BOOST_CHECK_EQUAL(dist, restored_dist); + BOOST_TEST(dist == restored_dist); } void use(BOOST_RANDOM_DISTRIBUTION::result_type) {} @@ -218,54 +218,54 @@ BOOST_AUTO_TEST_CASE(test_generation) { result_type value = dist(gen); use(value); #ifdef BOOST_RANDOM_TEST1_MIN - BOOST_CHECK_GE(value, BOOST_RANDOM_TEST1_MIN); + BOOST_TEST(value >= BOOST_RANDOM_TEST1_MIN); #endif #ifdef BOOST_RANDOM_TEST1_MAX - BOOST_CHECK_LE(value, BOOST_RANDOM_TEST1_MAX); + BOOST_TEST(value <= BOOST_RANDOM_TEST1_MAX); #endif result_type value_two = dist_two(gen); use(value_two); #ifdef BOOST_RANDOM_TEST2_MIN - BOOST_CHECK_GE(value_two, BOOST_RANDOM_TEST2_MIN); + BOOST_TEST(value_two >= BOOST_RANDOM_TEST2_MIN); #endif #ifdef BOOST_RANDOM_TEST2_MAX - BOOST_CHECK_LE(value_two, BOOST_RANDOM_TEST2_MAX); + BOOST_TEST(value_two <= BOOST_RANDOM_TEST2_MAX); #endif #ifdef BOOST_RANDOM_TEST3_PARAMS result_type value_three = dist_three(gen); use(value_three); #endif #ifdef BOOST_RANDOM_TEST3_MIN - BOOST_CHECK_GE(value_three, BOOST_RANDOM_TEST3_MIN); + BOOST_TEST(value_three >= BOOST_RANDOM_TEST3_MIN); #endif #ifdef BOOST_RANDOM_TEST3_MAX - BOOST_CHECK_LE(value_three, BOOST_RANDOM_TEST3_MAX); + BOOST_TEST(value_three <= BOOST_RANDOM_TEST3_MAX); #endif result_type value_param = dist_two(gen, dist.param()); use(value_param); #ifdef BOOST_RANDOM_TEST1_MIN - BOOST_CHECK_GE(value_param, BOOST_RANDOM_TEST1_MIN); + BOOST_TEST(value_param >= BOOST_RANDOM_TEST1_MIN); #endif #ifdef BOOST_RANDOM_TEST1_MAX - BOOST_CHECK_LE(value_param, BOOST_RANDOM_TEST1_MAX); + BOOST_TEST(value_param <= BOOST_RANDOM_TEST1_MAX); #endif result_type value_two_param = dist(gen, dist_two.param()); use(value_two_param); #ifdef BOOST_RANDOM_TEST2_MIN - BOOST_CHECK_GE(value_two_param, BOOST_RANDOM_TEST2_MIN); + BOOST_TEST(value_two_param >= BOOST_RANDOM_TEST2_MIN); #endif #ifdef BOOST_RANDOM_TEST2_MAX - BOOST_CHECK_LE(value_two_param, BOOST_RANDOM_TEST2_MAX); + BOOST_TEST(value_two_param <= BOOST_RANDOM_TEST2_MAX); #endif #ifdef BOOST_RANDOM_TEST3_PARAMS result_type value_three_param = dist(gen, dist_three.param()); use(value_three_param); #endif #ifdef BOOST_RANDOM_TEST3_MIN - BOOST_CHECK_GE(value_three_param, BOOST_RANDOM_TEST3_MIN); + BOOST_TEST(value_three_param >= BOOST_RANDOM_TEST3_MIN); #endif #ifdef BOOST_RANDOM_TEST3_MAX - BOOST_CHECK_LE(value_three_param, BOOST_RANDOM_TEST3_MAX); + BOOST_TEST(value_three_param <= BOOST_RANDOM_TEST3_MAX); #endif } } @@ -279,34 +279,34 @@ BOOST_AUTO_TEST_CASE(test_generation_float) { result_type value = dist(gen); use(value); #ifdef BOOST_RANDOM_TEST1_MIN - BOOST_CHECK_GE(value, BOOST_RANDOM_TEST1_MIN); + BOOST_TEST(value >= BOOST_RANDOM_TEST1_MIN); #endif #ifdef BOOST_RANDOM_TEST1_MAX - BOOST_CHECK_LE(value, BOOST_RANDOM_TEST1_MAX); + BOOST_TEST(value <= BOOST_RANDOM_TEST1_MAX); #endif result_type value_two = dist_two(gen); use(value_two); #ifdef BOOST_RANDOM_TEST2_MIN - BOOST_CHECK_GE(value_two, BOOST_RANDOM_TEST2_MIN); + BOOST_TEST(value_two >= BOOST_RANDOM_TEST2_MIN); #endif #ifdef BOOST_RANDOM_TEST2_MAX - BOOST_CHECK_LE(value_two, BOOST_RANDOM_TEST2_MAX); + BOOST_TEST(value_two <= BOOST_RANDOM_TEST2_MAX); #endif result_type value_param = dist_two(gen, dist.param()); use(value_param); #ifdef BOOST_RANDOM_TEST1_MIN - BOOST_CHECK_GE(value_param, BOOST_RANDOM_TEST1_MIN); + BOOST_TEST(value_param >= BOOST_RANDOM_TEST1_MIN); #endif #ifdef BOOST_RANDOM_TEST1_MAX - BOOST_CHECK_LE(value_param, BOOST_RANDOM_TEST1_MAX); + BOOST_TEST(value_param <= BOOST_RANDOM_TEST1_MAX); #endif result_type value_two_param = dist(gen, dist_two.param()); use(value_two_param); #ifdef BOOST_RANDOM_TEST2_MIN - BOOST_CHECK_GE(value_two_param, BOOST_RANDOM_TEST2_MIN); + BOOST_TEST(value_two_param >= BOOST_RANDOM_TEST2_MIN); #endif #ifdef BOOST_RANDOM_TEST2_MAX - BOOST_CHECK_LE(value_two_param, BOOST_RANDOM_TEST2_MAX); + BOOST_TEST(value_two_param <= BOOST_RANDOM_TEST2_MAX); #endif } } diff --git a/test/test_generate_canonical.cpp b/test/test_generate_canonical.cpp index 002dca68d..ff1ac266a 100644 --- a/test/test_generate_canonical.cpp +++ b/test/test_generate_canonical.cpp @@ -32,18 +32,18 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_float, Engine, engines) Engine expected; for(int i = 0; i < 1000; ++i) { float val = boost::random::generate_canonical(eng); - BOOST_CHECK_GE(val, 0); - BOOST_CHECK_LT(val, 1); + BOOST_TEST(val >= 0.f); + BOOST_TEST(val < 1.f); } expected.discard(1000); - BOOST_CHECK_EQUAL(eng, expected); + BOOST_TEST(eng == expected); for(int i = 0; i < 1000; ++i) { float val = boost::random::generate_canonical(eng); - BOOST_CHECK_GE(val, 0); - BOOST_CHECK_LT(val, 1); + BOOST_TEST(val >= 0.f); + BOOST_TEST(val < 1.f); } expected.discard(1000); - BOOST_CHECK_EQUAL(eng, expected); + BOOST_TEST(eng == expected); } BOOST_AUTO_TEST_CASE_TEMPLATE(test_double, Engine, engines) @@ -52,18 +52,18 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_double, Engine, engines) Engine expected; for(int i = 0; i < 1000; ++i) { double val = boost::random::generate_canonical(eng); - BOOST_CHECK_GE(val, 0); - BOOST_CHECK_LT(val, 1); + BOOST_TEST(val >= 0); + BOOST_TEST(val < 1); } expected.discard(2000); - BOOST_CHECK_EQUAL(eng, expected); + BOOST_TEST(eng == expected); for(int i = 0; i < 1000; ++i) { double val = boost::random::generate_canonical(eng); - BOOST_CHECK_GE(val, 0); - BOOST_CHECK_LT(val, 1); + BOOST_TEST(val >= 0); + BOOST_TEST(val < 1); } expected.discard(1000); - BOOST_CHECK_EQUAL(eng, expected); + BOOST_TEST(eng == expected); } BOOST_AUTO_TEST_CASE_TEMPLATE(test_long_double, Engine, engines) @@ -72,18 +72,18 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_long_double, Engine, engines) Engine expected; for(int i = 0; i < 1000; ++i) { long double val = boost::random::generate_canonical(eng); - BOOST_CHECK_GE(val, 0); - BOOST_CHECK_LT(val, 1); + BOOST_TEST(val >= 0); + BOOST_TEST(val < 1); } expected.discard(2000); - BOOST_CHECK_EQUAL(eng, expected); + BOOST_TEST(eng == expected); for(int i = 0; i < 1000; ++i) { long double val = boost::random::generate_canonical(eng); - BOOST_CHECK_GE(val, 0); - BOOST_CHECK_LT(val, 1); + BOOST_TEST(val >= 0); + BOOST_TEST(val < 1); } expected.discard(1000); - BOOST_CHECK_EQUAL(eng, expected); + BOOST_TEST(eng == expected); } struct max_engine @@ -98,7 +98,7 @@ struct max_engine BOOST_AUTO_TEST_CASE(test_max) { max_engine eng; - BOOST_CHECK_LT((boost::random::generate_canonical(eng)), 1); - BOOST_CHECK_LT((boost::random::generate_canonical(eng)), 1); - BOOST_CHECK_LT((boost::random::generate_canonical(eng)), 1); + BOOST_TEST((boost::random::generate_canonical(eng)) < 1.f); + BOOST_TEST((boost::random::generate_canonical(eng)) < 1.); + BOOST_TEST((boost::random::generate_canonical(eng)) < 1.); } diff --git a/test/test_generator.ipp b/test/test_generator.ipp index beec667b0..3fd5877ed 100644 --- a/test/test_generator.ipp +++ b/test/test_generator.ipp @@ -88,9 +88,9 @@ BOOST_AUTO_TEST_CASE(test_default_seed) BOOST_RANDOM_URNG urng; BOOST_RANDOM_URNG urng2; urng2(); - BOOST_CHECK_NE(urng, urng2); + BOOST_TEST(urng != urng2); urng2.seed(); - BOOST_CHECK_EQUAL(urng, urng2); + BOOST_TEST(urng == urng2); } BOOST_AUTO_TEST_CASE(test_arithmetic_seed) @@ -110,15 +110,15 @@ BOOST_AUTO_TEST_CASE(test_iterator_seed) BOOST_RANDOM_URNG urng(it, it_end); BOOST_CHECK(it != v.begin()); std::iterator_traits::const_iterator>::difference_type n_words = (it - v.begin()); - BOOST_CHECK_GT(n_words, 0); - BOOST_CHECK_EQUAL(n_words, BOOST_RANDOM_SEED_WORDS); + BOOST_TEST(n_words > 0); + BOOST_TEST(n_words == BOOST_RANDOM_SEED_WORDS); it = v.begin(); BOOST_RANDOM_URNG urng2; urng2.seed(it, it_end); std::iterator_traits::const_iterator>::difference_type n_words2 = (it - v.begin()); - BOOST_CHECK_EQUAL(n_words, n_words2); - BOOST_CHECK_EQUAL(urng, urng2); + BOOST_TEST(n_words == n_words2); + BOOST_TEST(urng == urng2); it = v.end(); BOOST_CHECK_THROW(BOOST_RANDOM_URNG(it, it_end), std::invalid_argument); @@ -140,9 +140,9 @@ BOOST_AUTO_TEST_CASE(test_seed_seq_seed) boost::random::seed_seq q; BOOST_RANDOM_URNG urng(q); BOOST_RANDOM_URNG urng2; - BOOST_CHECK_NE(urng, urng2); + BOOST_TEST(urng != urng2); urng2.seed(q); - BOOST_CHECK_EQUAL(urng, urng2); + BOOST_TEST(urng == urng2); } template @@ -151,12 +151,12 @@ void do_test_streaming(const BOOST_RANDOM_URNG& urng) BOOST_RANDOM_URNG urng2; std::basic_ostringstream output; BOOST_TEST_REQUIRE(static_cast(output << urng)); - BOOST_CHECK_NE(urng, urng2); + BOOST_TEST(urng != urng2); // restore old state std::basic_istringstream input(output.str()); BOOST_TEST(static_cast(input >> urng2)); BOOST_TEST(input.eof()); - BOOST_CHECK_EQUAL(urng, urng2); + BOOST_TEST(urng == urng2); } BOOST_AUTO_TEST_CASE(test_streaming) @@ -173,12 +173,12 @@ BOOST_AUTO_TEST_CASE(test_discard) { BOOST_RANDOM_URNG urng; BOOST_RANDOM_URNG urng2; - BOOST_CHECK_EQUAL(urng, urng2); + BOOST_TEST(urng == urng2); for(int i = 0; i < BOOST_RANDOM_DISCARD_COUNT1; ++i) urng(); - BOOST_CHECK_NE(urng, urng2); + BOOST_TEST(urng != urng2); urng2.discard(BOOST_RANDOM_DISCARD_COUNT1); - BOOST_CHECK_EQUAL(urng, urng2); + BOOST_TEST(urng == urng2); } #ifdef BOOST_RANDOM_DISCARD_COUNT2 @@ -186,12 +186,12 @@ BOOST_AUTO_TEST_CASE(test_discard2) { BOOST_RANDOM_URNG urng; BOOST_RANDOM_URNG urng2; - BOOST_CHECK_EQUAL(urng, urng2); + BOOST_TEST(urng == urng2); for(int i = 0; i < BOOST_RANDOM_DISCARD_COUNT2; ++i) urng(); - BOOST_CHECK_NE(urng, urng2); + BOOST_TEST(urng != urng2); urng2.discard(BOOST_RANDOM_DISCARD_COUNT2); - BOOST_CHECK_EQUAL(urng, urng2); + BOOST_TEST(urng == urng2); } #endif @@ -206,7 +206,7 @@ BOOST_AUTO_TEST_CASE(test_discard_max) urng.discard(half); urng.discard(val - 2*half); urng2.discard(val); - BOOST_CHECK_EQUAL(urng, urng2); + BOOST_TEST(urng == urng2); } #endif @@ -216,16 +216,16 @@ BOOST_AUTO_TEST_CASE(test_copy) urng.discard(9307); { BOOST_RANDOM_URNG urng2 = urng; - BOOST_CHECK_EQUAL(urng, urng2); + BOOST_TEST(urng == urng2); } { BOOST_RANDOM_URNG urng2(urng); - BOOST_CHECK_EQUAL(urng, urng2); + BOOST_TEST(urng == urng2); } { BOOST_RANDOM_URNG urng2; urng2 = urng; - BOOST_CHECK_EQUAL(urng, urng2); + BOOST_TEST(urng == urng2); } } @@ -234,8 +234,8 @@ BOOST_AUTO_TEST_CASE(test_min_max) BOOST_RANDOM_URNG urng; for(int i = 0; i < 10000; ++i) { result_type value = urng(); - BOOST_CHECK_GE(value, (BOOST_RANDOM_URNG::min)()); - BOOST_CHECK_LE(value, (BOOST_RANDOM_URNG::max)()); + BOOST_TEST(value >= (BOOST_RANDOM_URNG::min)()); + BOOST_TEST(value <= (BOOST_RANDOM_URNG::max)()); } } @@ -261,7 +261,7 @@ BOOST_AUTO_TEST_CASE(validate) for(int i = 0; i < 9999; ++i) { urng(); } - BOOST_CHECK_EQUAL(urng(), BOOST_RANDOM_VALIDATION_VALUE); + BOOST_TEST(urng() == BOOST_RANDOM_VALIDATION_VALUE); } BOOST_AUTO_TEST_CASE(validate_seed_seq) @@ -271,7 +271,7 @@ BOOST_AUTO_TEST_CASE(validate_seed_seq) for(int i = 0; i < 9999; ++i) { urng(); } - BOOST_CHECK_EQUAL(urng(), BOOST_RANDOM_SEED_SEQ_VALIDATION_VALUE); + BOOST_TEST(urng() == BOOST_RANDOM_SEED_SEQ_VALIDATION_VALUE); } #if 0 @@ -284,7 +284,7 @@ BOOST_AUTO_TEST_CASE(validate_iter) for(int i = 0; i < 9999; ++i) { urng(); } - BOOST_CHECK_EQUAL(urng(), BOOST_RANDOM_ITERATOR_VALIDATION_VALUE); + BOOST_TEST(urng() == BOOST_RANDOM_ITERATOR_VALIDATION_VALUE); } BOOST_AUTO_TEST_CASE(test_generate) diff --git a/test/test_hyperexponential_distribution.cpp b/test/test_hyperexponential_distribution.cpp index 81c0b6987..564143de5 100644 --- a/test/test_hyperexponential_distribution.cpp +++ b/test/test_hyperexponential_distribution.cpp @@ -12,7 +12,6 @@ #include #include #include -#include #include #include #include @@ -23,11 +22,11 @@ #include -#define BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(T, actual, expected, tol)\ +#define BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(actual, expected, tol) \ do { \ - std::vector x = (actual); \ - std::vector y = (expected); \ - BOOST_CHECK_EQUAL( x.size(), y.size() ); \ + const std::vector& x = (actual); \ + const std::vector& y = expected; \ + BOOST_TEST( x.size() == y.size() ); \ const std::size_t n = x.size(); \ for (std::size_t i = 0; i < n; ++i) \ { \ @@ -42,7 +41,7 @@ namespace /**/ { namespace detail { template RealT make_tolerance() { - // Tolerance is 100eps expressed as a percentage (as required by Boost.Build): + // Tolerance is 100eps expressed as a percentage (as required by Boost.Test): return boost::math::tools::epsilon() * 100 * 100; } @@ -57,135 +56,135 @@ BOOST_AUTO_TEST_CASE( test_constructors ) // Test default ctor boost::random::hyperexponential_distribution<> dist; - BOOST_CHECK_EQUAL(dist.num_phases(), 1u); - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist.probabilities(), boost::assign::list_of(1.0), tol); - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist.rates(), boost::assign::list_of(1.0), tol); + BOOST_TEST(dist.num_phases() == 1u); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist.probabilities(), std::vector{1.0}, tol); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist.rates(), std::vector{1.0}, tol); #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) && !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) // Test ctor from initializer_list with probabilities and rates boost::random::hyperexponential_distribution<> dist_il_p_r = {{1, 2, 3, 4 }, {1, 2, 3, 4}}; - BOOST_CHECK_EQUAL(dist_il_p_r.num_phases(), 4u); - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_il_p_r.probabilities(), boost::assign::list_of(.1)(.2)(.3)(.4), tol); - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_il_p_r.rates(), boost::assign::list_of(1.)(2.)(3.)(4.), tol); + BOOST_TEST(dist_il_p_r.num_phases() == 4u); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_il_p_r.probabilities(), make_vector(.1, .2, .3, .4), tol); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_il_p_r.rates(), make_vector(1., 2., 3., 4.), tol); // Test ctor from initializer_list with rates boost::random::hyperexponential_distribution<> dist_il_r = {{1, 2, 3, 4}}; - BOOST_CHECK_EQUAL(dist_il_r.num_phases(), 4u); - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_il_r.probabilities(), boost::assign::list_of(.25)(.25)(.25)(.25), tol); - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_il_r.rates(), boost::assign::list_of(1.)(2.)(3.)(4.), tol); + BOOST_TEST(dist_il_r.num_phases() == 4u); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_il_r.probabilities(), make_vector(.25, .25, .25, .25), tol); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_il_r.rates(), make_vector(1., 2., 3., 4.), tol); #endif - const std::vector probs = boost::assign::list_of(0.1)(0.2)(0.3)(0.4); - const std::vector rates = boost::assign::list_of(1.0)(2.0)(3.0)(4.0); + const std::vector probs{ 0.1, 0.2, 0.3, 0.4 }; + const std::vector rates{ 1.0, 2.0, 3.0, 4.0 }; // Test ctor from range boost::random::hyperexponential_distribution<> dist_r(probs, rates); - BOOST_CHECK_EQUAL(dist_r.num_phases(), 4u); - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_r.probabilities(), probs, tol); - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_r.rates(), rates, tol); + BOOST_TEST(dist_r.num_phases() == 4u); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_r.probabilities(), probs, tol); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_r.rates(), rates, tol); // Test ctor from iterators boost::random::hyperexponential_distribution<> dist_it(probs.begin(), probs.end(), rates.begin(), rates.end()); - BOOST_CHECK_EQUAL(dist_it.num_phases(), 4u); - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_it.probabilities(), probs, tol); - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_it.rates(), rates, tol); + BOOST_TEST(dist_it.num_phases() == 4u); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_it.probabilities(), probs, tol); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_it.rates(), rates, tol); // Test ctor from rate iterators boost::random::hyperexponential_distribution<> dist_r_it(rates.begin(), rates.end()); - BOOST_CHECK_EQUAL(dist_r_it.num_phases(), 4u); - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_r_it.probabilities(), boost::assign::list_of(.25)(.25)(.25)(.25), tol); - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_r_it.rates(), rates, tol); + BOOST_TEST(dist_r_it.num_phases() == 4u); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_r_it.probabilities(), make_vector(.25, .25, .25, .25), tol); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_r_it.rates(), rates, tol); // Test ctor from rate iterators #2 { const double rates2[] = {1.0,2.0,3.0,4.0}; boost::random::hyperexponential_distribution<> dist_r_it(rates2, rates2+4); - BOOST_CHECK_EQUAL(dist_r_it.num_phases(), 4u); - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_r_it.probabilities(), boost::assign::list_of(.25)(.25)(.25)(.25), tol); - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_r_it.rates(), std::vector(rates2, rates2+4), tol); + BOOST_TEST(dist_r_it.num_phases() == 4u); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_r_it.probabilities(), make_vector(.25, .25, .25, .25), tol); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_r_it.rates(), std::vector(rates2, rates2+4), tol); } // Test ctor from rate range boost::random::hyperexponential_distribution<> dist_r_r(rates); - BOOST_CHECK_EQUAL(dist_r_r.num_phases(), 4u); - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_r_r.probabilities(), boost::assign::list_of(.25)(.25)(.25)(.25), tol); - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_r_r.rates(), rates, tol); + BOOST_TEST(dist_r_r.num_phases() == 4u); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_r_r.probabilities(), make_vector(.25, .25, .25, .25), tol); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_r_r.rates(), rates, tol); // Test copy ctor boost::random::hyperexponential_distribution<> cp(dist); - BOOST_CHECK_EQUAL(cp, dist); + BOOST_TEST(cp == dist); boost::random::hyperexponential_distribution<> cp_r(dist_r); - BOOST_CHECK_EQUAL(cp_r, dist_r); + BOOST_TEST(cp_r == dist_r); } BOOST_AUTO_TEST_CASE( test_param ) { const double tol = detail::make_tolerance(); - const std::vector probs = boost::assign::list_of(0.1)(0.2)(0.3)(0.4); - const std::vector rates = boost::assign::list_of(1.0)(2.0)(3.0)(4.0); + const std::vector probs{ 0.1, 0.2, 0.3, 0.4 }; + const std::vector rates{ 1.0, 2.0, 3.0, 4.0 }; // Test param getter boost::random::hyperexponential_distribution<> dist(probs, rates); boost::random::hyperexponential_distribution<>::param_type param = dist.param(); - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist.probabilities(), param.probabilities(), tol); - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist.rates(), param.rates(), tol); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist.probabilities(), param.probabilities(), tol); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist.rates(), param.rates(), tol); // Test ctor from param boost::random::hyperexponential_distribution<> cp1(param); - BOOST_CHECK_EQUAL(cp1, dist); + BOOST_TEST(cp1 == dist); // Test param setter boost::random::hyperexponential_distribution<> cp2; cp2.param(param); - BOOST_CHECK_EQUAL(cp2, dist); + BOOST_TEST(cp2 == dist); // Test param constructors & operators boost::random::hyperexponential_distribution<>::param_type param_copy = param; - BOOST_CHECK_EQUAL(param, param_copy); + BOOST_TEST(param == param_copy); BOOST_CHECK(param == param_copy); BOOST_CHECK(!(param != param_copy)); boost::random::hyperexponential_distribution<>::param_type param_default; - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, param_default.probabilities(), boost::assign::list_of(1.0), tol); - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, param_default.rates(), boost::assign::list_of(1.0), tol); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(param_default.probabilities(), std::vector{1.0}, tol); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(param_default.rates(), std::vector{1.0}, tol); BOOST_CHECK(param != param_default); BOOST_CHECK(!(param == param_default)); #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) && !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) boost::random::hyperexponential_distribution<>::param_type param_il = {{1, 2, 3, 4 }, {1, 2, 3, 4}}; - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, param_il.probabilities(), boost::assign::list_of(.1)(.2)(.3)(.4), tol); - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, param_il.rates(), boost::assign::list_of(1.)(2.)(3.)(4.), tol); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(param_il.probabilities(), make_vector(.1, .2, .3, .4), tol); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(param_il.rates(), make_vector(1., 2., 3., 4.), tol); #endif boost::random::hyperexponential_distribution<>::param_type param_r(probs, rates); - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, param_r.probabilities(), probs, tol); - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, param_r.rates(), rates, tol); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(param_r.probabilities(), probs, tol); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(param_r.rates(), rates, tol); boost::random::hyperexponential_distribution<>::param_type param_it(probs.begin(), probs.end(), rates.begin(), rates.end()); - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, param_it.probabilities(), probs, tol); - BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, param_it.rates(), rates, tol); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(param_it.probabilities(), probs, tol); + BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(param_it.rates(), rates, tol); } BOOST_AUTO_TEST_CASE( test_min_max ) { //const double tol = detail::make_tolerance(); - const std::vector probs = boost::assign::list_of(0.1)(0.2)(0.3)(0.4); - const std::vector rates = boost::assign::list_of(1.0)(2.0)(3.0)(4.0); + const std::vector probs{ 0.1, 0.2, 0.3, 0.4 }; + const std::vector rates{ 1.0, 2.0, 3.0, 4.0 }; boost::random::hyperexponential_distribution<> dist; - BOOST_CHECK_EQUAL((dist.min)(), 0); - BOOST_CHECK_EQUAL((dist.max)(), (std::numeric_limits::infinity)()); + BOOST_TEST((dist.min)() == 0); + BOOST_TEST((dist.max)() == (std::numeric_limits::infinity)()); boost::random::hyperexponential_distribution<> dist_r(probs, rates); - BOOST_CHECK_EQUAL((dist_r.min)(), 0); - BOOST_CHECK_EQUAL((dist_r.max)(), (std::numeric_limits::infinity)()); + BOOST_TEST((dist_r.min)() == 0); + BOOST_TEST((dist_r.max)() == (std::numeric_limits::infinity)()); } BOOST_AUTO_TEST_CASE(test_comparison) { //const double tol = detail::make_tolerance(); - const std::vector probs = boost::assign::list_of(0.1)(0.2)(0.3)(0.4); - const std::vector rates = boost::assign::list_of(1.0)(2.0)(3.0)(4.0); + const std::vector probs{ 0.1, 0.2, 0.3, 0.4 }; + const std::vector rates{ 1.0, 2.0, 3.0, 4.0 }; boost::random::hyperexponential_distribution<> dist; boost::random::hyperexponential_distribution<> dist_copy(dist); @@ -205,8 +204,8 @@ BOOST_AUTO_TEST_CASE( test_streaming ) { //const double tol = detail::make_tolerance(); - const std::vector probs = boost::assign::list_of(0.1)(0.2)(0.3)(0.4); - const std::vector rates = boost::assign::list_of(1.0)(2.0)(3.0)(4.0); + const std::vector probs{ 0.1, 0.2, 0.3, 0.4 }; + const std::vector rates{ 1.0, 2.0, 3.0, 4.0 }; const std::vector empty_vector; // Test the reading of param_type @@ -218,7 +217,7 @@ BOOST_AUTO_TEST_CASE( test_streaming ) ss << parm; boost::random::hyperexponential_distribution<>::param_type restored_parm; ss >> restored_parm; - BOOST_CHECK_EQUAL(parm, restored_parm); + BOOST_TEST(parm == restored_parm); } // - Test with an empty probability vector and ios_base exceptions disabled @@ -230,7 +229,7 @@ BOOST_AUTO_TEST_CASE( test_streaming ) boost::random::hyperexponential_distribution<>::param_type param; ss >> param; boost::random::hyperexponential_distribution<>::param_type check_param(std::vector(rates.size(), 1), rates); - BOOST_CHECK_EQUAL(param, check_param); + BOOST_TEST(param == check_param); } // - Test with an empty rate vector and ios_base exceptions disabled @@ -242,7 +241,7 @@ BOOST_AUTO_TEST_CASE( test_streaming ) boost::random::hyperexponential_distribution<>::param_type param; ss >> param; boost::random::hyperexponential_distribution<>::param_type check_param(probs, std::vector(probs.size(), 1)); - BOOST_CHECK_EQUAL(param, check_param); + BOOST_TEST(param == check_param); } // - Test with an empty probability and rate vectors and ios_base exceptions disabled @@ -254,7 +253,7 @@ BOOST_AUTO_TEST_CASE( test_streaming ) boost::random::hyperexponential_distribution<>::param_type param; ss >> param; boost::random::hyperexponential_distribution<>::param_type check_param; - BOOST_CHECK_EQUAL(param, check_param); + BOOST_TEST(param == check_param); } // - Test with an empty probability vector and ios_base exceptions enabled @@ -267,7 +266,7 @@ BOOST_AUTO_TEST_CASE( test_streaming ) ss.exceptions(std::ios_base::failbit); ss >> param; boost::random::hyperexponential_distribution<>::param_type check_param(std::vector(rates.size(), 1), rates); - BOOST_CHECK_EQUAL(param, check_param); + BOOST_TEST(param == check_param); } // - Test with an empty rate vector and ios_base exceptions enabled @@ -280,7 +279,7 @@ BOOST_AUTO_TEST_CASE( test_streaming ) ss.exceptions(std::ios_base::failbit); ss >> param; boost::random::hyperexponential_distribution<>::param_type check_param(probs, std::vector(probs.size(), 1)); - BOOST_CHECK_EQUAL(param, check_param); + BOOST_TEST(param == check_param); } // - Test with an empty probability and rate vectors and ios_base exceptions enabled @@ -293,7 +292,7 @@ BOOST_AUTO_TEST_CASE( test_streaming ) ss.exceptions(std::ios_base::failbit); ss >> param; boost::random::hyperexponential_distribution<>::param_type check_param; - BOOST_CHECK_EQUAL(param, check_param); + BOOST_TEST(param == check_param); } // The the reading of hyperexponential_distribution @@ -305,7 +304,7 @@ BOOST_AUTO_TEST_CASE( test_streaming ) ss << dist; boost::random::hyperexponential_distribution<> restored_dist; ss >> restored_dist; - BOOST_CHECK_EQUAL(dist, restored_dist); + BOOST_TEST(dist == restored_dist); } // - Test with an empty probability vector and ios_base exceptions disabled @@ -317,7 +316,7 @@ BOOST_AUTO_TEST_CASE( test_streaming ) boost::random::hyperexponential_distribution<> dist; ss >> dist; boost::random::hyperexponential_distribution<> check_dist(std::vector(rates.size(), 1), rates); - BOOST_CHECK_EQUAL(dist, check_dist); + BOOST_TEST(dist == check_dist); } // - Test with an empty rate vector and ios_base exceptions disabled @@ -329,7 +328,7 @@ BOOST_AUTO_TEST_CASE( test_streaming ) boost::random::hyperexponential_distribution<> dist; ss >> dist; boost::random::hyperexponential_distribution<> check_dist(probs, std::vector(probs.size(), 1)); - BOOST_CHECK_EQUAL(dist, check_dist); + BOOST_TEST(dist == check_dist); } // - Test with an empty probability and rate vectors and ios_base exceptions disabled @@ -341,7 +340,7 @@ BOOST_AUTO_TEST_CASE( test_streaming ) boost::random::hyperexponential_distribution<> dist; ss >> dist; boost::random::hyperexponential_distribution<> check_dist; - BOOST_CHECK_EQUAL(dist, check_dist); + BOOST_TEST(dist == check_dist); } // - Test with an empty probability vector and ios_base exceptions enabled @@ -354,7 +353,7 @@ BOOST_AUTO_TEST_CASE( test_streaming ) ss.exceptions(std::ios_base::failbit); ss >> dist; boost::random::hyperexponential_distribution<> check_dist(std::vector(rates.size(), 1), rates); - BOOST_CHECK_EQUAL(dist, check_dist); + BOOST_TEST(dist == check_dist); } // - Test with an empty rate vector and ios_base exceptions enabled @@ -367,7 +366,7 @@ BOOST_AUTO_TEST_CASE( test_streaming ) ss.exceptions(std::ios_base::failbit); ss >> dist; boost::random::hyperexponential_distribution<> check_dist(probs, std::vector(probs.size(), 1)); - BOOST_CHECK_EQUAL(dist, check_dist); + BOOST_TEST(dist == check_dist); } // - Test with an empty probability and rate vectors and ios_base exceptions enabled @@ -380,7 +379,7 @@ BOOST_AUTO_TEST_CASE( test_streaming ) ss.exceptions(std::ios_base::failbit); ss >> dist; boost::random::hyperexponential_distribution<> check_dist; - BOOST_CHECK_EQUAL(dist, check_dist); + BOOST_TEST(dist == check_dist); } } @@ -389,21 +388,21 @@ BOOST_AUTO_TEST_CASE( test_streaming ) //{ // const double tol = detail::make_tolerance(); // -// const std::vector probs = boost::assign::list_of(1023.0)(1.0); -// const std::vector rates = boost::assign::list_of(1023.0)(1.0); -// const std::vector norm_probs = boost::assign::list_of(1023.0/1024.0)(1.0/1024.0); +// const std::vector probs{ 1023.0, 1.0 }; +// const std::vector rates{ 1023.0, 1.0 }; +// const std::vector norm_probs{ 1023.0/1024.0, 1.0/1024.0 }; // // boost::random::hyperexponential_distribution<> dist(probs, rates); // BOOST_CHECK( boost::random::hyperexp_detail::check_params(dist.probabilities(), dist.rates()) ); -// BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist.probabilities(), norm_probs, tol); +// BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist.probabilities(), norm_probs, tol); // -// const std::vector probs2 = boost::assign::list_of(1001.0)(1.0); -// const std::vector rates2 = boost::assign::list_of(1001.0)(1.0); -// const std::vector norm_probs2 = boost::assign::list_of(1001.0/1002.0)(1.0/1002.0); +// const std::vector probs2{ 1001.0, 1.0 }; +// const std::vector rates2{ 1001.0, 1.0 }; +// const std::vector norm_probs2{ 1001.0/1002.0, 1.0/1002.0 }; // // boost::random::hyperexponential_distribution<> dist2(probs2, rates2); // BOOST_CHECK( boost::random::hyperexp_detail::check_params(dist2.probabilities(), dist2.rates()) ); -// BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist2.probabilities(), norm_probs2, tol); +// BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist2.probabilities(), norm_probs2, tol); //} void use(boost::random::hyperexponential_distribution<>::result_type) {} @@ -412,8 +411,8 @@ BOOST_AUTO_TEST_CASE(test_generation) { //const double tol = detail::make_tolerance(); - const std::vector probs = boost::assign::list_of(0.1)(0.2)(0.3)(0.4); - const std::vector rates = boost::assign::list_of(1.0)(2.0)(3.0)(4.0); + const std::vector probs{ 0.1, 0.2, 0.3, 0.4 }; + const std::vector rates{ 1.0, 2.0, 3.0, 4.0 }; boost::minstd_rand0 gen; @@ -424,16 +423,16 @@ BOOST_AUTO_TEST_CASE(test_generation) { const result_type value = dist(gen); use(value); - BOOST_CHECK_GE(value, static_cast(0)); + BOOST_TEST(value >= static_cast(0)); const result_type value_r = dist_r(gen); use(value_r); - BOOST_CHECK_GE(value_r, static_cast(0)); + BOOST_TEST(value_r >= static_cast(0)); const result_type value_param = dist_r(gen, dist.param()); use(value_param); - BOOST_CHECK_GE(value_param, static_cast(0)); + BOOST_TEST(value_param >= static_cast(0)); const result_type value_r_param = dist(gen, dist_r.param()); use(value_r_param); - BOOST_CHECK_GE(value_r_param, static_cast(0)); + BOOST_TEST(value_r_param >= static_cast(0)); } } @@ -441,8 +440,8 @@ BOOST_AUTO_TEST_CASE( test_generation_float ) { //const double tol = detail::make_tolerance(); - const std::vector probs = boost::assign::list_of(0.1)(0.2)(0.3)(0.4); - const std::vector rates = boost::assign::list_of(1.0)(2.0)(3.0)(4.0); + const std::vector probs{ 0.1, 0.2, 0.3, 0.4 }; + const std::vector rates{ 1.0, 2.0, 3.0, 4.0 }; boost::lagged_fibonacci607 gen; @@ -453,15 +452,15 @@ BOOST_AUTO_TEST_CASE( test_generation_float ) { const result_type value = dist(gen); use(value); - BOOST_CHECK_GE(value, static_cast(0)); + BOOST_TEST(value >= static_cast(0)); const result_type value_r = dist_r(gen); use(value_r); - BOOST_CHECK_GE(value_r, static_cast(0)); + BOOST_TEST(value_r >= static_cast(0)); const result_type value_param = dist_r(gen, dist.param()); use(value_param); - BOOST_CHECK_GE(value_param, static_cast(0)); + BOOST_TEST(value_param >= static_cast(0)); const result_type value_r_param = dist(gen, dist_r.param()); use(value_r_param); - BOOST_CHECK_GE(value_r_param, static_cast(0)); + BOOST_TEST(value_r_param >= static_cast(0)); } } diff --git a/test/test_mixmax.cpp b/test/test_mixmax.cpp index c300637d1..817ab4f30 100644 --- a/test/test_mixmax.cpp +++ b/test/test_mixmax.cpp @@ -40,13 +40,13 @@ BOOST_AUTO_TEST_CASE(test_special_seed) { seed.generate(vec.begin(), vec.end()); // fill vec with ones std::vector::iterator it = vec.begin(); boost::random::mixmax gen1(it, vec.end()); // init gen1 with vec iterator - BOOST_CHECK_EQUAL(gen1(), 775778250716139533ULL); - BOOST_CHECK_EQUAL(gen1(), 846264592759195742ULL); + BOOST_TEST(gen1() == 775778250716139533ULL); + BOOST_TEST(gen1() == 846264592759195742ULL); boost::random::mixmax gen2(seed); // init gen2 with seeq_seq, should be the same as gen1! - BOOST_CHECK_EQUAL(gen2(), 775778250716139533ULL); - BOOST_CHECK_EQUAL(gen2(), 846264592759195742ULL); + BOOST_TEST(gen2() == 775778250716139533ULL); + BOOST_TEST(gen2() == 846264592759195742ULL); - BOOST_CHECK_EQUAL(gen1, gen2); + BOOST_TEST(gen1 == gen2); } } diff --git a/test/test_mt19937.cpp b/test/test_mt19937.cpp index 5f2aa36a8..9e3284df1 100644 --- a/test/test_mt19937.cpp +++ b/test/test_mt19937.cpp @@ -53,14 +53,14 @@ BOOST_AUTO_TEST_CASE(test_special_seed) { std::vector::iterator it = vec.begin(); boost::mt19937 gen1(it, vec.end()); - BOOST_CHECK_EQUAL(gen1(), 0u); - BOOST_CHECK_EQUAL(gen1(), 0u); + BOOST_TEST(gen1() == 0u); + BOOST_TEST(gen1() == 0u); boost::mt19937 gen2(seed); - BOOST_CHECK_EQUAL(gen2(), 0u); - BOOST_CHECK_EQUAL(gen2(), 0u); + BOOST_TEST(gen2() == 0u); + BOOST_TEST(gen2() == 0u); - BOOST_CHECK_EQUAL(gen1, gen2); + BOOST_TEST(gen1 == gen2); } { seed_seq_0 seed; @@ -69,13 +69,13 @@ BOOST_AUTO_TEST_CASE(test_special_seed) { std::vector::iterator it = vec.begin(); boost::mt19937 gen1(it, vec.end()); - BOOST_CHECK_EQUAL(gen1(), 1141379330u); - BOOST_CHECK_EQUAL(gen1(), 0u); + BOOST_TEST(gen1() == 1141379330u); + BOOST_TEST(gen1() == 0u); boost::mt19937 gen2(seed); - BOOST_CHECK_EQUAL(gen2(), 1141379330u); - BOOST_CHECK_EQUAL(gen2(), 0u); + BOOST_TEST(gen2() == 1141379330u); + BOOST_TEST(gen2() == 0u); - BOOST_CHECK_EQUAL(gen1, gen2); + BOOST_TEST(gen1 == gen2); } } diff --git a/test/test_old_uniform_int_distribution.cpp b/test/test_old_uniform_int_distribution.cpp index b6b8c6776..5fa912f04 100644 --- a/test/test_old_uniform_int_distribution.cpp +++ b/test/test_old_uniform_int_distribution.cpp @@ -48,7 +48,7 @@ BOOST_AUTO_TEST_CASE(test_random_shuffle) { #ifndef BOOST_NO_CXX98_RANDOM_SHUFFLE - typedef boost::uniform_int<> distribution_type; + typedef boost::uniform_int distribution_type; typedef boost::variate_generator generator_type; boost::mt19937 engine1(1234); @@ -70,8 +70,6 @@ BOOST_AUTO_TEST_CASE(test_random_shuffle) std::random_shuffle(referenceVec.begin(), referenceVec.end(), referenceRand); std::random_shuffle(testVec.begin(), testVec.end(), testRand); - BOOST_CHECK_EQUAL_COLLECTIONS( - testVec.begin(), testVec.end(), - referenceVec.begin(), referenceVec.end()); + BOOST_TEST(testVec == referenceVec, boost::test_tools::per_element()); #endif } diff --git a/test/test_piecewise_constant_distribution.cpp b/test/test_piecewise_constant_distribution.cpp index 793c3e657..f39c1ebef 100644 --- a/test/test_piecewise_constant_distribution.cpp +++ b/test/test_piecewise_constant_distribution.cpp @@ -11,7 +11,6 @@ #include #include -#include #include #include #include "concepts.hpp" @@ -34,108 +33,104 @@ struct gen { } }; -#define CHECK_SEQUENCE(actual, expected) \ - do { \ - std::vector _actual = (actual); \ - std::vector _expected = (expected); \ - BOOST_CHECK_EQUAL_COLLECTIONS( \ - _actual.begin(), _actual.end(), \ - _expected.begin(), _expected.end()); \ +#define CHECK_SEQUENCE(actual, expected) \ + do { \ + const std::vector& actual_ = (actual); \ + std::vector expected_ = make_vectorexpected; \ + BOOST_TEST(actual_ == expected_, boost::test_tools::per_element()); \ } while(false) -using boost::assign::list_of; - BOOST_AUTO_TEST_CASE(test_constructors) { boost::random::piecewise_constant_distribution<> dist; - CHECK_SEQUENCE(dist.densities(), list_of(1.0)); - CHECK_SEQUENCE(dist.intervals(), list_of(0.0)(1.0)); + CHECK_SEQUENCE(dist.densities(), (1.0)); + CHECK_SEQUENCE(dist.intervals(), (0.0, 1.0)); #ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST boost::random::piecewise_constant_distribution<> dist_il = { { 99, 103, 107, 111, 115 }, gen() }; - CHECK_SEQUENCE(dist_il.intervals(), list_of(99)(103)(107)(111)(115)); - CHECK_SEQUENCE(dist_il.densities(), list_of(.03125)(.0625)(.03125)(.125)); + CHECK_SEQUENCE(dist_il.intervals(), (99, 103, 107, 111, 115)); + CHECK_SEQUENCE(dist_il.densities(), (.03125, .0625, .03125, .125)); boost::random::piecewise_constant_distribution<> dist_il2 = { { 99 }, gen() }; - CHECK_SEQUENCE(dist_il2.intervals(), list_of(0.0)(1.0)); - CHECK_SEQUENCE(dist_il2.densities(), list_of(1.0)); + CHECK_SEQUENCE(dist_il2.intervals(), (0.0, 1.0)); + CHECK_SEQUENCE(dist_il2.densities(), (1.0)); #endif - std::vector intervals = boost::assign::list_of(0)(1)(2)(3)(5); - std::vector weights = boost::assign::list_of(1)(2)(1)(4); - std::vector intervals2 = boost::assign::list_of(99); + std::vector intervals{ 0, 1, 2, 3, 5 }; + std::vector weights{ 1, 2, 1, 4 }; + std::vector intervals2{ 99 }; std::vector weights2; boost::random::piecewise_constant_distribution<> dist_r(intervals, weights); - CHECK_SEQUENCE(dist_r.intervals(), list_of(0)(1)(2)(3)(5)); - CHECK_SEQUENCE(dist_r.densities(), list_of(.125)(.25)(.125)(.25)); + CHECK_SEQUENCE(dist_r.intervals(), (0, 1, 2, 3, 5)); + CHECK_SEQUENCE(dist_r.densities(), (.125, .25, .125, .25)); boost::random::piecewise_constant_distribution<> dist_r2(intervals2, weights2); - CHECK_SEQUENCE(dist_r2.intervals(), list_of(0.0)(1.0)); - CHECK_SEQUENCE(dist_r2.densities(), list_of(1.0)); + CHECK_SEQUENCE(dist_r2.intervals(), (0.0, 1.0)); + CHECK_SEQUENCE(dist_r2.densities(), (1.0)); boost::random::piecewise_constant_distribution<> dist_it( intervals.begin(), intervals.end(), weights.begin()); - CHECK_SEQUENCE(dist_it.intervals(), list_of(0)(1)(2)(3)(5)); - CHECK_SEQUENCE(dist_it.densities(), list_of(.125)(.25)(.125)(.25)); + CHECK_SEQUENCE(dist_it.intervals(), (0, 1, 2, 3, 5)); + CHECK_SEQUENCE(dist_it.densities(), (.125, .25, .125, .25)); boost::random::piecewise_constant_distribution<> dist_it2( intervals2.begin(), intervals2.end(), weights2.begin()); - CHECK_SEQUENCE(dist_it2.intervals(), list_of(0.0)(1.0)); - CHECK_SEQUENCE(dist_it2.densities(), list_of(1.0)); + CHECK_SEQUENCE(dist_it2.intervals(), (0.0, 1.0)); + CHECK_SEQUENCE(dist_it2.densities(), (1.0)); boost::random::piecewise_constant_distribution<> dist_fun(4, 99,115, gen()); - CHECK_SEQUENCE(dist_fun.intervals(), list_of(99)(103)(107)(111)(115)); - CHECK_SEQUENCE(dist_fun.densities(), list_of(.03125)(.0625)(.03125)(.125)); + CHECK_SEQUENCE(dist_fun.intervals(), (99, 103, 107, 111, 115)); + CHECK_SEQUENCE(dist_fun.densities(), (.03125, .0625, .03125, .125)); boost::random::piecewise_constant_distribution<> dist_fun2(1, 99, 115, gen()); - CHECK_SEQUENCE(dist_fun2.intervals(), list_of(99)(115)); - CHECK_SEQUENCE(dist_fun2.densities(), list_of(0.0625)); + CHECK_SEQUENCE(dist_fun2.intervals(), (99, 115)); + CHECK_SEQUENCE(dist_fun2.densities(), (0.0625)); boost::random::piecewise_constant_distribution<> copy(dist); - BOOST_CHECK_EQUAL(dist, copy); + BOOST_TEST(dist == copy); boost::random::piecewise_constant_distribution<> copy_r(dist_r); - BOOST_CHECK_EQUAL(dist_r, copy_r); + BOOST_TEST(dist_r == copy_r); boost::random::piecewise_constant_distribution<> notpow2(3, 99, 111, gen()); BOOST_REQUIRE_EQUAL(notpow2.densities().size(), 3u); - BOOST_CHECK_CLOSE_FRACTION(notpow2.densities()[0], 0.0625, 0.00000000001); - BOOST_CHECK_CLOSE_FRACTION(notpow2.densities()[1], 0.125, 0.00000000001); - BOOST_CHECK_CLOSE_FRACTION(notpow2.densities()[2], 0.0625, 0.00000000001); + BOOST_TEST(notpow2.densities()[0] == 0.0625, boost::test_tools::tolerance(0.00000000001)); + BOOST_TEST(notpow2.densities()[1] == 0.125, boost::test_tools::tolerance(0.00000000001)); + BOOST_TEST(notpow2.densities()[2] == 0.0625, boost::test_tools::tolerance(0.00000000001)); boost::random::piecewise_constant_distribution<> copy_notpow2(notpow2); - BOOST_CHECK_EQUAL(notpow2, copy_notpow2); + BOOST_TEST(notpow2 == copy_notpow2); } BOOST_AUTO_TEST_CASE(test_param) { - std::vector intervals = boost::assign::list_of(0)(1)(2)(3)(5); - std::vector weights = boost::assign::list_of(1)(2)(1)(4); - std::vector intervals2 = boost::assign::list_of(0); + std::vector intervals{ 0, 1, 2, 3, 5 }; + std::vector weights{ 1, 2, 1, 4 }; + std::vector intervals2{ 0 }; std::vector weights2; boost::random::piecewise_constant_distribution<> dist(intervals, weights); boost::random::piecewise_constant_distribution<>::param_type param = dist.param(); - CHECK_SEQUENCE(param.intervals(), list_of(0)(1)(2)(3)(5)); - CHECK_SEQUENCE(param.densities(), list_of(.125)(.25)(.125)(.25)); + CHECK_SEQUENCE(param.intervals(), (0, 1, 2, 3, 5)); + CHECK_SEQUENCE(param.densities(), (.125, .25, .125, .25)); boost::random::piecewise_constant_distribution<> copy1(param); - BOOST_CHECK_EQUAL(dist, copy1); + BOOST_TEST(dist == copy1); boost::random::piecewise_constant_distribution<> copy2; copy2.param(param); - BOOST_CHECK_EQUAL(dist, copy2); + BOOST_TEST(dist == copy2); boost::random::piecewise_constant_distribution<>::param_type param_copy = param; - BOOST_CHECK_EQUAL(param, param_copy); + BOOST_TEST(param == param_copy); BOOST_CHECK(param == param_copy); BOOST_CHECK(!(param != param_copy)); boost::random::piecewise_constant_distribution<>::param_type param_default; - CHECK_SEQUENCE(param_default.intervals(), list_of(0.0)(1.0)); - CHECK_SEQUENCE(param_default.densities(), list_of(1.0)); + CHECK_SEQUENCE(param_default.intervals(), (0.0, 1.0)); + CHECK_SEQUENCE(param_default.densities(), (1.0)); BOOST_CHECK(param != param_default); BOOST_CHECK(!(param == param_default)); @@ -144,62 +139,62 @@ BOOST_AUTO_TEST_CASE(test_param) { { 99, 103, 107, 111, 115 }, gen() }; - CHECK_SEQUENCE(parm_il.intervals(), list_of(99)(103)(107)(111)(115)); - CHECK_SEQUENCE(parm_il.densities(), list_of(.03125)(.0625)(.03125)(.125)); + CHECK_SEQUENCE(parm_il.intervals(), (99, 103, 107, 111, 115)); + CHECK_SEQUENCE(parm_il.densities(), (.03125, .0625, .03125, .125)); boost::random::piecewise_constant_distribution<>::param_type parm_il2 = { { 99 }, gen() }; - CHECK_SEQUENCE(parm_il2.intervals(), list_of(0.0)(1.0)); - CHECK_SEQUENCE(parm_il2.densities(), list_of(1.0)); + CHECK_SEQUENCE(parm_il2.intervals(), (0.0, 1.0)); + CHECK_SEQUENCE(parm_il2.densities(), (1.0)); #endif boost::random::piecewise_constant_distribution<>::param_type parm_r(intervals, weights); - CHECK_SEQUENCE(parm_r.intervals(), list_of(0)(1)(2)(3)(5)); - CHECK_SEQUENCE(parm_r.densities(), list_of(.125)(.25)(.125)(.25)); + CHECK_SEQUENCE(parm_r.intervals(), (0, 1, 2, 3, 5)); + CHECK_SEQUENCE(parm_r.densities(), (.125, .25, .125, .25)); boost::random::piecewise_constant_distribution<>::param_type parm_r2(intervals2, weights2); - CHECK_SEQUENCE(parm_r2.intervals(), list_of(0.0)(1.0)); - CHECK_SEQUENCE(parm_r2.densities(), list_of(1.0)); + CHECK_SEQUENCE(parm_r2.intervals(), (0.0, 1.0)); + CHECK_SEQUENCE(parm_r2.densities(), (1.0)); boost::random::piecewise_constant_distribution<>::param_type parm_it(intervals.begin(), intervals.end(), weights.begin()); - CHECK_SEQUENCE(parm_it.intervals(), list_of(0)(1)(2)(3)(5)); - CHECK_SEQUENCE(parm_it.densities(), list_of(.125)(.25)(.125)(.25)); + CHECK_SEQUENCE(parm_it.intervals(), (0, 1, 2, 3, 5)); + CHECK_SEQUENCE(parm_it.densities(), (.125, .25, .125, .25)); boost::random::piecewise_constant_distribution<>::param_type parm_it2(intervals2.begin(), intervals2.end(), weights2.begin()); - CHECK_SEQUENCE(parm_it2.intervals(), list_of(0.0)(1.0)); - CHECK_SEQUENCE(parm_it2.densities(), list_of(1.0)); + CHECK_SEQUENCE(parm_it2.intervals(), (0.0, 1.0)); + CHECK_SEQUENCE(parm_it2.densities(), (1.0)); boost::random::piecewise_constant_distribution<>::param_type parm_fun(4, 99, 115, gen()); - CHECK_SEQUENCE(parm_fun.intervals(), list_of(99)(103)(107)(111)(115)); - CHECK_SEQUENCE(parm_fun.densities(), list_of(.03125)(.0625)(.03125)(.125)); + CHECK_SEQUENCE(parm_fun.intervals(), (99, 103, 107, 111, 115)); + CHECK_SEQUENCE(parm_fun.densities(), (.03125, .0625, .03125, .125)); boost::random::piecewise_constant_distribution<>::param_type parm_fun2(1, 99, 115, gen()); - CHECK_SEQUENCE(parm_fun2.intervals(), list_of(99)(115)); - CHECK_SEQUENCE(parm_fun2.densities(), list_of(0.0625)); + CHECK_SEQUENCE(parm_fun2.intervals(), (99, 115)); + CHECK_SEQUENCE(parm_fun2.densities(), (0.0625)); } BOOST_AUTO_TEST_CASE(test_min_max) { - std::vector intervals = boost::assign::list_of(0)(1)(2)(3)(5); - std::vector weights = boost::assign::list_of(1)(2)(1)(4); + std::vector intervals{ 0, 1, 2, 3, 5 }; + std::vector weights{ 1, 2, 1, 4 }; boost::random::piecewise_constant_distribution<> dist; - BOOST_CHECK_EQUAL((dist.min)(), 0.0); - BOOST_CHECK_EQUAL((dist.max)(), 1.0); + BOOST_TEST((dist.min)() == 0.0); + BOOST_TEST((dist.max)() == 1.0); boost::random::piecewise_constant_distribution<> dist_r(intervals, weights); - BOOST_CHECK_EQUAL((dist_r.min)(), 0.0); - BOOST_CHECK_EQUAL((dist_r.max)(), 5.0); + BOOST_TEST((dist_r.min)() == 0.0); + BOOST_TEST((dist_r.max)() == 5.0); } BOOST_AUTO_TEST_CASE(test_comparison) { - std::vector intervals = boost::assign::list_of(0)(1)(2)(3)(5); - std::vector weights = boost::assign::list_of(1)(2)(1)(4); + std::vector intervals{ 0, 1, 2, 3, 5 }; + std::vector weights{ 1, 2, 1, 4 }; boost::random::piecewise_constant_distribution<> dist; boost::random::piecewise_constant_distribution<> dist_copy(dist); boost::random::piecewise_constant_distribution<> dist_r(intervals, weights); @@ -213,34 +208,34 @@ BOOST_AUTO_TEST_CASE(test_comparison) { } BOOST_AUTO_TEST_CASE(test_streaming) { - std::vector intervals = boost::assign::list_of(0)(1)(2)(3)(5); - std::vector weights = boost::assign::list_of(1)(2)(1)(4); + std::vector intervals{ 0, 1, 2, 3, 5 }; + std::vector weights{ 1, 2, 1, 4 }; boost::random::piecewise_constant_distribution<> dist(intervals, weights); std::stringstream stream; stream << dist; boost::random::piecewise_constant_distribution<> restored_dist; stream >> restored_dist; - BOOST_CHECK_EQUAL(dist, restored_dist); + BOOST_TEST(dist == restored_dist); } BOOST_AUTO_TEST_CASE(test_generation) { - std::vector intervals = boost::assign::list_of(1)(2); - std::vector weights = boost::assign::list_of(1); + std::vector intervals{ 1, 2 }; + std::vector weights{ 1 }; boost::minstd_rand0 gen; boost::random::piecewise_constant_distribution<> dist; boost::random::piecewise_constant_distribution<> dist_r(intervals, weights); for(int i = 0; i < 10; ++i) { double value = dist(gen); - BOOST_CHECK_GE(value, 0.0); - BOOST_CHECK_LT(value, 1.0); + BOOST_TEST(value >= 0.0); + BOOST_TEST(value < 1.0); double value_r = dist_r(gen); - BOOST_CHECK_GE(value_r, 1.0); - BOOST_CHECK_LT(value_r, 2.0); + BOOST_TEST(value_r >= 1.0); + BOOST_TEST(value_r < 2.0); double value_param = dist_r(gen, dist.param()); - BOOST_CHECK_GE(value_param, 0.0); - BOOST_CHECK_LT(value_param, 1.0); + BOOST_TEST(value_param >= 0.0); + BOOST_TEST(value_param < 1.0); double value_r_param = dist(gen, dist_r.param()); - BOOST_CHECK_GE(value_r_param, 1.0); - BOOST_CHECK_LT(value_r_param, 2.0); + BOOST_TEST(value_r_param >= 1.0); + BOOST_TEST(value_r_param < 2.0); } } diff --git a/test/test_piecewise_linear_distribution.cpp b/test/test_piecewise_linear_distribution.cpp index 9426de283..924e1eeaa 100644 --- a/test/test_piecewise_linear_distribution.cpp +++ b/test/test_piecewise_linear_distribution.cpp @@ -11,7 +11,6 @@ #include #include -#include #include #include #include "concepts.hpp" @@ -35,111 +34,107 @@ struct gen { } }; -#define CHECK_SEQUENCE(actual, expected) \ - do { \ - std::vector _actual = (actual); \ - std::vector _expected = (expected); \ - BOOST_CHECK_EQUAL_COLLECTIONS( \ - _actual.begin(), _actual.end(), \ - _expected.begin(), _expected.end()); \ +#define CHECK_SEQUENCE(actual, expected) \ + do { \ + const std::vector& actual_ = (actual); \ + std::vector expected_ = make_vectorexpected; \ + BOOST_TEST(actual_ == expected_, boost::test_tools::per_element()); \ } while(false) -using boost::assign::list_of; - BOOST_AUTO_TEST_CASE(test_constructors) { boost::random::piecewise_linear_distribution<> dist; - CHECK_SEQUENCE(dist.intervals(), list_of(0.0)(1.0)); - CHECK_SEQUENCE(dist.densities(), list_of(1.0)(1.0)); + CHECK_SEQUENCE(dist.intervals(), (0.0, 1.0)); + CHECK_SEQUENCE(dist.densities(), (1.0, 1.0)); #ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST boost::random::piecewise_linear_distribution<> dist_il = { { 99, 103, 107, 111, 115 }, gen() }; - CHECK_SEQUENCE(dist_il.intervals(), list_of(99)(103)(107)(111)(115)); + CHECK_SEQUENCE(dist_il.intervals(), (99, 103, 107, 111, 115)); CHECK_SEQUENCE(dist_il.densities(), - list_of(.09375)(.03125)(0.0625)(.03125)(.15625)); + (.09375, .03125, 0.0625, .03125, .15625)); boost::random::piecewise_linear_distribution<> dist_il2 = { { 99 }, gen() }; - CHECK_SEQUENCE(dist_il2.intervals(), list_of(0.0)(1.0)); - CHECK_SEQUENCE(dist_il2.densities(), list_of(1.0)(1.0)); + CHECK_SEQUENCE(dist_il2.intervals(), (0.0, 1.0)); + CHECK_SEQUENCE(dist_il2.densities(), (1.0, 1.0)); #endif - std::vector intervals = boost::assign::list_of(0)(1)(2)(3)(5); - std::vector weights = boost::assign::list_of(3)(1)(2)(1)(2); - std::vector intervals2 = boost::assign::list_of(99); - std::vector weights2 = boost::assign::list_of(2); + std::vector intervals{ 0, 1, 2, 3, 5 }; + std::vector weights{ 3, 1, 2, 1, 2 }; + std::vector intervals2{ 99 }; + std::vector weights2{ 2 }; boost::random::piecewise_linear_distribution<> dist_r(intervals, weights); - CHECK_SEQUENCE(dist_r.intervals(), list_of(0)(1)(2)(3)(5)); - CHECK_SEQUENCE(dist_r.densities(), list_of(.375)(.125)(.25)(.125)(.25)); + CHECK_SEQUENCE(dist_r.intervals(), (0, 1, 2, 3, 5)); + CHECK_SEQUENCE(dist_r.densities(), (.375, .125, .25, .125, .25)); boost::random::piecewise_linear_distribution<> dist_r2(intervals2, weights2); - CHECK_SEQUENCE(dist_r2.intervals(), list_of(0.0)(1.0)); - CHECK_SEQUENCE(dist_r2.densities(), list_of(1.0)(1.0)); + CHECK_SEQUENCE(dist_r2.intervals(), (0.0, 1.0)); + CHECK_SEQUENCE(dist_r2.densities(), (1.0, 1.0)); boost::random::piecewise_linear_distribution<> dist_it( intervals.begin(), intervals.end(), weights.begin()); - CHECK_SEQUENCE(dist_it.intervals(), list_of(0)(1)(2)(3)(5)); - CHECK_SEQUENCE(dist_it.densities(), list_of(.375)(.125)(.25)(.125)(.25)); + CHECK_SEQUENCE(dist_it.intervals(), (0, 1, 2, 3, 5)); + CHECK_SEQUENCE(dist_it.densities(), (.375, .125, .25, .125, .25)); boost::random::piecewise_linear_distribution<> dist_it2( intervals2.begin(), intervals2.end(), weights2.begin()); - CHECK_SEQUENCE(dist_it2.intervals(), list_of(0.0)(1.0)); - CHECK_SEQUENCE(dist_it2.densities(), list_of(1.0)(1.0)); + CHECK_SEQUENCE(dist_it2.intervals(), (0.0, 1.0)); + CHECK_SEQUENCE(dist_it2.densities(), (1.0, 1.0)); - boost::random::piecewise_linear_distribution<> dist_fun(4, 99,115, gen()); - CHECK_SEQUENCE(dist_fun.intervals(), list_of(99)(103)(107)(111)(115)); + boost::random::piecewise_linear_distribution<> dist_fun(4, 99, 115, gen()); + CHECK_SEQUENCE(dist_fun.intervals(), (99, 103, 107, 111, 115)); CHECK_SEQUENCE(dist_fun.densities(), - list_of(.09375)(.03125)(0.0625)(.03125)(.15625)); + (.09375, .03125, 0.0625, .03125, .15625)); boost::random::piecewise_linear_distribution<> dist_fun2(1, 99, 115, gen()); - CHECK_SEQUENCE(dist_fun2.intervals(), list_of(99)(115)); - CHECK_SEQUENCE(dist_fun2.densities(), list_of(0.046875)(0.078125)); + CHECK_SEQUENCE(dist_fun2.intervals(), (99, 115)); + CHECK_SEQUENCE(dist_fun2.densities(), (0.046875, 0.078125)); boost::random::piecewise_linear_distribution<> copy(dist); - BOOST_CHECK_EQUAL(dist, copy); + BOOST_TEST(dist == copy); boost::random::piecewise_linear_distribution<> copy_r(dist_r); - BOOST_CHECK_EQUAL(dist_r, copy_r); + BOOST_TEST(dist_r == copy_r); boost::random::piecewise_linear_distribution<> notpow2(3, 99, 111, gen()); BOOST_REQUIRE_EQUAL(notpow2.densities().size(), 4u); - BOOST_CHECK_CLOSE_FRACTION(notpow2.densities()[0], 0.15, 1e-12); - BOOST_CHECK_CLOSE_FRACTION(notpow2.densities()[1], 0.05, 1e-12); - BOOST_CHECK_CLOSE_FRACTION(notpow2.densities()[2], 0.1, 1e-12); - BOOST_CHECK_CLOSE_FRACTION(notpow2.densities()[3], 0.05, 1e-12); + BOOST_TEST(notpow2.densities()[0] == 0.15, boost::test_tools::tolerance(1e-12)); + BOOST_TEST(notpow2.densities()[1] == 0.05, boost::test_tools::tolerance(1e-12)); + BOOST_TEST(notpow2.densities()[2] == 0.1, boost::test_tools::tolerance(1e-12)); + BOOST_TEST(notpow2.densities()[3] == 0.05, boost::test_tools::tolerance(1e-12)); boost::random::piecewise_linear_distribution<> copy_notpow2(notpow2); - BOOST_CHECK_EQUAL(notpow2, copy_notpow2); + BOOST_TEST(notpow2 == copy_notpow2); } BOOST_AUTO_TEST_CASE(test_param) { - std::vector intervals = boost::assign::list_of(0)(1)(2)(3)(5); - std::vector weights = boost::assign::list_of(3)(1)(2)(1)(2); - std::vector intervals2 = boost::assign::list_of(99); - std::vector weights2 = boost::assign::list_of(2); + std::vector intervals{ 0, 1, 2, 3, 5 }; + std::vector weights{ 3, 1, 2, 1, 2 }; + std::vector intervals2{ 99 }; + std::vector weights2{ 2 }; boost::random::piecewise_linear_distribution<> dist(intervals, weights); boost::random::piecewise_linear_distribution<>::param_type param = dist.param(); - CHECK_SEQUENCE(param.intervals(), list_of(0)(1)(2)(3)(5)); - CHECK_SEQUENCE(param.densities(), list_of(.375)(.125)(.25)(.125)(.25)); + CHECK_SEQUENCE(param.intervals(), (0, 1, 2, 3, 5)); + CHECK_SEQUENCE(param.densities(), (.375, .125, .25, .125, .25)); boost::random::piecewise_linear_distribution<> copy1(param); - BOOST_CHECK_EQUAL(dist, copy1); + BOOST_TEST(dist == copy1); boost::random::piecewise_linear_distribution<> copy2; copy2.param(param); - BOOST_CHECK_EQUAL(dist, copy2); + BOOST_TEST(dist == copy2); boost::random::piecewise_linear_distribution<>::param_type param_copy = param; - BOOST_CHECK_EQUAL(param, param_copy); + BOOST_TEST(param == param_copy); BOOST_CHECK(param == param_copy); BOOST_CHECK(!(param != param_copy)); boost::random::piecewise_linear_distribution<>::param_type param_default; - CHECK_SEQUENCE(param_default.intervals(), list_of(0.0)(1.0)); - CHECK_SEQUENCE(param_default.densities(), list_of(1.0)(1.0)); + CHECK_SEQUENCE(param_default.intervals(), (0.0, 1.0)); + CHECK_SEQUENCE(param_default.densities(), (1.0, 1.0)); BOOST_CHECK(param != param_default); BOOST_CHECK(!(param == param_default)); @@ -148,64 +143,64 @@ BOOST_AUTO_TEST_CASE(test_param) { { 99, 103, 107, 111, 115 }, gen() }; - CHECK_SEQUENCE(parm_il.intervals(), list_of(99)(103)(107)(111)(115)); + CHECK_SEQUENCE(parm_il.intervals(), (99, 103, 107, 111, 115)); CHECK_SEQUENCE(parm_il.densities(), - list_of(.09375)(.03125)(0.0625)(.03125)(.15625)); + (.09375, .03125, 0.0625, .03125, .15625)); boost::random::piecewise_linear_distribution<>::param_type parm_il2 = { { 99 }, gen() }; - CHECK_SEQUENCE(parm_il2.intervals(), list_of(0.0)(1.0)); - CHECK_SEQUENCE(parm_il2.densities(), list_of(1.0)(1.0)); + CHECK_SEQUENCE(parm_il2.intervals(), (0.0, 1.0)); + CHECK_SEQUENCE(parm_il2.densities(), (1.0, 1.0)); #endif boost::random::piecewise_linear_distribution<>::param_type parm_r(intervals, weights); - CHECK_SEQUENCE(parm_r.intervals(), list_of(0)(1)(2)(3)(5)); - CHECK_SEQUENCE(parm_r.densities(), list_of(.375)(.125)(.25)(.125)(.25)); + CHECK_SEQUENCE(parm_r.intervals(), (0, 1, 2, 3, 5)); + CHECK_SEQUENCE(parm_r.densities(), (.375, .125, .25, .125, .25)); boost::random::piecewise_linear_distribution<>::param_type parm_r2(intervals2, weights2); - CHECK_SEQUENCE(parm_r2.intervals(), list_of(0.0)(1.0)); - CHECK_SEQUENCE(parm_r2.densities(), list_of(1.0)(1.0)); + CHECK_SEQUENCE(parm_r2.intervals(), (0.0, 1.0)); + CHECK_SEQUENCE(parm_r2.densities(), (1.0, 1.0)); boost::random::piecewise_linear_distribution<>::param_type parm_it(intervals.begin(), intervals.end(), weights.begin()); - CHECK_SEQUENCE(parm_it.intervals(), list_of(0)(1)(2)(3)(5)); - CHECK_SEQUENCE(parm_it.densities(), list_of(.375)(.125)(.25)(.125)(.25)); + CHECK_SEQUENCE(parm_it.intervals(), (0, 1, 2, 3, 5)); + CHECK_SEQUENCE(parm_it.densities(), (.375, .125, .25, .125, .25)); boost::random::piecewise_linear_distribution<>::param_type parm_it2(intervals2.begin(), intervals2.end(), weights2.begin()); - CHECK_SEQUENCE(parm_it2.intervals(), list_of(0.0)(1.0)); - CHECK_SEQUENCE(parm_it2.densities(), list_of(1.0)(1.0)); + CHECK_SEQUENCE(parm_it2.intervals(), (0.0, 1.0)); + CHECK_SEQUENCE(parm_it2.densities(), (1.0, 1.0)); boost::random::piecewise_linear_distribution<>::param_type parm_fun(4, 99, 115, gen()); - CHECK_SEQUENCE(parm_fun.intervals(), list_of(99)(103)(107)(111)(115)); + CHECK_SEQUENCE(parm_fun.intervals(), (99, 103, 107, 111, 115)); CHECK_SEQUENCE(parm_fun.densities(), - list_of(.09375)(.03125)(0.0625)(.03125)(.15625)); + (.09375, .03125, 0.0625, .03125, .15625)); boost::random::piecewise_linear_distribution<>::param_type parm_fun2(1, 99, 115, gen()); - CHECK_SEQUENCE(parm_fun2.intervals(), list_of(99)(115)); - CHECK_SEQUENCE(parm_fun2.densities(), list_of(0.046875)(0.078125)); + CHECK_SEQUENCE(parm_fun2.intervals(), (99, 115)); + CHECK_SEQUENCE(parm_fun2.densities(), (0.046875, 0.078125)); } BOOST_AUTO_TEST_CASE(test_min_max) { - std::vector intervals = boost::assign::list_of(0)(1)(2)(3)(5); - std::vector weights = boost::assign::list_of(3)(1)(2)(1)(2); + std::vector intervals{ 0, 1, 2, 3, 5 }; + std::vector weights{ 3, 1, 2, 1, 2 }; boost::random::piecewise_linear_distribution<> dist; - BOOST_CHECK_EQUAL((dist.min)(), 0.0); - BOOST_CHECK_EQUAL((dist.max)(), 1.0); + BOOST_TEST((dist.min)() == 0.0); + BOOST_TEST((dist.max)() == 1.0); boost::random::piecewise_linear_distribution<> dist_r(intervals, weights); - BOOST_CHECK_EQUAL((dist_r.min)(), 0.0); - BOOST_CHECK_EQUAL((dist_r.max)(), 5.0); + BOOST_TEST((dist_r.min)() == 0.0); + BOOST_TEST((dist_r.max)() == 5.0); } BOOST_AUTO_TEST_CASE(test_comparison) { - std::vector intervals = boost::assign::list_of(0)(1)(2)(3)(5); - std::vector weights = boost::assign::list_of(3)(1)(2)(1)(2); + std::vector intervals{ 0, 1, 2, 3, 5 }; + std::vector weights{ 3, 1, 2, 1, 2 }; boost::random::piecewise_linear_distribution<> dist; boost::random::piecewise_linear_distribution<> dist_copy(dist); boost::random::piecewise_linear_distribution<> dist_r(intervals, weights); @@ -219,34 +214,34 @@ BOOST_AUTO_TEST_CASE(test_comparison) { } BOOST_AUTO_TEST_CASE(test_streaming) { - std::vector intervals = boost::assign::list_of(0)(1)(2)(3)(5); - std::vector weights = boost::assign::list_of(3)(1)(2)(1)(2); + std::vector intervals{ 0, 1, 2, 3, 5 }; + std::vector weights{ 3, 1, 2, 1, 2 }; boost::random::piecewise_linear_distribution<> dist(intervals, weights); std::stringstream stream; stream << dist; boost::random::piecewise_linear_distribution<> restored_dist; stream >> restored_dist; - BOOST_CHECK_EQUAL(dist, restored_dist); + BOOST_TEST(dist == restored_dist); } BOOST_AUTO_TEST_CASE(test_generation) { - std::vector intervals = boost::assign::list_of(1)(2); - std::vector weights = boost::assign::list_of(1)(1); + std::vector intervals{ 1, 2 }; + std::vector weights{ 1, 1 }; boost::minstd_rand0 gen; boost::random::piecewise_linear_distribution<> dist; boost::random::piecewise_linear_distribution<> dist_r(intervals, weights); for(int i = 0; i < 10; ++i) { double value = dist(gen); - BOOST_CHECK_GE(value, 0.0); - BOOST_CHECK_LT(value, 1.0); + BOOST_TEST(value >= 0.0); + BOOST_TEST(value < 1.0); double value_r = dist_r(gen); - BOOST_CHECK_GE(value_r, 1.0); - BOOST_CHECK_LT(value_r, 2.0); + BOOST_TEST(value_r >= 1.0); + BOOST_TEST(value_r < 2.0); double value_param = dist_r(gen, dist.param()); - BOOST_CHECK_GE(value_param, 0.0); - BOOST_CHECK_LT(value_param, 1.0); + BOOST_TEST(value_param >= 0.0); + BOOST_TEST(value_param < 1.0); double value_r_param = dist(gen, dist_r.param()); - BOOST_CHECK_GE(value_r_param, 1.0); - BOOST_CHECK_LT(value_r_param, 2.0); + BOOST_TEST(value_r_param >= 1.0); + BOOST_TEST(value_r_param < 2.0); } } diff --git a/test/test_random_device.cpp b/test/test_random_device.cpp index 068ea1c74..5e7e05e06 100644 --- a/test/test_random_device.cpp +++ b/test/test_random_device.cpp @@ -26,11 +26,11 @@ BOOST_AUTO_TEST_CASE(test_random_device) boost::random_device rng; double entropy = rng.entropy(); - BOOST_CHECK_GE(entropy, 0); + BOOST_TEST(entropy >= 0); for(int i = 0; i < 100; ++i) { boost::random_device::result_type val = rng(); - BOOST_CHECK_GE(val, (rng.min)()); - BOOST_CHECK_LE(val, (rng.max)()); + BOOST_TEST(val >= (rng.min)()); + BOOST_TEST(val <= (rng.max)()); } std::uint32_t a[10]; diff --git a/test/test_seed_seq.cpp b/test/test_seed_seq.cpp index 2e32c93f8..b600b3695 100644 --- a/test/test_seed_seq.cpp +++ b/test/test_seed_seq.cpp @@ -9,15 +9,12 @@ */ #include -#include #include #include #define BOOST_TEST_MAIN #include -using boost::assign::list_of; - BOOST_AUTO_TEST_CASE(test_seed_seq) { std::uint32_t expected_param[4] = { 2, 3, 4, 0xdeadbeaf }; std::uint32_t param[4] = { 2, 3, 4, 0xdeadbeaf }; @@ -44,7 +41,7 @@ BOOST_AUTO_TEST_CASE(test_seed_seq) { seq.generate(&store64[0], &store64[0] + 10); BOOST_CHECK_EQUAL_COLLECTIONS( &store64[0], &store64[0] + 10, &expected[0], &expected[0] + 10); - BOOST_CHECK_EQUAL(seq.size(), 0u); + BOOST_TEST(seq.size() == 0u); seq.param(¶m[0]); BOOST_CHECK_EQUAL_COLLECTIONS( ¶m[0], ¶m[0] + 4, &expected_param[0], &expected_param[0] + 4); @@ -62,7 +59,7 @@ BOOST_AUTO_TEST_CASE(test_seed_seq) { 494552679u }; - std::vector data = list_of(2)(3)(4); + std::vector data{ 2, 3, 4 }; std::fill_n(&store32[0], 10, 0); std::fill_n(&store64[0], 10, 0); @@ -74,7 +71,7 @@ BOOST_AUTO_TEST_CASE(test_seed_seq) { seq_r.generate(&store64[0], &store64[0] + 10); BOOST_CHECK_EQUAL_COLLECTIONS( &store64[0], &store64[0] + 10, &expected_r[0], &expected_r[0] + 10); - BOOST_CHECK_EQUAL(seq_r.size(), 3u); + BOOST_TEST(seq_r.size() == 3u); seq_r.param(¶m[0]); BOOST_CHECK_EQUAL_COLLECTIONS( ¶m[0], ¶m[0] + 4, &expected_param[0], &expected_param[0] + 4); @@ -89,7 +86,7 @@ BOOST_AUTO_TEST_CASE(test_seed_seq) { seq_it.generate(&store64[0], &store64[0] + 10); BOOST_CHECK_EQUAL_COLLECTIONS( &store64[0], &store64[0] + 10, &expected_r[0], &expected_r[0] + 10); - BOOST_CHECK_EQUAL(seq_it.size(), 3u); + BOOST_TEST(seq_it.size() == 3u); seq_it.param(¶m[0]); BOOST_CHECK_EQUAL_COLLECTIONS( ¶m[0], ¶m[0] + 4, &expected_param[0], &expected_param[0] + 4); @@ -105,7 +102,7 @@ BOOST_AUTO_TEST_CASE(test_seed_seq) { seq_il.generate(&store64[0], &store64[0] + 10); BOOST_CHECK_EQUAL_COLLECTIONS( &store64[0], &store64[0] + 10, &expected_r[0], &expected_r[0] + 10); - BOOST_CHECK_EQUAL(seq_il.size(), 3u); + BOOST_TEST(seq_il.size() == 3u); seq_il.param(¶m[0]); BOOST_CHECK_EQUAL_COLLECTIONS( ¶m[0], ¶m[0] + 4, &expected_param[0], &expected_param[0] + 4); @@ -120,7 +117,7 @@ BOOST_AUTO_TEST_CASE(test_seed_seq_short_output) { 3175758659u }; - std::vector data = list_of(2)(3)(4)(5); + std::vector data{ 2, 3, 4, 5 }; boost::random::seed_seq seq(data); diff --git a/test/test_uniform_int.ipp b/test/test_uniform_int.ipp index baa43273e..8db6c43ee 100644 --- a/test/test_uniform_int.ipp +++ b/test/test_uniform_int.ipp @@ -31,15 +31,15 @@ void check_uniform_int(Generator & gen, int iter) std::vector bucket(range); for(int j = 0; j < iter; j++) { int result = gen(); - BOOST_CHECK_GE(result, (gen.min)()); - BOOST_CHECK_LE(result, (gen.max)()); + BOOST_TEST(result >= (gen.min)()); + BOOST_TEST(result <= (gen.max)()); if(result >= (gen.min)() && result <= (gen.max)()) { bucket[result-(gen.min)()]++; } } int sum = std::accumulate(bucket.begin(), bucket.end(), 0); std::vector expected(range, 1.0 / range); - BOOST_CHECK_LT(chi_squared_test(bucket, expected, sum), 0.99); + BOOST_TEST(chi_squared_test(bucket, expected, sum) < 0.99); } BOOST_AUTO_TEST_CASE(test_uniform_int) diff --git a/test/test_uniform_on_sphere_distribution.cpp b/test/test_uniform_on_sphere_distribution.cpp index a45c47e8b..397cf48b9 100644 --- a/test/test_uniform_on_sphere_distribution.cpp +++ b/test/test_uniform_on_sphere_distribution.cpp @@ -10,17 +10,16 @@ */ #include -#include #define BOOST_RANDOM_DISTRIBUTION boost::random::uniform_on_sphere<> #define BOOST_RANDOM_ARG1 dim #define BOOST_RANDOM_ARG1_DEFAULT 2 #define BOOST_RANDOM_ARG1_VALUE 3 -std::vector min0 = boost::assign::list_of(-1.0)(0.0); -std::vector max0 = boost::assign::list_of(1.0)(0.0); -std::vector min1 = boost::assign::list_of(-1.0)(0.0)(0.0); -std::vector max1 = boost::assign::list_of(1.0)(0.0)(0.0); +std::vector min0{ -1.0, 0.0 }; +std::vector max0{ 1.0, 0.0 }; +std::vector min1{ -1.0, 0.0, 0.0 }; +std::vector max1{ 1.0, 0.0, 0.0 }; #define BOOST_RANDOM_DIST0_MIN min0 #define BOOST_RANDOM_DIST0_MAX max0 @@ -79,7 +78,7 @@ BOOST_AUTO_TEST_CASE(test_valid_output) { for(std::size_t j = 0; j < result.size(); ++j) { sum_sq += result[j] * result[j]; } - BOOST_CHECK_CLOSE_FRACTION(sum_sq, 1.0, 1e-5); + BOOST_TEST(sum_sq == 1.0, boost::test_tools::tolerance(1e-5)); } } } diff --git a/test/test_uniform_real_distribution.cpp b/test/test_uniform_real_distribution.cpp index ed47e59e7..ffb80f6e8 100644 --- a/test/test_uniform_real_distribution.cpp +++ b/test/test_uniform_real_distribution.cpp @@ -43,6 +43,6 @@ BOOST_AUTO_TEST_CASE(test_dbl_min_max) { double max = (std::numeric_limits::max)(); boost::random::uniform_real_distribution dist(min, max); double val = dist(rng); - BOOST_CHECK_GE(val, min); - BOOST_CHECK_LE(val, max); + BOOST_TEST(val >= min); + BOOST_TEST(val <= max); }