ceph/src/boost/libs/multiprecision/test/test_adapt_serial.cpp

   1 ///////////////////////////////////////////////////////////////
   2 //  Copyright 2012 John Maddock. Distributed under the Boost
   3 //  Software License, Version 1.0. (See accompanying file
   4 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_
   5
   6 //
   7 // Compare arithmetic results using fixed_int to GMP results.
   8 //
   9
  10 #ifdef _MSC_VER
  11 #  define _SCL_SECURE_NO_WARNINGS
  12 #endif
  13
  14 #include <boost/multiprecision/cpp_int.hpp>
  15 #include <boost/multiprecision/logged_adaptor.hpp>
  16 #include <boost/multiprecision/debug_adaptor.hpp>
  17 #include <boost/random/mersenne_twister.hpp>
  18 #include <boost/random/uniform_int.hpp>
  19 #include <boost/timer.hpp>
  20 #include "test.hpp"
  21
  22 #include <iostream>
  23 #include <iomanip>
  24 #include <sstream>
  25 #include <boost/archive/text_iarchive.hpp>
  26 #include <boost/archive/text_oarchive.hpp>
  27 #include <boost/archive/binary_iarchive.hpp>
  28 #include <boost/archive/binary_oarchive.hpp>
  29 #include <boost/exception/all.hpp>
  30
  31 template <class T>
  32 T generate_random(unsigned bits_wanted)
  33 {
  34    static boost::random::mt19937 gen;
  35    typedef boost::random::mt19937::result_type random_type;
  36
  37    T max_val;
  38    unsigned digits;
  39    if(std::numeric_limits<T>::is_bounded && (bits_wanted == (unsigned)std::numeric_limits<T>::digits))
  40    {
  41       max_val = (std::numeric_limits<T>::max)();
  42       digits = std::numeric_limits<T>::digits;
  43    }
  44    else
  45    {
  46       max_val = T(1) << bits_wanted;
  47       digits = bits_wanted;
  48    }
  49
  50    unsigned bits_per_r_val = std::numeric_limits<random_type>::digits - 1;
  51    while((random_type(1) << bits_per_r_val) > (gen.max)()) --bits_per_r_val;
  52
  53    unsigned terms_needed = digits / bits_per_r_val + 1;
  54
  55    T val = 0;
  56    for(unsigned i = 0; i < terms_needed; ++i)
  57    {
  58       val *= (gen.max)();
  59       val += gen();
  60    }
  61    val %= max_val;
  62    return val;
  63 }
  64
  65 template <class T>
  66 void test_neg(const T& x, const boost::mpl::true_&)
  67 {
  68    T val = -x;
  69 #ifndef BOOST_NO_EXCEPTIONS
  70    try
  71    {
  72 #endif
  73       std::stringstream ss;
  74       boost::archive::text_oarchive oa(ss);
  75       oa << static_cast<const T&>(val);
  76       boost::archive::text_iarchive ia(ss);
  77       T val2;
  78       ia >> val2;
  79       BOOST_CHECK_EQUAL(val, val2);
  80
  81       ss.clear();
  82       boost::archive::binary_oarchive ob(ss);
  83       ob << static_cast<const T&>(val);
  84       boost::archive::binary_iarchive ib(ss);
  85       ib >> val2;
  86       BOOST_CHECK_EQUAL(val, val2);
  87 #ifndef BOOST_NO_EXCEPTIONS
  88    }
  89    catch(const boost::exception& e)
  90    {
  91       std::cout << "Caught boost::exception with:\n";
  92       std::cout << diagnostic_information(e);
  93    }
  94    catch(const std::exception& e)
  95    {
  96       std::cout << "Caught std::exception with:\n";
  97       std::cout << e.what() << std::endl;
  98    }
  99 #endif
 100 }
 101 template <class T>
 102 void test_neg(const T& , const boost::mpl::false_&){}
 103
 104 template <class T>
 105 void test()
 106 {
 107    using namespace boost::multiprecision;
 108
 109    boost::random::mt19937 gen;
 110    boost::uniform_int<> d(3, std::numeric_limits<T>::is_bounded ? std::numeric_limits<T>::digits : 3000);
 111    boost::timer tim;
 112
 113    while(true)
 114    {
 115       T val = generate_random<T>(d(gen));
 116 #ifndef BOOST_NO_EXCEPTIONS
 117       try
 118       {
 119 #endif
 120          std::stringstream ss;
 121          boost::archive::text_oarchive oa(ss);
 122          oa << static_cast<const T&>(val);
 123          boost::archive::text_iarchive ia(ss);
 124          T val2;
 125          ia >> val2;
 126          BOOST_CHECK_EQUAL(val, val2);
 127
 128          ss.clear();
 129          boost::archive::binary_oarchive ob(ss);
 130          ob << static_cast<const T&>(val);
 131          boost::archive::binary_iarchive ib(ss);
 132          ib >> val2;
 133          BOOST_CHECK_EQUAL(val, val2);
 134 #ifndef BOOST_NO_EXCEPTIONS
 135       }
 136       catch(const boost::exception& e)
 137       {
 138          std::cout << "Caught boost::exception with:\n";
 139          std::cout << diagnostic_information(e);
 140       }
 141       catch(const std::exception& e)
 142       {
 143          std::cout << "Caught std::exception with:\n";
 144          std::cout << e.what() << std::endl;
 145       }
 146 #endif
 147       test_neg(val, boost::mpl::bool_<std::numeric_limits<T>::is_signed>());
 148       //
 149       // Check to see if test is taking too long.
 150       // Tests run on the compiler farm time out after 300 seconds,
 151       // so don't get too close to that:
 152       //
 153 #ifndef CI_SUPPRESS_KNOWN_ISSUES
 154       if(tim.elapsed() > 30)
 155 #else
 156       if(tim.elapsed() > 10)
 157 #endif
 158       {
 159          std::cout << "Timeout reached, aborting tests now....\n";
 160          break;
 161       }
 162    }
 163 }
 164
 165 int main()
 166 {
 167    using namespace boost::multiprecision;
 168    test<number<logged_adaptor<cpp_int_backend<> > > >();
 169    test<number<debug_adaptor<cpp_int_backend<> > > >();
 170    return boost::report_errors();
 171 }
 172
 173
 174