[Boost-commit] svn:boost r67761 - trunk/libs/random/test

Subject: [Boost-commit] svn:boost r67761 - trunk/libs/random/test
From: steven_at_[hidden]
Date: 2011-01-07 13:49:09

Author: steven_watanabe
Date: 2011-01-07 13:48:53 EST (Fri, 07 Jan 2011)
New Revision: 67761
URL: http://svn.boost.org/trac/boost/changeset/67761

Log:
Start refactoring tests again.
Added:
   trunk/libs/random/test/concepts.hpp   (contents, props changed)
   trunk/libs/random/test/test_generator.ipp   (contents, props changed)
   trunk/libs/random/test/test_mt19937.cpp   (contents, props changed)
Text files modified: 
   trunk/libs/random/test/Jamfile.v2   |     5                                         
   trunk/libs/random/test/validate.cpp |   150 +++++++++++---------------------------- 
   2 files changed, 45 insertions(+), 110 deletions(-)

Modified: trunk/libs/random/test/Jamfile.v2
==============================================================================
--- trunk/libs/random/test/Jamfile.v2	(original)
+++ trunk/libs/random/test/Jamfile.v2	2011-01-07 13:48:53 EST (Fri, 07 Jan 2011)
@@ -24,7 +24,6 @@
     kreutzer1986
     hellekalek1995
     mt11213b
-    mt19937
     mt19937_64
     lagged_fibonacci
     lagged_fibonacci607
@@ -44,6 +43,8 @@
     run instantiate.cpp : : : <define>BOOST_RANDOM_URNG_TEST=$(urng) : test_$(urng) ;
 }
 
+run test_mt19937.cpp /boost//unit_test_framework ;
+
 run test_seed_seq.cpp /boost//unit_test_framework ;
 
 run test_binomial.cpp ;
@@ -77,7 +78,7 @@
 # run statistic_tests.cpp ;
 
 exe statistic_tests.exe : statistic_tests.cpp ;
-explicit statistics_tests ;
+explicit statistics_tests.exe ;
 
 install statistic_tests : statistic_tests.exe : <install-type>EXE <location>. ;
 explicit statistic_tests ;

