From ac88d68a1002ba9bdec0a28df8cd921abfd626ff Mon Sep 17 00:00:00 2001 From: Steven Watanabe Date: Sun, 29 Aug 2010 04:03:02 +0000 Subject: [PATCH] Refactor tests [SVN r65093] --- include/boost/random/gamma_distribution.hpp | 2 +- test/test_binomial_distribution.cpp | 136 +++------------ test/test_distribution.ipp | 177 ++++++++++++++++++++ test/test_extreme_value_distribution.cpp | 130 +++----------- test/test_gamma_distribution.cpp | 135 +++------------ test/test_poisson_distribution.cpp | 101 ++--------- test/test_weibull_distribution.cpp | 136 +++------------ 7 files changed, 272 insertions(+), 545 deletions(-) create mode 100644 test/test_distribution.ipp diff --git a/include/boost/random/gamma_distribution.hpp b/include/boost/random/gamma_distribution.hpp index 5680c12..a546a34 100644 --- a/include/boost/random/gamma_distribution.hpp +++ b/include/boost/random/gamma_distribution.hpp @@ -134,7 +134,7 @@ public: RealType min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return 0; } /* Returns the largest value that the distribution can produce. */ RealType max BOOST_PREVENT_MACRO_SUBSTITUTION () const - { return (std::numeric_limits::max)(); } + { return (std::numeric_limits::infinity)(); } /** Returns the parameters of the distribution. */ param_type param() const { return param_type(_alpha, _beta); } diff --git a/test/test_binomial_distribution.cpp b/test/test_binomial_distribution.cpp index 7c9a2e5..47e80d6 100644 --- a/test/test_binomial_distribution.cpp +++ b/test/test_binomial_distribution.cpp @@ -10,124 +10,28 @@ */ #include -#include -#include -#define BOOST_TEST_MAIN -#include +#define BOOST_RANDOM_DISTRIBUTION boost::random::binomial_distribution<> +#define BOOST_RANDOM_ARG1 t +#define BOOST_RANDOM_ARG2 p +#define BOOST_RANDOM_ARG1_DEFAULT 1 +#define BOOST_RANDOM_ARG2_DEFAULT 0.5 +#define BOOST_RANDOM_ARG1_VALUE 10 +#define BOOST_RANDOM_ARG2_VALUE 0.25 -BOOST_AUTO_TEST_CASE(test_constructors) { - boost::random::binomial_distribution<> dist; - BOOST_CHECK_EQUAL(dist.t(), 1); - BOOST_CHECK_EQUAL(dist.p(), 0.5); - boost::random::binomial_distribution<> dist_one(10); - BOOST_CHECK_EQUAL(dist_one.t(), 10); - BOOST_CHECK_EQUAL(dist_one.p(), 0.5); - boost::random::binomial_distribution<> dist_two(10, 0.25); - BOOST_CHECK_EQUAL(dist_two.t(), 10); - BOOST_CHECK_EQUAL(dist_two.p(), 0.25); - boost::random::binomial_distribution<> copy(dist); - BOOST_CHECK_EQUAL(dist, copy); - boost::random::binomial_distribution<> copy_one(dist_one); - BOOST_CHECK_EQUAL(dist_one, copy_one); - boost::random::binomial_distribution<> copy_two(dist_two); - BOOST_CHECK_EQUAL(dist_two, copy_two); -} +#define BOOST_RANDOM_DIST0_MIN 0 +#define BOOST_RANDOM_DIST0_MAX 1 +#define BOOST_RANDOM_DIST1_MIN 0 +#define BOOST_RANDOM_DIST1_MAX 10 +#define BOOST_RANDOM_DIST2_MIN 0 +#define BOOST_RANDOM_DIST2_MAX 10 -BOOST_AUTO_TEST_CASE(test_copy_constructor) { - boost::random::binomial_distribution<> dist(10, 0.25); -} +#define BOOST_RANDOM_TEST1_PARAMS +#define BOOST_RANDOM_TEST1_MIN 0 +#define BOOST_RANDOM_TEST1_MAX 1 -BOOST_AUTO_TEST_CASE(test_param) { - boost::random::binomial_distribution<> dist(10, 0.25); - boost::random::binomial_distribution<>::param_type param = dist.param(); - BOOST_CHECK_EQUAL(param.t(), 10); - BOOST_CHECK_EQUAL(param.p(), 0.25); - boost::random::binomial_distribution<> copy1(param); - BOOST_CHECK_EQUAL(dist, copy1); - boost::random::binomial_distribution<> copy2; - copy2.param(param); - BOOST_CHECK_EQUAL(dist, copy2); +#define BOOST_RANDOM_TEST2_PARAMS (10, 0.25) +#define BOOST_RANDOM_TEST2_MIN 0 +#define BOOST_RANDOM_TEST2_MAX 10 - boost::random::binomial_distribution<>::param_type param_copy = param; - BOOST_CHECK_EQUAL(param, param_copy); - BOOST_CHECK(param == param_copy); - BOOST_CHECK(!(param != param_copy)); - boost::random::binomial_distribution<>::param_type param_default; - BOOST_CHECK_EQUAL(param_default.t(), 1); - BOOST_CHECK_EQUAL(param_default.p(), 0.5); - BOOST_CHECK(param != param_default); - BOOST_CHECK(!(param == param_default)); - boost::random::binomial_distribution<>::param_type param_one(10); - BOOST_CHECK_EQUAL(param_one.t(), 10); - BOOST_CHECK_EQUAL(param_one.p(), 0.5); - BOOST_CHECK(param != param_one); - BOOST_CHECK(!(param == param_one)); - BOOST_CHECK(param_default != param_one); - BOOST_CHECK(!(param_default == param_one)); - boost::random::binomial_distribution<>::param_type param_two(10, 0.25); - BOOST_CHECK_EQUAL(param_two.t(), 10); - BOOST_CHECK_EQUAL(param_two.p(), 0.25); -} - -BOOST_AUTO_TEST_CASE(test_min_max) { - boost::random::binomial_distribution<> dist; - BOOST_CHECK_EQUAL((dist.min)(), 0); - BOOST_CHECK_EQUAL((dist.max)(), 1); - boost::random::binomial_distribution<> dist_one(10); - BOOST_CHECK_EQUAL((dist_one.min)(), 0); - BOOST_CHECK_EQUAL((dist_one.max)(), 10); - boost::random::binomial_distribution<> dist_two(10, 0.25); - BOOST_CHECK_EQUAL((dist_two.min)(), 0); - BOOST_CHECK_EQUAL((dist_two.max)(), 10); -} - -BOOST_AUTO_TEST_CASE(test_comparison) { - boost::random::binomial_distribution<> dist; - boost::random::binomial_distribution<> dist_copy(dist); - boost::random::binomial_distribution<> dist_one(10); - boost::random::binomial_distribution<> dist_one_copy(dist_one); - boost::random::binomial_distribution<> dist_two(10, 0.25); - boost::random::binomial_distribution<> dist_two_copy(dist_two); - BOOST_CHECK(dist == dist_copy); - BOOST_CHECK(!(dist != dist_copy)); - BOOST_CHECK(dist_one == dist_one_copy); - BOOST_CHECK(!(dist_one != dist_one_copy)); - BOOST_CHECK(dist_two == dist_two_copy); - BOOST_CHECK(!(dist_two != dist_two_copy)); - BOOST_CHECK(dist != dist_one); - BOOST_CHECK(!(dist == dist_one)); - BOOST_CHECK(dist != dist_two); - BOOST_CHECK(!(dist == dist_two)); - BOOST_CHECK(dist_one != dist_two); - BOOST_CHECK(!(dist_one == dist_two)); -} - -BOOST_AUTO_TEST_CASE(test_streaming) { - boost::random::binomial_distribution<> dist(10, 0.25); - std::stringstream stream; - stream << dist; - boost::random::binomial_distribution<> restored_dist; - stream >> restored_dist; - BOOST_CHECK_EQUAL(dist, restored_dist); -} - -BOOST_AUTO_TEST_CASE(test_generation) { - boost::minstd_rand0 gen; - boost::random::binomial_distribution<> dist; - boost::random::binomial_distribution<> dist_two(10, 0.25); - for(int i = 0; i < 10; ++i) { - int value = dist(gen); - BOOST_CHECK_GE(value, (dist.min)()); - BOOST_CHECK_LE(value, (dist.max)()); - int value_two = dist_two(gen); - BOOST_CHECK_GE(value_two, (dist_two.min)()); - BOOST_CHECK_LE(value_two, (dist_two.max)()); - int value_param = dist_two(gen, dist.param()); - BOOST_CHECK_GE(value_param, (dist.min)()); - BOOST_CHECK_LE(value_param, (dist.max)()); - int value_two_param = dist(gen, dist_two.param()); - BOOST_CHECK_GE(value_two_param, (dist_two.min)()); - BOOST_CHECK_LE(value_two_param, (dist_two.max)()); - } -} +#include "test_distribution.ipp" diff --git a/test/test_distribution.ipp b/test/test_distribution.ipp new file mode 100644 index 0000000..6a28225 --- /dev/null +++ b/test/test_distribution.ipp @@ -0,0 +1,177 @@ +/* test_distribution.ipp + * + * Copyright Steven Watanabe 2010 + * 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$ + * + */ + +#include +#include + +#define BOOST_TEST_MAIN +#include + +BOOST_AUTO_TEST_CASE(test_constructors) { + BOOST_RANDOM_DISTRIBUTION dist; + BOOST_CHECK_EQUAL(dist.BOOST_RANDOM_ARG1(), BOOST_RANDOM_ARG1_DEFAULT); +#ifdef BOOST_RANDOM_ARG2 + BOOST_CHECK_EQUAL(dist.BOOST_RANDOM_ARG2(), BOOST_RANDOM_ARG2_DEFAULT); +#endif + BOOST_RANDOM_DISTRIBUTION dist_one(BOOST_RANDOM_ARG1_VALUE); + BOOST_CHECK_EQUAL(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); +#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); +#endif + BOOST_RANDOM_DISTRIBUTION copy(dist); + BOOST_CHECK_EQUAL(dist, copy); + BOOST_RANDOM_DISTRIBUTION copy_one(dist_one); + BOOST_CHECK_EQUAL(dist_one, copy_one); +#ifdef BOOST_RANDOM_ARG2 + BOOST_RANDOM_DISTRIBUTION copy_two(dist_two); + BOOST_CHECK_EQUAL(dist_two, copy_two); +#endif +} + +BOOST_AUTO_TEST_CASE(test_param) { +#ifdef BOOST_RANDOM_ARG2 + BOOST_RANDOM_DISTRIBUTION dist(BOOST_RANDOM_ARG1_VALUE, BOOST_RANDOM_ARG2_VALUE); +#else + 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); +#ifdef BOOST_RANDOM_ARG2 + BOOST_CHECK_EQUAL(param.BOOST_RANDOM_ARG2(), BOOST_RANDOM_ARG2_VALUE); +#endif + BOOST_RANDOM_DISTRIBUTION copy1(param); + BOOST_CHECK_EQUAL(dist, copy1); + BOOST_RANDOM_DISTRIBUTION copy2; + copy2.param(param); + BOOST_CHECK_EQUAL(dist, copy2); + + BOOST_RANDOM_DISTRIBUTION::param_type param_copy = param; + BOOST_CHECK_EQUAL(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); +#ifdef BOOST_RANDOM_ARG2 + BOOST_CHECK_EQUAL(param_default.BOOST_RANDOM_ARG2(), BOOST_RANDOM_ARG2_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); +#ifdef BOOST_RANDOM_ARG2 + BOOST_CHECK_EQUAL(param_one.BOOST_RANDOM_ARG2(), BOOST_RANDOM_ARG2_DEFAULT); +#endif +#ifdef BOOST_RANDOM_ARG2 + BOOST_CHECK(param != param_one); + BOOST_CHECK(!(param == param_one)); +#endif + BOOST_CHECK(param_default != param_one); + 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); +#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_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); +#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); +#endif +} + +BOOST_AUTO_TEST_CASE(test_comparison) { + BOOST_RANDOM_DISTRIBUTION dist; + BOOST_RANDOM_DISTRIBUTION dist_copy(dist); + BOOST_RANDOM_DISTRIBUTION dist_one(BOOST_RANDOM_ARG1_VALUE); + BOOST_RANDOM_DISTRIBUTION dist_one_copy(dist_one); +#ifdef BOOST_RANDOM_ARG2 + BOOST_RANDOM_DISTRIBUTION dist_two(BOOST_RANDOM_ARG1_VALUE, BOOST_RANDOM_ARG2_VALUE); + BOOST_RANDOM_DISTRIBUTION dist_two_copy(dist_two); +#endif + BOOST_CHECK(dist == dist_copy); + BOOST_CHECK(!(dist != dist_copy)); + BOOST_CHECK(dist_one == dist_one_copy); + BOOST_CHECK(!(dist_one != dist_one_copy)); + BOOST_CHECK(dist != dist_one); + BOOST_CHECK(!(dist == dist_one)); +#ifdef BOOST_RANDOM_ARG2 + BOOST_CHECK(dist_two == dist_two_copy); + BOOST_CHECK(!(dist_two != dist_two_copy)); + BOOST_CHECK(dist != dist_two); + BOOST_CHECK(!(dist == dist_two)); + BOOST_CHECK(dist_one != dist_two); + BOOST_CHECK(!(dist_one == dist_two)); +#endif +} + +BOOST_AUTO_TEST_CASE(test_streaming) { +#ifdef BOOST_RANDOM_ARG2 + BOOST_RANDOM_DISTRIBUTION dist(BOOST_RANDOM_ARG1_VALUE, BOOST_RANDOM_ARG2_VALUE); +#else + BOOST_RANDOM_DISTRIBUTION dist(BOOST_RANDOM_ARG1_VALUE); +#endif + std::stringstream stream; + stream << dist; + BOOST_RANDOM_DISTRIBUTION restored_dist; + stream >> restored_dist; + BOOST_CHECK_EQUAL(dist, restored_dist); +} + +BOOST_AUTO_TEST_CASE(test_generation) { + boost::minstd_rand0 gen; + BOOST_RANDOM_DISTRIBUTION dist BOOST_RANDOM_TEST1_PARAMS; + BOOST_RANDOM_DISTRIBUTION dist_two BOOST_RANDOM_TEST2_PARAMS; + typedef BOOST_RANDOM_DISTRIBUTION::result_type result_type; + for(int i = 0; i < 10; ++i) { + result_type value = dist(gen); +#ifdef BOOST_RANDOM_TEST1_MIN + BOOST_CHECK_GE(value, BOOST_RANDOM_TEST1_MIN); +#endif +#ifdef BOOST_RANDOM_TEST1_MAX + BOOST_CHECK_LE(value, BOOST_RANDOM_TEST1_MAX); +#endif + result_type value_two = dist_two(gen); +#ifdef BOOST_RANDOM_TEST2_MIN + BOOST_CHECK_GE(value_two, BOOST_RANDOM_TEST2_MIN); +#endif +#ifdef BOOST_RANDOM_TEST2_MAX + BOOST_CHECK_LE(value_two, BOOST_RANDOM_TEST2_MAX); +#endif + result_type value_param = dist_two(gen, dist.param()); +#ifdef BOOST_RANDOM_TEST1_MIN + BOOST_CHECK_GE(value_param, BOOST_RANDOM_TEST1_MIN); +#endif +#ifdef BOOST_RANDOM_TEST1_MAX + BOOST_CHECK_LE(value_param, BOOST_RANDOM_TEST1_MAX); +#endif + result_type value_two_param = dist(gen, dist_two.param()); +#ifdef BOOST_RANDOM_TEST2_MIN + BOOST_CHECK_GE(value_two_param, BOOST_RANDOM_TEST2_MIN); +#endif +#ifdef BOOST_RANDOM_TEST2_MAX + BOOST_CHECK_LE(value_two_param, BOOST_RANDOM_TEST2_MAX); +#endif + } +} diff --git a/test/test_extreme_value_distribution.cpp b/test/test_extreme_value_distribution.cpp index 30ad866..fc9642c 100644 --- a/test/test_extreme_value_distribution.cpp +++ b/test/test_extreme_value_distribution.cpp @@ -10,119 +10,27 @@ */ #include -#include -#include +#include -#define BOOST_TEST_MAIN -#include +#define BOOST_RANDOM_DISTRIBUTION boost::random::extreme_value_distribution<> +#define BOOST_RANDOM_ARG1 a +#define BOOST_RANDOM_ARG2 b +#define BOOST_RANDOM_ARG1_DEFAULT 1.0 +#define BOOST_RANDOM_ARG2_DEFAULT 1.0 +#define BOOST_RANDOM_ARG1_VALUE 7.5 +#define BOOST_RANDOM_ARG2_VALUE 0.25 -BOOST_AUTO_TEST_CASE(test_constructors) { - boost::random::extreme_value_distribution<> dist; - BOOST_CHECK_EQUAL(dist.a(), 1.0); - BOOST_CHECK_EQUAL(dist.b(), 1.0); - boost::random::extreme_value_distribution<> dist_one(7.5); - BOOST_CHECK_EQUAL(dist_one.a(), 7.5); - BOOST_CHECK_EQUAL(dist_one.b(), 1.0); - boost::random::extreme_value_distribution<> dist_two(7.5, 0.25); - BOOST_CHECK_EQUAL(dist_two.a(), 7.5); - BOOST_CHECK_EQUAL(dist_two.b(), 0.25); - boost::random::extreme_value_distribution<> copy(dist); - BOOST_CHECK_EQUAL(dist, copy); - boost::random::extreme_value_distribution<> copy_one(dist_one); - BOOST_CHECK_EQUAL(dist_one, copy_one); - boost::random::extreme_value_distribution<> copy_two(dist_two); - BOOST_CHECK_EQUAL(dist_two, copy_two); -} +#define BOOST_RANDOM_DIST0_MIN -(std::numeric_limits::infinity)() +#define BOOST_RANDOM_DIST0_MAX (std::numeric_limits::infinity)() +#define BOOST_RANDOM_DIST1_MIN -(std::numeric_limits::infinity)() +#define BOOST_RANDOM_DIST1_MAX (std::numeric_limits::infinity)() +#define BOOST_RANDOM_DIST2_MIN -(std::numeric_limits::infinity)() +#define BOOST_RANDOM_DIST2_MAX (std::numeric_limits::infinity)() -BOOST_AUTO_TEST_CASE(test_param) { - boost::random::extreme_value_distribution<> dist(7.5, 0.25); - boost::random::extreme_value_distribution<>::param_type param = dist.param(); - BOOST_CHECK_EQUAL(param.a(), 7.5); - BOOST_CHECK_EQUAL(param.b(), 0.25); - boost::random::extreme_value_distribution<> copy1(param); - BOOST_CHECK_EQUAL(dist, copy1); - boost::random::extreme_value_distribution<> copy2; - copy2.param(param); - BOOST_CHECK_EQUAL(dist, copy2); +#define BOOST_RANDOM_TEST1_PARAMS (-100.0) +#define BOOST_RANDOM_TEST1_MAX 0 - boost::random::extreme_value_distribution<>::param_type param_copy = param; - BOOST_CHECK_EQUAL(param, param_copy); - BOOST_CHECK(param == param_copy); - BOOST_CHECK(!(param != param_copy)); - boost::random::extreme_value_distribution<>::param_type param_default; - BOOST_CHECK_EQUAL(param_default.a(), 1.0); - BOOST_CHECK_EQUAL(param_default.b(), 1.0); - BOOST_CHECK(param != param_default); - BOOST_CHECK(!(param == param_default)); - boost::random::extreme_value_distribution<>::param_type param_one(7.5); - BOOST_CHECK_EQUAL(param_one.a(), 7.5); - BOOST_CHECK_EQUAL(param_one.b(), 1.0); - BOOST_CHECK(param != param_one); - BOOST_CHECK(!(param == param_one)); - BOOST_CHECK(param_default != param_one); - BOOST_CHECK(!(param_default == param_one)); - boost::random::extreme_value_distribution<>::param_type param_two(7.5, 0.25); - BOOST_CHECK_EQUAL(param_two.a(), 7.5); - BOOST_CHECK_EQUAL(param_two.b(), 0.25); -} +#define BOOST_RANDOM_TEST2_PARAMS (100.0) +#define BOOST_RANDOM_TEST2_MIN 0 -BOOST_AUTO_TEST_CASE(test_min_max) { - boost::random::extreme_value_distribution<> dist; - BOOST_CHECK_EQUAL((dist.min)(), -(std::numeric_limits::infinity)()); - BOOST_CHECK_EQUAL((dist.max)(), (std::numeric_limits::infinity)()); - boost::random::extreme_value_distribution<> dist_one(7.5); - BOOST_CHECK_EQUAL((dist_one.min)(), -(std::numeric_limits::infinity)()); - BOOST_CHECK_EQUAL((dist_one.max)(), (std::numeric_limits::infinity)()); - boost::random::extreme_value_distribution<> dist_two(7.5, 0.25); - BOOST_CHECK_EQUAL((dist_two.min)(), -(std::numeric_limits::infinity)()); - BOOST_CHECK_EQUAL((dist_two.max)(), (std::numeric_limits::infinity)()); -} - -BOOST_AUTO_TEST_CASE(test_comparison) { - boost::random::extreme_value_distribution<> dist; - boost::random::extreme_value_distribution<> dist_copy(dist); - boost::random::extreme_value_distribution<> dist_one(7.5); - boost::random::extreme_value_distribution<> dist_one_copy(dist_one); - boost::random::extreme_value_distribution<> dist_two(7.5, 0.25); - boost::random::extreme_value_distribution<> dist_two_copy(dist_two); - BOOST_CHECK(dist == dist_copy); - BOOST_CHECK(!(dist != dist_copy)); - BOOST_CHECK(dist_one == dist_one_copy); - BOOST_CHECK(!(dist_one != dist_one_copy)); - BOOST_CHECK(dist_two == dist_two_copy); - BOOST_CHECK(!(dist_two != dist_two_copy)); - BOOST_CHECK(dist != dist_one); - BOOST_CHECK(!(dist == dist_one)); - BOOST_CHECK(dist != dist_two); - BOOST_CHECK(!(dist == dist_two)); - BOOST_CHECK(dist_one != dist_two); - BOOST_CHECK(!(dist_one == dist_two)); -} - -BOOST_AUTO_TEST_CASE(test_streaming) { - boost::random::extreme_value_distribution<> dist(7.5, 0.25); - std::stringstream stream; - stream << dist; - boost::random::extreme_value_distribution<> restored_dist; - stream >> restored_dist; - BOOST_CHECK_EQUAL(dist, restored_dist); -} - -BOOST_AUTO_TEST_CASE(test_generation) { - boost::minstd_rand0 gen; - boost::random::extreme_value_distribution<> dist(-100.0); - boost::random::extreme_value_distribution<> dist_two(100.0); - for(int i = 0; i < 10; ++i) { - // This test is not guaranteed to work, since - // a extreme value distribution with a large location - // parameter can produce small values and vice versa - double value = dist(gen); - BOOST_CHECK_LE(value, 0.0); - double value_two = dist_two(gen); - BOOST_CHECK_GE(value_two, 0.0); - double value_param = dist_two(gen, dist.param()); - BOOST_CHECK_LE(value_param, 0.0); - double value_two_param = dist(gen, dist_two.param()); - BOOST_CHECK_GE(value_two_param, 0.0); - } -} +#include "test_distribution.ipp" diff --git a/test/test_gamma_distribution.cpp b/test/test_gamma_distribution.cpp index a4b82c5..2e9696f 100644 --- a/test/test_gamma_distribution.cpp +++ b/test/test_gamma_distribution.cpp @@ -10,123 +10,28 @@ */ #include -#include -#include +#include -#define BOOST_TEST_MAIN -#include +#define BOOST_RANDOM_DISTRIBUTION boost::random::gamma_distribution<> +#define BOOST_RANDOM_ARG1 alpha +#define BOOST_RANDOM_ARG2 beta +#define BOOST_RANDOM_ARG1_DEFAULT 1.0 +#define BOOST_RANDOM_ARG2_DEFAULT 1.0 +#define BOOST_RANDOM_ARG1_VALUE 7.5 +#define BOOST_RANDOM_ARG2_VALUE 0.25 -BOOST_AUTO_TEST_CASE(test_constructors) { - boost::random::gamma_distribution<> dist; - BOOST_CHECK_EQUAL(dist.alpha(), 1.0); - BOOST_CHECK_EQUAL(dist.beta(), 1.0); - boost::random::gamma_distribution<> dist_one(7.5); - BOOST_CHECK_EQUAL(dist_one.alpha(), 7.5); - BOOST_CHECK_EQUAL(dist_one.beta(), 1.0); - boost::random::gamma_distribution<> dist_two(7.5, 0.25); - BOOST_CHECK_EQUAL(dist_two.alpha(), 7.5); - BOOST_CHECK_EQUAL(dist_two.beta(), 0.25); - boost::random::gamma_distribution<> copy(dist); - BOOST_CHECK_EQUAL(dist, copy); - boost::random::gamma_distribution<> copy_one(dist_one); - BOOST_CHECK_EQUAL(dist_one, copy_one); - boost::random::gamma_distribution<> copy_two(dist_two); - BOOST_CHECK_EQUAL(dist_two, copy_two); -} +#define BOOST_RANDOM_DIST0_MIN 0 +#define BOOST_RANDOM_DIST0_MAX (std::numeric_limits::infinity)() +#define BOOST_RANDOM_DIST1_MIN 0 +#define BOOST_RANDOM_DIST1_MAX (std::numeric_limits::infinity)() +#define BOOST_RANDOM_DIST2_MIN 0 +#define BOOST_RANDOM_DIST2_MAX (std::numeric_limits::infinity)() -BOOST_AUTO_TEST_CASE(test_param) { - boost::random::gamma_distribution<> dist(7.5, 0.25); - boost::random::gamma_distribution<>::param_type param = dist.param(); - BOOST_CHECK_EQUAL(param.alpha(), 7.5); - BOOST_CHECK_EQUAL(param.beta(), 0.25); - boost::random::gamma_distribution<> copy1(param); - BOOST_CHECK_EQUAL(dist, copy1); - boost::random::gamma_distribution<> copy2; - copy2.param(param); - BOOST_CHECK_EQUAL(dist, copy2); +#define BOOST_RANDOM_TEST1_PARAMS +#define BOOST_RANDOM_TEST1_MIN 0.0 +#define BOOST_RANDOM_TEST1_MAX 100.0 - boost::random::gamma_distribution<>::param_type param_copy = param; - BOOST_CHECK_EQUAL(param, param_copy); - BOOST_CHECK(param == param_copy); - BOOST_CHECK(!(param != param_copy)); - boost::random::gamma_distribution<>::param_type param_default; - BOOST_CHECK_EQUAL(param_default.alpha(), 1.0); - BOOST_CHECK_EQUAL(param_default.beta(), 1.0); - BOOST_CHECK(param != param_default); - BOOST_CHECK(!(param == param_default)); - boost::random::gamma_distribution<>::param_type param_one(7.5); - BOOST_CHECK_EQUAL(param_one.alpha(), 7.5); - BOOST_CHECK_EQUAL(param_one.beta(), 1.0); - BOOST_CHECK(param != param_one); - BOOST_CHECK(!(param == param_one)); - BOOST_CHECK(param_default != param_one); - BOOST_CHECK(!(param_default == param_one)); - boost::random::gamma_distribution<>::param_type param_two(7.5, 0.25); - BOOST_CHECK_EQUAL(param_two.alpha(), 7.5); - BOOST_CHECK_EQUAL(param_two.beta(), 0.25); -} +#define BOOST_RANDOM_TEST2_PARAMS (1.0, 1000000.0) +#define BOOST_RANDOM_TEST2_MIN 100.0 -BOOST_AUTO_TEST_CASE(test_min_max) { - boost::random::gamma_distribution<> dist; - BOOST_CHECK_EQUAL((dist.min)(), 0); - BOOST_CHECK_EQUAL((dist.max)(), (std::numeric_limits::max)()); - boost::random::gamma_distribution<> dist_one(7.5); - BOOST_CHECK_EQUAL((dist_one.min)(), 0); - BOOST_CHECK_EQUAL((dist_one.max)(), (std::numeric_limits::max)()); - boost::random::gamma_distribution<> dist_two(7.5, 0.25); - BOOST_CHECK_EQUAL((dist_two.min)(), 0); - BOOST_CHECK_EQUAL((dist_two.max)(), (std::numeric_limits::max)()); -} - -BOOST_AUTO_TEST_CASE(test_comparison) { - boost::random::gamma_distribution<> dist; - boost::random::gamma_distribution<> dist_copy(dist); - boost::random::gamma_distribution<> dist_one(7.5); - boost::random::gamma_distribution<> dist_one_copy(dist_one); - boost::random::gamma_distribution<> dist_two(7.5, 0.25); - boost::random::gamma_distribution<> dist_two_copy(dist_two); - BOOST_CHECK(dist == dist_copy); - BOOST_CHECK(!(dist != dist_copy)); - BOOST_CHECK(dist_one == dist_one_copy); - BOOST_CHECK(!(dist_one != dist_one_copy)); - BOOST_CHECK(dist_two == dist_two_copy); - BOOST_CHECK(!(dist_two != dist_two_copy)); - BOOST_CHECK(dist != dist_one); - BOOST_CHECK(!(dist == dist_one)); - BOOST_CHECK(dist != dist_two); - BOOST_CHECK(!(dist == dist_two)); - BOOST_CHECK(dist_one != dist_two); - BOOST_CHECK(!(dist_one == dist_two)); -} - -BOOST_AUTO_TEST_CASE(test_streaming) { - boost::random::gamma_distribution<> dist(7.5, 0.25); - std::stringstream stream; - stream << dist; - boost::random::gamma_distribution<> restored_dist; - stream >> restored_dist; - BOOST_CHECK_EQUAL(dist, restored_dist); -} - -BOOST_AUTO_TEST_CASE(test_generation) { - boost::minstd_rand0 gen; - boost::random::gamma_distribution<> dist; - boost::random::gamma_distribution<> dist_two(1.0, 1000000.0); - for(int i = 0; i < 10; ++i) { - // This test is not guaranteed to work, since - // a gamma distribution with a large scale parameter - // can produce small values and a distribution with - // a small scale can produce large values, but the - // chances of failure are small. - double value = dist(gen); - BOOST_CHECK_GE(value, 0.0); - BOOST_CHECK_LE(value, 100.0); - double value_two = dist_two(gen); - BOOST_CHECK_GE(value_two, 100.0); - double value_param = dist_two(gen, dist.param()); - BOOST_CHECK_GE(value_param, 0); - BOOST_CHECK_LE(value_param, 100.0); - double value_two_param = dist(gen, dist_two.param()); - BOOST_CHECK_GE(value_two_param, 100.0); - } -} +#include "test_distribution.ipp" diff --git a/test/test_poisson_distribution.cpp b/test/test_poisson_distribution.cpp index 854ae24..a2cb5ae 100644 --- a/test/test_poisson_distribution.cpp +++ b/test/test_poisson_distribution.cpp @@ -10,95 +10,24 @@ */ #include -#include -#include -#define BOOST_TEST_MAIN -#include +#include -BOOST_AUTO_TEST_CASE(test_constructors) { - boost::random::poisson_distribution<> dist; - BOOST_CHECK_EQUAL(dist.mean(), 1.0); - boost::random::poisson_distribution<> dist_one(7.5); - BOOST_CHECK_EQUAL(dist_one.mean(), 7.5); - boost::random::poisson_distribution<> copy(dist); - BOOST_CHECK_EQUAL(dist, copy); - boost::random::poisson_distribution<> copy_one(dist_one); - BOOST_CHECK_EQUAL(dist_one, copy_one); -} +#define BOOST_RANDOM_DISTRIBUTION boost::random::poisson_distribution<> +#define BOOST_RANDOM_ARG1 mean +#define BOOST_RANDOM_ARG1_DEFAULT 1.0 +#define BOOST_RANDOM_ARG1_VALUE 7.5 -BOOST_AUTO_TEST_CASE(test_param) { - boost::random::poisson_distribution<> dist(7.5); - boost::random::poisson_distribution<>::param_type param = dist.param(); - BOOST_CHECK_EQUAL(param.mean(), 7.5); - boost::random::poisson_distribution<> copy1(param); - BOOST_CHECK_EQUAL(dist, copy1); - boost::random::poisson_distribution<> copy2; - copy2.param(param); - BOOST_CHECK_EQUAL(dist, copy2); +#define BOOST_RANDOM_DIST0_MIN 0 +#define BOOST_RANDOM_DIST0_MAX (std::numeric_limits::max)() +#define BOOST_RANDOM_DIST1_MIN 0 +#define BOOST_RANDOM_DIST1_MAX (std::numeric_limits::max)() - boost::random::poisson_distribution<>::param_type param_copy = param; - BOOST_CHECK_EQUAL(param, param_copy); - BOOST_CHECK(param == param_copy); - BOOST_CHECK(!(param != param_copy)); - boost::random::poisson_distribution<>::param_type param_default; - BOOST_CHECK_EQUAL(param_default.mean(), 1.0); - BOOST_CHECK(param != param_default); - BOOST_CHECK(!(param == param_default)); - boost::random::poisson_distribution<>::param_type param_one(7.5); - BOOST_CHECK_EQUAL(param_one.mean(), 7.5); - BOOST_CHECK(param_default != param_one); - BOOST_CHECK(!(param_default == param_one)); -} +#define BOOST_RANDOM_TEST1_PARAMS +#define BOOST_RANDOM_TEST1_MIN 0.0 +#define BOOST_RANDOM_TEST1_MAX 10.0 -BOOST_AUTO_TEST_CASE(test_min_max) { - boost::random::poisson_distribution<> dist; - BOOST_CHECK_EQUAL((dist.min)(), 0); - BOOST_CHECK_EQUAL((dist.max)(), (std::numeric_limits::max)()); - boost::random::poisson_distribution<> dist_one(7.5); - BOOST_CHECK_EQUAL((dist_one.min)(), 0); - BOOST_CHECK_EQUAL((dist_one.max)(), (std::numeric_limits::max)()); -} +#define BOOST_RANDOM_TEST2_PARAMS (1000.0) +#define BOOST_RANDOM_TEST2_MIN 10.0 -BOOST_AUTO_TEST_CASE(test_comparison) { - boost::random::poisson_distribution<> dist; - boost::random::poisson_distribution<> dist_copy(dist); - boost::random::poisson_distribution<> dist_one(7.5); - boost::random::poisson_distribution<> dist_one_copy(dist_one); - BOOST_CHECK(dist == dist_copy); - BOOST_CHECK(!(dist != dist_copy)); - BOOST_CHECK(dist_one == dist_one_copy); - BOOST_CHECK(!(dist_one != dist_one_copy)); - BOOST_CHECK(dist != dist_one); - BOOST_CHECK(!(dist == dist_one)); -} - -BOOST_AUTO_TEST_CASE(test_streaming) { - boost::random::poisson_distribution<> dist(7.5); - std::stringstream stream; - stream << dist; - boost::random::poisson_distribution<> restored_dist; - stream >> restored_dist; - BOOST_CHECK_EQUAL(dist, restored_dist); -} - -BOOST_AUTO_TEST_CASE(test_generation) { - boost::minstd_rand0 gen; - boost::random::poisson_distribution<> dist; - boost::random::poisson_distribution<> dist_1000(1000); - for(int i = 0; i < 10; ++i) { - // Basic sanity checks. Technically these tests are incorrect, - // since the range of a poisson_distribution is [0, inf), but - // the probability that there's an error is very small. - int value = dist(gen); - BOOST_CHECK_GE(value, 0); - BOOST_CHECK_LE(value, 10); - int value_two = dist_1000(gen); - BOOST_CHECK_GE(value_two, 10); - int value_param = dist_1000(gen, dist.param()); - BOOST_CHECK_GE(value_param, 0); - BOOST_CHECK_LE(value_param, 10); - int value_two_param = dist(gen, dist_1000.param()); - BOOST_CHECK_GE(value_two_param, 10); - } -} +#include "test_distribution.ipp" diff --git a/test/test_weibull_distribution.cpp b/test/test_weibull_distribution.cpp index e794f21..cd88b6d 100644 --- a/test/test_weibull_distribution.cpp +++ b/test/test_weibull_distribution.cpp @@ -8,125 +8,29 @@ * $Id$ * */ - #include -#include -#include +#include -#define BOOST_TEST_MAIN -#include +#define BOOST_RANDOM_DISTRIBUTION boost::random::weibull_distribution<> +#define BOOST_RANDOM_ARG1 a +#define BOOST_RANDOM_ARG2 b +#define BOOST_RANDOM_ARG1_DEFAULT 1.0 +#define BOOST_RANDOM_ARG2_DEFAULT 1.0 +#define BOOST_RANDOM_ARG1_VALUE 7.5 +#define BOOST_RANDOM_ARG2_VALUE 0.25 -BOOST_AUTO_TEST_CASE(test_constructors) { - boost::random::weibull_distribution<> dist; - BOOST_CHECK_EQUAL(dist.a(), 1.0); - BOOST_CHECK_EQUAL(dist.b(), 1.0); - boost::random::weibull_distribution<> dist_one(7.5); - BOOST_CHECK_EQUAL(dist_one.a(), 7.5); - BOOST_CHECK_EQUAL(dist_one.b(), 1.0); - boost::random::weibull_distribution<> dist_two(7.5, 0.25); - BOOST_CHECK_EQUAL(dist_two.a(), 7.5); - BOOST_CHECK_EQUAL(dist_two.b(), 0.25); - boost::random::weibull_distribution<> copy(dist); - BOOST_CHECK_EQUAL(dist, copy); - boost::random::weibull_distribution<> copy_one(dist_one); - BOOST_CHECK_EQUAL(dist_one, copy_one); - boost::random::weibull_distribution<> copy_two(dist_two); - BOOST_CHECK_EQUAL(dist_two, copy_two); -} +#define BOOST_RANDOM_DIST0_MIN 0.0 +#define BOOST_RANDOM_DIST0_MAX (std::numeric_limits::infinity)() +#define BOOST_RANDOM_DIST1_MIN 0.0 +#define BOOST_RANDOM_DIST1_MAX (std::numeric_limits::infinity)() +#define BOOST_RANDOM_DIST2_MIN 0.0 +#define BOOST_RANDOM_DIST2_MAX (std::numeric_limits::infinity)() -BOOST_AUTO_TEST_CASE(test_param) { - boost::random::weibull_distribution<> dist(7.5, 0.25); - boost::random::weibull_distribution<>::param_type param = dist.param(); - BOOST_CHECK_EQUAL(param.a(), 7.5); - BOOST_CHECK_EQUAL(param.b(), 0.25); - boost::random::weibull_distribution<> copy1(param); - BOOST_CHECK_EQUAL(dist, copy1); - boost::random::weibull_distribution<> copy2; - copy2.param(param); - BOOST_CHECK_EQUAL(dist, copy2); +#define BOOST_RANDOM_TEST1_PARAMS +#define BOOST_RANDOM_TEST1_MIN 0.0 +#define BOOST_RANDOM_TEST1_MAX 100.0 - boost::random::weibull_distribution<>::param_type param_copy = param; - BOOST_CHECK_EQUAL(param, param_copy); - BOOST_CHECK(param == param_copy); - BOOST_CHECK(!(param != param_copy)); - boost::random::weibull_distribution<>::param_type param_default; - BOOST_CHECK_EQUAL(param_default.a(), 1.0); - BOOST_CHECK_EQUAL(param_default.b(), 1.0); - BOOST_CHECK(param != param_default); - BOOST_CHECK(!(param == param_default)); - boost::random::weibull_distribution<>::param_type param_one(7.5); - BOOST_CHECK_EQUAL(param_one.a(), 7.5); - BOOST_CHECK_EQUAL(param_one.b(), 1.0); - BOOST_CHECK(param != param_one); - BOOST_CHECK(!(param == param_one)); - BOOST_CHECK(param_default != param_one); - BOOST_CHECK(!(param_default == param_one)); - boost::random::weibull_distribution<>::param_type param_two(7.5, 0.25); - BOOST_CHECK_EQUAL(param_two.a(), 7.5); - BOOST_CHECK_EQUAL(param_two.b(), 0.25); -} +#define BOOST_RANDOM_TEST2_PARAMS (1.0, 1000000.0) +#define BOOST_RANDOM_TEST2_MIN 100.0 -BOOST_AUTO_TEST_CASE(test_min_max) { - boost::random::weibull_distribution<> dist; - BOOST_CHECK_EQUAL((dist.min)(), 0); - BOOST_CHECK_EQUAL((dist.max)(), (std::numeric_limits::infinity)()); - boost::random::weibull_distribution<> dist_one(7.5); - BOOST_CHECK_EQUAL((dist_one.min)(), 0); - BOOST_CHECK_EQUAL((dist_one.max)(), (std::numeric_limits::infinity)()); - boost::random::weibull_distribution<> dist_two(7.5, 0.25); - BOOST_CHECK_EQUAL((dist_two.min)(), 0); - BOOST_CHECK_EQUAL((dist_two.max)(), (std::numeric_limits::infinity)()); -} - -BOOST_AUTO_TEST_CASE(test_comparison) { - boost::random::weibull_distribution<> dist; - boost::random::weibull_distribution<> dist_copy(dist); - boost::random::weibull_distribution<> dist_one(7.5); - boost::random::weibull_distribution<> dist_one_copy(dist_one); - boost::random::weibull_distribution<> dist_two(7.5, 0.25); - boost::random::weibull_distribution<> dist_two_copy(dist_two); - BOOST_CHECK(dist == dist_copy); - BOOST_CHECK(!(dist != dist_copy)); - BOOST_CHECK(dist_one == dist_one_copy); - BOOST_CHECK(!(dist_one != dist_one_copy)); - BOOST_CHECK(dist_two == dist_two_copy); - BOOST_CHECK(!(dist_two != dist_two_copy)); - BOOST_CHECK(dist != dist_one); - BOOST_CHECK(!(dist == dist_one)); - BOOST_CHECK(dist != dist_two); - BOOST_CHECK(!(dist == dist_two)); - BOOST_CHECK(dist_one != dist_two); - BOOST_CHECK(!(dist_one == dist_two)); -} - -BOOST_AUTO_TEST_CASE(test_streaming) { - boost::random::weibull_distribution<> dist(7.5, 0.25); - std::stringstream stream; - stream << dist; - boost::random::weibull_distribution<> restored_dist; - stream >> restored_dist; - BOOST_CHECK_EQUAL(dist, restored_dist); -} - -BOOST_AUTO_TEST_CASE(test_generation) { - boost::minstd_rand0 gen; - boost::random::weibull_distribution<> dist; - boost::random::weibull_distribution<> dist_two(1.0, 1000000.0); - for(int i = 0; i < 10; ++i) { - // This test is not guaranteed to work, since - // a weibull distribution with a large scale parameter - // can produce small values and a distribution with - // a small scale can produce large values, but the - // chances of failure are small. - double value = dist(gen); - BOOST_CHECK_GE(value, 0.0); - BOOST_CHECK_LE(value, 100.0); - double value_two = dist_two(gen); - BOOST_CHECK_GE(value_two, 100.0); - double value_param = dist_two(gen, dist.param()); - BOOST_CHECK_GE(value_param, 0); - BOOST_CHECK_LE(value_param, 100.0); - double value_two_param = dist(gen, dist_two.param()); - BOOST_CHECK_GE(value_two_param, 100.0); - } -} +#include "test_distribution.ipp"