ceph/src/boost/libs/detail/test/numeric_traits_test.cpp

   1 //  (C) Copyright David Abrahams 2001.
   2 // Distributed under the Boost Software License, Version 1.0. (See
   3 // accompanying file LICENSE_1_0.txt or copy at
   4 // http://www.boost.org/LICENSE_1_0.txt)
   5
   6 //  See http://www.boost.org for most recent version including documentation.
   7
   8 //  Revision History
   9 //  1  Apr 2001 Fixes for ICL; use BOOST_STATIC_CONSTANT
  10 //  11 Feb 2001 Fixes for Borland (David Abrahams)
  11 //  23 Jan 2001 Added test for wchar_t (David Abrahams)
  12 //  23 Jan 2001 Now statically selecting a test for signed numbers to avoid
  13 //              warnings with fancy compilers. Added commentary and
  14 //              additional dumping of traits data for tested types (David
  15 //              Abrahams).
  16 //  21 Jan 2001 Initial version (David Abrahams)
  17
  18 #include <boost/detail/numeric_traits.hpp>
  19 #include <cassert>
  20 #include <boost/type_traits/conditional.hpp>
  21 #include <boost/type_traits/is_signed.hpp>
  22 #include <boost/type_traits/is_same.hpp>
  23 #include <boost/static_assert.hpp>
  24 #include <boost/cstdint.hpp>
  25 #include <climits>
  26 #include <typeinfo>
  27 #include <iostream>
  28 #include <sstream>
  29 #include <string>
  30 #ifndef BOOST_NO_LIMITS
  31 #include <limits>
  32 #endif
  33
  34 // =================================================================================
  35 // template class complement_traits<Number> --
  36 //
  37 //    statically computes the max and min for 1s and 2s-complement binary
  38 //    numbers. This helps on platforms without <limits> support. It also shows
  39 //    an example of a recursive template that works with MSVC!
  40 //
  41
  42 template <unsigned size> struct complement; // forward
  43
  44 // The template complement, below, does all the real work, using "poor man's
  45 // partial specialization". We need complement_traits_aux<> so that MSVC doesn't
  46 // complain about undefined min/max as we're trying to recursively define them.
  47 template <class Number, unsigned size>
  48 struct complement_traits_aux
  49 {
  50     BOOST_STATIC_CONSTANT(Number, max = complement<size>::template traits<Number>::max);
  51     BOOST_STATIC_CONSTANT(Number, min = complement<size>::template traits<Number>::min);
  52 };
  53
  54 template <unsigned size>
  55 struct complement
  56 {
  57     template <class Number>
  58     struct traits
  59     {
  60      private:
  61         // indirection through complement_traits_aux necessary to keep MSVC happy
  62         typedef complement_traits_aux<Number, size - 1> prev;
  63      public:
  64 #if defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 2
  65         // GCC 4.0.2 ICEs on these C-style casts
  66         BOOST_STATIC_CONSTANT(Number, max =
  67                             Number((prev::max) << CHAR_BIT)
  68                             + Number(UCHAR_MAX));
  69         BOOST_STATIC_CONSTANT(Number, min = Number((prev::min) << CHAR_BIT));
  70 #else
  71         // Avoid left shifting negative integers, use multiplication instead
  72         BOOST_STATIC_CONSTANT(Number, shift = 1u << CHAR_BIT);
  73         BOOST_STATIC_CONSTANT(Number, max =
  74                             Number(Number(prev::max) * shift)
  75                             + Number(UCHAR_MAX));
  76         BOOST_STATIC_CONSTANT(Number, min = Number(Number(prev::min) * shift));
  77 #endif
  78     };
  79 };
  80
  81 // Template class complement_base<> -- defines values for min and max for
  82 // complement<1>, at the deepest level of recursion. Uses "poor man's partial
  83 // specialization" again.
  84 template <bool is_signed> struct complement_base;
  85
  86 template <> struct complement_base<false>
  87 {
  88     template <class Number>
  89     struct values
  90     {
  91         BOOST_STATIC_CONSTANT(Number, min = 0);
  92         BOOST_STATIC_CONSTANT(Number, max = UCHAR_MAX);
  93     };
  94 };
  95
  96 template <> struct complement_base<true>
  97 {
  98     template <class Number>
  99     struct values
 100     {
 101         BOOST_STATIC_CONSTANT(Number, min = SCHAR_MIN);
 102         BOOST_STATIC_CONSTANT(Number, max = SCHAR_MAX);
 103     };
 104 };
 105
 106 // Base specialization of complement, puts an end to the recursion.
 107 template <>
 108 struct complement<1>
 109 {
 110     template <class Number>
 111     struct traits
 112     {
 113         BOOST_STATIC_CONSTANT(bool, is_signed = boost::is_signed<Number>::value);
 114         BOOST_STATIC_CONSTANT(Number, min =
 115                             complement_base<is_signed>::template values<Number>::min);
 116         BOOST_STATIC_CONSTANT(Number, max =
 117                             complement_base<is_signed>::template values<Number>::max);
 118     };
 119 };
 120
 121 // Now here's the "pretty" template you're intended to actually use.
 122 //   complement_traits<Number>::min, complement_traits<Number>::max are the
 123 //   minimum and maximum values of Number if Number is a built-in integer type.
 124 template <class Number>
 125 struct complement_traits
 126 {
 127     BOOST_STATIC_CONSTANT(Number, max = (complement_traits_aux<Number, sizeof(Number)>::max));
 128     BOOST_STATIC_CONSTANT(Number, min = (complement_traits_aux<Number, sizeof(Number)>::min));
 129 };
 130
 131 // =================================================================================
 132
 133 // Support for streaming various numeric types in exactly the format I want. I
 134 // needed this in addition to all the assertions so that I could see exactly
 135 // what was going on.
 136 //
 137 // Numbers go through a 2-stage conversion process (by default, though, no real
 138 // conversion).
 139 //
 140 template <class T> struct stream_as {
 141     typedef T t1;
 142     typedef T t2;
 143 };
 144
 145 // char types first get converted to unsigned char, then to unsigned.
 146 template <> struct stream_as<char> {
 147     typedef unsigned char t1;
 148     typedef unsigned t2;
 149 };
 150 template <> struct stream_as<unsigned char> {
 151     typedef unsigned char t1; typedef unsigned t2;
 152 };
 153 template <> struct stream_as<signed char>  {
 154     typedef unsigned char t1; typedef unsigned t2;
 155 };
 156
 157 #if defined(BOOST_MSVC_STD_ITERATOR) // No intmax streaming built-in
 158
 159 // With this library implementation, __int64 and __uint64 get streamed as strings
 160 template <> struct stream_as<boost::uintmax_t> {
 161     typedef std::string t1;
 162     typedef std::string t2;
 163 };
 164
 165 template <> struct stream_as<boost::intmax_t>  {
 166     typedef std::string t1;
 167     typedef std::string t2;
 168 };
 169 #endif
 170
 171 // Standard promotion process for streaming
 172 template <class T> struct promote
 173 {
 174     static typename stream_as<T>::t1 from(T x) {
 175         typedef typename stream_as<T>::t1 t1;
 176         return t1(x);
 177     }
 178 };
 179
 180 #if defined(BOOST_MSVC_STD_ITERATOR) // No intmax streaming built-in
 181
 182 // On this platform, stream them as long/unsigned long if they fit.
 183 // Otherwise, write a string.
 184 template <> struct promote<boost::uintmax_t> {
 185     std::string static from(const boost::uintmax_t x) {
 186         if (x > ULONG_MAX)
 187             return std::string("large unsigned value");
 188         else {
 189             std::ostringstream strm;
 190             strm << (unsigned long)x;
 191             return strm.str();
 192         }
 193     }
 194 };
 195 template <> struct promote<boost::intmax_t> {
 196     std::string static from(const boost::intmax_t x) {
 197         if (x > boost::intmax_t(ULONG_MAX))
 198             return std::string("large positive signed value");
 199         else if (x >= 0) {
 200             std::ostringstream strm;
 201             strm << (unsigned long)x;
 202             return strm.str();
 203         }
 204
 205         if (x < boost::intmax_t(LONG_MIN))
 206             return std::string("large negative signed value");
 207         else {
 208             std::ostringstream strm;
 209             strm << (long)x;
 210             return strm.str();
 211         }
 212     }
 213 };
 214 #endif
 215
 216 // This is the function which converts types to the form I want to stream them in.
 217 template <class T>
 218 typename stream_as<T>::t2 stream_number(T x)
 219 {
 220     return promote<T>::from(x);
 221 }
 222 // =================================================================================
 223
 224 //
 225 // Tests for built-in signed and unsigned types
 226 //
 227
 228 // Tag types for selecting tests
 229 struct unsigned_tag {};
 230 struct signed_tag {};
 231
 232 // Tests for unsigned numbers. The extra default Number parameter works around
 233 // an MSVC bug.
 234 template <class Number>
 235 void test_aux(unsigned_tag, Number*)
 236 {
 237     typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
 238     BOOST_STATIC_ASSERT(!boost::is_signed<Number>::value);
 239     BOOST_STATIC_ASSERT(
 240         (sizeof(Number) < sizeof(boost::intmax_t))
 241         | (boost::is_same<difference_type, boost::intmax_t>::value));
 242
 243 #if defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 2
 244     // GCC 4.0.2 ICEs on this C-style cases
 245     BOOST_STATIC_ASSERT((complement_traits<Number>::max) > Number(0));
 246     BOOST_STATIC_ASSERT((complement_traits<Number>::min) == Number(0));
 247 #else
 248     // Force casting to Number here to work around the fact that it's an enum on MSVC
 249     BOOST_STATIC_ASSERT(Number(complement_traits<Number>::max) > Number(0));
 250     BOOST_STATIC_ASSERT(Number(complement_traits<Number>::min) == Number(0));
 251 #endif
 252
 253     const Number max = complement_traits<Number>::max;
 254     const Number min = complement_traits<Number>::min;
 255
 256     const Number test_max = (sizeof(Number) < sizeof(boost::intmax_t))
 257         ? max
 258         : max / 2 - 1;
 259
 260     std::cout << std::hex << "(unsigned) min = " << stream_number(min) << ", max = "
 261               << stream_number(max) << "..." << std::flush;
 262     std::cout << "difference_type = " << typeid(difference_type).name() << "..."
 263               << std::flush;
 264
 265     difference_type d1 = boost::detail::numeric_distance(Number(0), test_max);
 266     difference_type d2 = boost::detail::numeric_distance(test_max, Number(0));
 267
 268     std::cout << "0->" << stream_number(test_max) << "==" << std::dec << stream_number(d1) << "; "
 269               << std::hex << stream_number(test_max) << "->0==" << std::dec << stream_number(d2) << "..." << std::flush;
 270
 271     assert(d1 == difference_type(test_max));
 272     assert(d2 == -difference_type(test_max));
 273 }
 274
 275 // Tests for signed numbers. The extra default Number parameter works around an
 276 // MSVC bug.
 277 struct out_of_range_tag {};
 278 struct in_range_tag {};
 279
 280 // This test morsel gets executed for numbers whose difference will always be
 281 // representable in intmax_t
 282 template <class Number>
 283 void signed_test(in_range_tag, Number*)
 284 {
 285     BOOST_STATIC_ASSERT(boost::is_signed<Number>::value);
 286     typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
 287     const Number max = complement_traits<Number>::max;
 288     const Number min = complement_traits<Number>::min;
 289
 290     difference_type d1 = boost::detail::numeric_distance(min, max);
 291     difference_type d2 = boost::detail::numeric_distance(max, min);
 292
 293     std::cout << stream_number(min) << "->" << stream_number(max) << "==";
 294     std::cout << std::dec << stream_number(d1) << "; ";
 295     std::cout << std::hex << stream_number(max) << "->" << stream_number(min)
 296               << "==" << std::dec << stream_number(d2) << "..." << std::flush;
 297     assert(d1 == difference_type(max) - difference_type(min));
 298     assert(d2 == difference_type(min) - difference_type(max));
 299 }
 300
 301 // This test morsel gets executed for numbers whose difference may exceed the
 302 // capacity of intmax_t.
 303 template <class Number>
 304 void signed_test(out_of_range_tag, Number*)
 305 {
 306     BOOST_STATIC_ASSERT(boost::is_signed<Number>::value);
 307     typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
 308     const Number max = complement_traits<Number>::max;
 309     const Number min = complement_traits<Number>::min;
 310
 311     difference_type min_distance = complement_traits<difference_type>::min;
 312     difference_type max_distance = complement_traits<difference_type>::max;
 313
 314     const Number n1 = Number(min + max_distance);
 315     const Number n2 = Number(max + min_distance);
 316     difference_type d1 = boost::detail::numeric_distance(min, n1);
 317     difference_type d2 = boost::detail::numeric_distance(max, n2);
 318
 319     std::cout << stream_number(min) << "->" << stream_number(n1) << "==";
 320     std::cout << std::dec << stream_number(d1) << "; ";
 321     std::cout << std::hex << stream_number(max) << "->" << stream_number(n2)
 322               << "==" << std::dec << stream_number(d2) << "..." << std::flush;
 323     assert(d1 == max_distance);
 324     assert(d2 == min_distance);
 325 }
 326
 327 template <class Number>
 328 void test_aux(signed_tag, Number*)
 329 {
 330     typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
 331     BOOST_STATIC_ASSERT(boost::is_signed<Number>::value);
 332     BOOST_STATIC_ASSERT(
 333         (sizeof(Number) < sizeof(boost::intmax_t))
 334         | (boost::is_same<difference_type, Number>::value));
 335
 336 #if defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 2
 337     // GCC 4.0.2 ICEs on this cast
 338     BOOST_STATIC_ASSERT((complement_traits<Number>::max) > Number(0));
 339     BOOST_STATIC_ASSERT((complement_traits<Number>::min) < Number(0));
 340 #else
 341     // Force casting to Number here to work around the fact that it's an enum on MSVC
 342     BOOST_STATIC_ASSERT(Number(complement_traits<Number>::max) > Number(0));
 343     BOOST_STATIC_ASSERT(Number(complement_traits<Number>::min) < Number(0));
 344 #endif
 345     const Number max = complement_traits<Number>::max;
 346     const Number min = complement_traits<Number>::min;
 347
 348     std::cout << std::hex << "min = " << stream_number(min) << ", max = "
 349               << stream_number(max) << "..." << std::flush;
 350     std::cout << "difference_type = " << typeid(difference_type).name() << "..."
 351               << std::flush;
 352
 353     typedef typename boost::conditional<
 354         (sizeof(Number) < sizeof(boost::intmax_t)),
 355         in_range_tag,
 356         out_of_range_tag
 357     >::type range_tag;
 358     signed_test<Number>(range_tag(), 0);
 359 }
 360
 361
 362 // Test for all numbers. The extra default Number parameter works around an MSVC
 363 // bug.
 364 template <class Number>
 365 void test(Number* = 0)
 366 {
 367     std::cout << "testing " << typeid(Number).name() << ":\n"
 368 #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
 369               << "is_signed: " << (std::numeric_limits<Number>::is_signed ? "true\n" : "false\n")
 370               << "is_bounded: " << (std::numeric_limits<Number>::is_bounded ? "true\n" : "false\n")
 371               << "digits: " << std::numeric_limits<Number>::digits << "\n"
 372 #endif
 373               << "..." << std::flush;
 374
 375     // factoring out difference_type for the assert below confused Borland :(
 376     typedef boost::is_signed<
 377 #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
 378         typename
 379 #endif
 380         boost::detail::numeric_traits<Number>::difference_type
 381         > is_signed;
 382     BOOST_STATIC_ASSERT(is_signed::value);
 383
 384     typedef typename boost::conditional<
 385         boost::is_signed<Number>::value,
 386         signed_tag,
 387         unsigned_tag
 388     >::type signedness;
 389
 390     test_aux<Number>(signedness(), 0);
 391     std::cout << "passed" << std::endl;
 392 }
 393
 394 int main()
 395 {
 396     test<char>();
 397     test<unsigned char>();
 398     test<signed char>();
 399     test<wchar_t>();
 400     test<short>();
 401     test<unsigned short>();
 402     test<int>();
 403     test<unsigned int>();
 404     test<long>();
 405     test<unsigned long>();
 406 #if defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_INTEGRAL_INT64_T)
 407     test< ::boost::long_long_type>();
 408     test< ::boost::ulong_long_type>();
 409 #elif defined(BOOST_MSVC)
 410     // The problem of not having compile-time static class constants other than
 411     // enums prevents this from working, since values get truncated.
 412     // test<boost::uintmax_t>();
 413     // test<boost::intmax_t>();
 414 #endif
 415     return 0;
 416 }