Added: trunk/libs/random/test/concepts.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/random/test/concepts.hpp	2011-01-07 13:48:53 EST (Fri, 07 Jan 2011)
@@ -0,0 +1,134 @@
+/* concepts.hpp
+ *
+ * Copyright Steven Watanabe 2011
+ * 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 <boost/concept_check.hpp>
+#include <boost/concept_archetype.hpp>
+# include <boost/concept/requires.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_arithmetic.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/static_assert.hpp>
+#include <istream>
+#include <ostream>
+
+#ifndef BOOST_RANDOM_TEST_CONCEPTS_HPP
+#define BOOST_RANDOM_TEST_CONCEPTS_HPP
+
+namespace boost {
+namespace random {
+namespace test {
+
+template<class Base = null_archetype<> >
+struct seed_seq_archetype : Base
+{
+    template<class Iter>
+    BOOST_CONCEPT_REQUIRES(
+        ((Mutable_RandomAccessIterator<Iter>))
+        ((UnsignedInteger<typename Mutable_RandomAccessIterator<Iter>::value_type>)),
+    (void))
+    generate(Iter, Iter);
+};
+
+template<class SSeq>
+struct SeedSeq
+{
+public:
+    BOOST_CONCEPT_USAGE(SeedSeq)
+    {
+        q.generate(rb, re);
+    }
+private:
+    SSeq q;
+    mutable_random_access_iterator_archetype<boost::uint32_t> rb, re;
+};
+
+template<class T>
+struct Streamable
+{
+public:
+    BOOST_CONCEPT_USAGE(Streamable)
+    {
+        os << x;
+        is >> v;
+        wos << x;
+        wis >> v;
+    }
+private:
+    const T x;
+    T v;
+
+    std::istream is;
+    std::ostream os;
+    std::wistream wis;
+    std::wostream wos;
+};
+
+template <class E>
+struct RandomNumberEngine :
+    DefaultConstructible<E>,
+    CopyConstructible<E>,
+    Assignable<E>,
+    EqualityComparable<E>,
+    Streamable<E>
+{
+ public:
+    typedef typename E::result_type result_type;
+
+    // relaxed from the standard
+    BOOST_MPL_ASSERT((boost::is_arithmetic<result_type>));
+
+    // backwards compatibility check
+    BOOST_STATIC_ASSERT(!E::has_fixed_range);
+
+    // a generator can be used to seed another generator (extension)
+    BOOST_CONCEPT_ASSERT((SeedSeq<E>));
+
+    BOOST_CONCEPT_USAGE(RandomNumberEngine)
+    {
+        same_type(e(), result_type());
+        same_type(E::min(), result_type());
+        same_type(E::max(), result_type());
+
+        E();
+        E(s);
+        E(q);
+
+        e.seed();
+        e.seed(s);
+        e.seed(q);
+
+        e.discard(z);
+
+        // extension
+        E(sb, se);
+        e.seed(sb, se);
+    }
+    
+ private:
+    E e;
+    E v;
+    const E x;
+    seed_seq_archetype<> q;
+    result_type s;
+    unsigned long long z;
+    
+    input_iterator_archetype<boost::uint32_t> sb, se;
+
+    // Type deduction will fail unless the arguments have the same type.
+    template <typename T>
+    void same_type(T const&, T const&);
+};
+
+}
+}
+}
+
+#endif

Added: trunk/libs/random/test/test_generator.ipp
==============================================================================
--- (empty file)
+++ trunk/libs/random/test/test_generator.ipp	2011-01-07 13:48:53 EST (Fri, 07 Jan 2011)
@@ -0,0 +1,194 @@
+/* test_generator.ipp
+ *
+ * Copyright Steven Watanabe 2011
+ * 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 "concepts.hpp"
+#include <boost/random/seed_seq.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+using boost::random::test::RandomNumberEngine;
+BOOST_CONCEPT_ASSERT((RandomNumberEngine< BOOST_RANDOM_URNG >));
+
+typedef BOOST_RANDOM_URNG::result_type result_type;
+
+template<class Converted, class URNG, class T>
+void test_seed_conversion(URNG & urng, const T & t)
+{
+    Converted c = static_cast<Converted>(t);
+    if(static_cast<T>(c) == t) {
+        URNG urng2(c);
+        std::ostringstream msg;
+        msg << "Testing seed: type " << typeid(Converted).name() << ", value " << c;
+        BOOST_CHECK_MESSAGE(urng == urng2, msg.str());
+        urng2.seed(c);
+        BOOST_CHECK_MESSAGE(urng == urng2, msg.str());
+    }
+}
+
+void test_seed(result_type value)
+{
+    BOOST_RANDOM_URNG urng(value);
+
+    // integral types
+    test_seed_conversion<char>(urng, value);
+    test_seed_conversion<signed char>(urng, value);
+    test_seed_conversion<unsigned char>(urng, value);
+    test_seed_conversion<short>(urng, value);
+    test_seed_conversion<unsigned short>(urng, value);
+    test_seed_conversion<int>(urng, value);
+    test_seed_conversion<unsigned int>(urng, value);
+    test_seed_conversion<long>(urng, value);
+    test_seed_conversion<unsigned long>(urng, value);
+#if !defined(BOOST_NO_INT64_T)
+    test_seed_conversion<boost::int64_t>(urng, value);
+    test_seed_conversion<boost::uint64_t>(urng, value);
+#endif
+
+    // floating point types
+    test_seed_conversion<float>(urng, value);
+    test_seed_conversion<double>(urng, value);
+    test_seed_conversion<long double>(urng, value);
+}
+
+BOOST_AUTO_TEST_CASE(test_default_seed)
+{
+    BOOST_RANDOM_URNG urng;
+    BOOST_RANDOM_URNG urng2;
+    urng2();
+    BOOST_CHECK_NE(urng, urng2);
+    urng2.seed();
+    BOOST_CHECK_EQUAL(urng, urng2);
+}
+
+BOOST_AUTO_TEST_CASE(test_arithmetic_seed)
+{
+    test_seed(static_cast<result_type>(0));
+    test_seed(static_cast<result_type>(127));
+    test_seed(static_cast<result_type>(539157235));
+    test_seed(static_cast<result_type>(~0u));
+}
+   
+BOOST_AUTO_TEST_CASE(test_iterator_seed)
+{
+    const std::vector<int> v(9999u, 0x41);
+    std::vector<int>::const_iterator it = v.begin();
+    std::vector<int>::const_iterator it_end = v.end();
+    BOOST_RANDOM_URNG urng(it, it_end);
+    BOOST_CHECK(it != v.begin());
+    std::iterator_traits<std::vector<int>::const_iterator>::difference_type n_words = (it - v.begin());
+    BOOST_CHECK_GT(n_words, 0);
+
+	it = v.begin();
+    BOOST_RANDOM_URNG urng2;
+    urng2.seed(it, it_end);
+    std::iterator_traits<std::vector<int>::const_iterator>::difference_type n_words2 = (it - v.begin());
+    BOOST_CHECK_EQUAL(n_words, n_words2);
+    BOOST_CHECK_EQUAL(urng, urng2);
+
+    it = v.end();
+    BOOST_CHECK_THROW(BOOST_RANDOM_URNG(it, it_end), std::invalid_argument);
+    BOOST_CHECK_THROW(urng.seed(it, it_end), std::invalid_argument);
+
+    if(n_words > 1) {
+        it = v.end();
+        --it;
+		BOOST_CHECK_THROW(BOOST_RANDOM_URNG(it, it_end), std::invalid_argument);
+        it = v.end();
+        --it;
+        BOOST_CHECK_THROW(urng.seed(it, it_end), std::invalid_argument);
+    }
+}
+
+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);
+    urng2.seed(q);
+    BOOST_CHECK_EQUAL(urng, urng2);
+}
+
+template<class CharT>
+void do_test_streaming(const BOOST_RANDOM_URNG& urng)
+{
+    BOOST_RANDOM_URNG urng2;
+    std::basic_ostringstream<CharT> output;
+    output << urng;
+    BOOST_CHECK_NE(urng, urng2);
+    // restore old state
+    std::basic_istringstream<CharT> input(output.str());
+    input >> urng2;
+    BOOST_CHECK_EQUAL(urng, urng2);
+}
+
+BOOST_AUTO_TEST_CASE(test_streaming)
+{
+    BOOST_RANDOM_URNG urng;
+    urng.discard(9307);
+    do_test_streaming<char>(urng);
+#if !defined(BOOST_NO_STD_WSTREAMBUF) && !defined(BOOST_NO_STD_WSTRING)
+    do_test_streaming<wchar_t>(urng);
+#endif
+}
+
+BOOST_AUTO_TEST_CASE(test_discard)
+{
+    BOOST_RANDOM_URNG urng;
+    BOOST_RANDOM_URNG urng2;
+    BOOST_CHECK_EQUAL(urng, urng2);
+    for(int i = 0; i < 9307; ++i)
+        urng();
+    BOOST_CHECK_NE(urng, urng2);
+    urng2.discard(9307);
+    BOOST_CHECK_EQUAL(urng, urng2);
+}
+
+BOOST_AUTO_TEST_CASE(test_copy)
+{
+    BOOST_RANDOM_URNG urng;
+    urng.discard(9307);
+    {
+        BOOST_RANDOM_URNG urng2 = urng;
+        BOOST_CHECK_EQUAL(urng, urng2);
+    }
+    {
+        BOOST_RANDOM_URNG urng2(urng);
+        BOOST_CHECK_EQUAL(urng, urng2);
+    }
+    {
+        BOOST_RANDOM_URNG urng2;
+        urng2 = urng;
+        BOOST_CHECK_EQUAL(urng, urng2);
+    }
+}
+
+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_AUTO_TEST_CASE(test_comparison)
+{
+    BOOST_RANDOM_URNG urng;
+    BOOST_RANDOM_URNG urng2;
+    BOOST_CHECK(urng == urng2);
+    BOOST_CHECK(!(urng != urng2));
+    urng();
+    BOOST_CHECK(urng != urng2);
+    BOOST_CHECK(!(urng == urng2));
+}

Added: trunk/libs/random/test/test_mt19937.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/random/test/test_mt19937.cpp	2011-01-07 13:48:53 EST (Fri, 07 Jan 2011)
@@ -0,0 +1,16 @@
+/* test_mt19937.cpp
+ *
+ * Copyright Steven Watanabe 2011
+ * 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 <boost/random/mersenne_twister.hpp>
+
+#define BOOST_RANDOM_URNG boost::random::mt19937
+
+#include "test_generator.ipp"

Modified: trunk/libs/random/test/validate.cpp
==============================================================================
--- trunk/libs/random/test/validate.cpp	(original)
+++ trunk/libs/random/test/validate.cpp	2011-01-07 13:48:53 EST (Fri, 07 Jan 2011)
@@ -1,6 +1,7 @@
 /* boost validate.cpp
  *
  * Copyright Jens Maurer 2000
+ * Copyright Steven Watanabe 2010-2011
  * 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)
@@ -8,145 +9,78 @@
  * $Id$
  */
 
-#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
-#pragma warning( disable : 4786 )
-#endif
-
-#include <iostream>
-#include <sstream>
-#include <string>
 #include <cmath>
-#include <iterator>
-#include <vector>
 #include <boost/random.hpp>
 #include <boost/config.hpp>
 
 #include <boost/test/test_tools.hpp>
 #include <boost/test/included/test_exec_monitor.hpp>
 
-#ifdef BOOST_NO_STDC_NAMESPACE
-  namespace std { using ::abs; using ::fabs; using ::pow; }
-#endif
-
-
-/*
- * General portability note:
- * MSVC mis-compiles explicit function template instantiations.
- * For example, f<A>() and f<B>() are both compiled to call f<A>().
- * BCC is unable to implicitly convert a "const char *" to a std::string
- * when using explicit function template instantiations.
- *
- * Therefore, avoid explicit function template instantiations.
- */
-
 /*
  * Validate correct implementation
  */
 
-// own run
-bool check_(unsigned long x, const boost::mt11213b&) { return x == 3809585648U; }
+template<class PRNG>
+typename PRNG::result_type validation_value(PRNG rng)
+{
+    for(int i = 0; i < 9999; i++)
+        rng();
+    return rng();
+}
+
+int test_main(int, char*[])
+{
+    // own run
+    BOOST_CHECK_EQUAL(validation_value(boost::mt11213b()), 3809585648U);
 
-// validation by experiment from mt19937.c
-bool check_(unsigned long x, const boost::mt19937&) { return x == 4123659995U; }
+    // validation by experiment from mt19937.c
+    BOOST_CHECK_EQUAL(validation_value(boost::mt19937()), 4123659995U);
 
 #if !defined(BOOST_NO_INT64_T) && !defined(BOOST_NO_INTEGRAL_INT64_T)
-// validation from the C++0x draft (n3090)
-bool check_(boost::uint64_t x, const boost::mt19937_64&) { return x == UINT64_C(9981545732273789042); }
+    // validation from the C++0x draft (n3090)
+    BOOST_CHECK_EQUAL(validation_value(boost::mt19937_64()), UINT64_C(9981545732273789042));
 #endif
 
-// validation values from the publications
-bool check_(int x, const boost::minstd_rand0&) { return x == 1043618065; }
+    // validation values from the publications
+    BOOST_CHECK_EQUAL(validation_value(boost::minstd_rand0()), 1043618065);
 
-// validation values from the publications
-bool check_(int x, const boost::minstd_rand&) { return x == 399268537; }
+    // validation values from the publications
+    BOOST_CHECK_EQUAL(validation_value(boost::minstd_rand()), 399268537);
 
 #if !defined(BOOST_NO_INT64_T) && !defined(BOOST_NO_INTEGRAL_INT64_T)
-// by experiment from lrand48()
-bool check_(unsigned long x, const boost::rand48&) { return x == 1993516219; }
+    // by experiment from lrand48()
+    BOOST_CHECK_EQUAL(validation_value(boost::rand48()), 1993516219);
 #endif
 
-// ????
-bool check_(unsigned long x, const boost::taus88&) { return x == 3535848941U; }
+    // ????
+    BOOST_CHECK_EQUAL(validation_value(boost::taus88()), 3535848941U);
 
-// ????
-bool check_(int x, const boost::ecuyer1988&) { return x == 2060321752; }
+    // ????
+    BOOST_CHECK_EQUAL(validation_value(boost::ecuyer1988()), 2060321752);
 
-// validation by experiment from Harry Erwin's generator.h (private e-mail)
-bool check_(unsigned int x, const boost::kreutzer1986&) { return x == 139726; }
+    // validation by experiment from Harry Erwin's generator.h (private e-mail)
+    BOOST_CHECK_EQUAL(validation_value(boost::kreutzer1986()), 139726);
 
-// validation from the C++0x draft (n3090)
-bool check_(unsigned int x, const boost::random::knuth_b&) { return x == 1112339016; }
+    // validation from the C++0x draft (n3090)
+    BOOST_CHECK_EQUAL(validation_value(boost::random::knuth_b()), 1112339016);
 
-bool check_(double x, const boost::lagged_fibonacci607&) { return std::abs(x-0.401269) < 1e-5; }
+    BOOST_CHECK_CLOSE_FRACTION(validation_value(boost::lagged_fibonacci607()), 0.401269, 1e-5);
 
-// principal operation validated with CLHEP, values by experiment
-bool check_(unsigned long x, const boost::ranlux3&) { return x == 5957620; }
-bool check_(unsigned long x, const boost::ranlux4&) { return x == 8587295; }
+    // principal operation validated with CLHEP, values by experiment
+    BOOST_CHECK_EQUAL(validation_value(boost::ranlux3()), 5957620);
+    BOOST_CHECK_EQUAL(validation_value(boost::ranlux4()), 8587295);
 
-bool check_(float x, const boost::ranlux3_01&)
-{ return std::abs(x-5957620/std::pow(2.0f,24)) < 1e-6; }
-bool check_(float x, const boost::ranlux4_01&)
-{ return std::abs(x-8587295/std::pow(2.0f,24)) < 1e-6; }
+    BOOST_CHECK_CLOSE_FRACTION(validation_value(boost::ranlux3_01()), 5957620/std::pow(2.0f,24), 1e-6);
+    BOOST_CHECK_CLOSE_FRACTION(validation_value(boost::ranlux4_01()), 8587295/std::pow(2.0f,24), 1e-6);
 
-bool check_(double x, const boost::ranlux64_3_01&)
-{ return std::abs(x-0.838413) < 1e-6; }
-bool check_(double x, const boost::ranlux64_4_01&)
-{ return std::abs(x-0.59839) < 1e-6; }
+    BOOST_CHECK_CLOSE_FRACTION(validation_value(boost::ranlux64_3_01()), 0.838413, 1e-6);
+    BOOST_CHECK_CLOSE_FRACTION(validation_value(boost::ranlux64_4_01()), 0.59839, 1e-6);
 
-bool check_(boost::uint32_t x, const boost::random::ranlux24&) { return x == 9901578; }
-#if !defined(BOOST_NO_INT64_T) && !defined(BOOST_NO_INTEGRAL_INT64_T)
-bool check_(boost::uint64_t x, const boost::random::ranlux48&) { return x == UINT64_C(249142670248501); }
-#endif
+    BOOST_CHECK_EQUAL(validation_value(boost::random::ranlux24()), 9901578);
 
-template<class PRNG>
-void validate(const std::string & name, const PRNG &)
-{
-  std::cout << "validating " << name << ": ";
-  PRNG rng;  // default ctor
-  for(int i = 0; i < 9999; i++)
-    rng();
-  typename PRNG::result_type val = rng();
-  // make sure the validation function is a static member
-  bool result = check_(val, rng);
-  
-  // allow for a simple eyeball check for MSVC instantiation brokenness
-  // (if the numbers for all generators are the same, it's obviously broken)
-  std::cout << val << std::endl;
-  BOOST_CHECK(result);
-}
-
-void validate_all()
-{
-  using namespace boost;
 #if !defined(BOOST_NO_INT64_T) && !defined(BOOST_NO_INTEGRAL_INT64_T)
-  validate("rand48", rand48());
+    BOOST_CHECK_EQUAL(validation_value(boost::random::ranlux48()), UINT64_C(249142670248501));
 #endif
-  validate("minstd_rand", minstd_rand());
-  validate("minstd_rand0", minstd_rand0());
-  validate("ecuyer combined", ecuyer1988());
-  validate("mt11213b", mt11213b());
-  validate("mt19937", mt19937());
-#if !defined(BOOST_NO_INT64_T) && !defined(BOOST_NO_INTEGRAL_INT64_T)
-  validate("mt19937_64", mt19937_64());
-#endif
-  validate("kreutzer1986", kreutzer1986());
-  validate("knuth_b", boost::random::knuth_b());
-  validate("ranlux3", ranlux3());
-  validate("ranlux4", ranlux4());
-  validate("ranlux3_01", ranlux3_01());
-  validate("ranlux4_01", ranlux4_01());
-  validate("ranlux64_3_01", ranlux64_3_01());
-  validate("ranlux64_4_01", ranlux64_4_01());
-  validate("ranlux24", boost::random::ranlux24());
-#if !defined(BOOST_NO_INT64_T) && !defined(BOOST_NO_INTEGRAL_INT64_T)
-  validate("ranlux48", boost::random::ranlux48());
-#endif
-  validate("taus88", taus88());
-  validate("lagged_fibonacci607", lagged_fibonacci607());
-}
 
-int test_main(int, char*[])
-{
-  validate_all();
-  return 0;
+    return 0;
 }