Release 1.41.0

[SVN r57747]

cstdint_test.cpp

@@ -1,233 +0,0 @@
-//  boost cstdint.hpp test program  ------------------------------------------//
-
-//  Copyright Beman Dawes 2000.  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)
-
-
-//  See http://www.boost.org/libs/integer for documentation.
-
-//  Revision History
-//   11 Sep 01  Adapted to work with macros defined in native stdint.h (John Maddock)
-//   12 Nov 00  Adapted to merged <boost/cstdint.hpp>
-//   23 Sep 00  Added INTXX_C constant macro support + int64_t support (John Maddock).
-//   28 Jun 00  Initial version
-#define __STDC_CONSTANT_MACROS
-#include <cassert>
-#include <iostream>
-#include <boost/cstdint.hpp>
-
-#ifdef NDEBUG
-int main()
-{
-  std::cout << "This test makes no sense with NDEBUG defined.\n";
-  return 0;
-}
-#else
-
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-//
-// the following class is designed to verify
-// that the various INTXX_C macros can be used
-// in integral constant expressions:
-//
-struct integral_constant_checker
-{
-  static const boost::int8_t          int8          = INT8_C(-127);
-  static const boost::int_least8_t    int_least8    = INT8_C(-127);
-  static const boost::int_fast8_t     int_fast8     = INT8_C(-127);
-
-  static const boost::uint8_t         uint8         = UINT8_C(255);
-  static const boost::uint_least8_t   uint_least8   = UINT8_C(255);
-  static const boost::uint_fast8_t    uint_fast8    = UINT8_C(255);
-
-  static const boost::int16_t         int16         = INT16_C(-32767);
-  static const boost::int_least16_t   int_least16   = INT16_C(-32767);
-  static const boost::int_fast16_t    int_fast16    = INT16_C(-32767);
-
-  static const boost::uint16_t        uint16         = UINT16_C(65535);
-  static const boost::uint_least16_t  uint_least16   = UINT16_C(65535);
-  static const boost::uint_fast16_t   uint_fast16    = UINT16_C(65535);
-
-  static const boost::int32_t         int32         = INT32_C(-2147483647);
-  static const boost::int_least32_t   int_least32   = INT32_C(-2147483647);
-  static const boost::int_fast32_t    int_fast32    = INT32_C(-2147483647);
-
-  static const boost::uint32_t        uint32        = UINT32_C(4294967295);
-  static const boost::uint_least32_t  uint_least32  = UINT32_C(4294967295);
-  static const boost::uint_fast32_t   uint_fast32   = UINT32_C(4294967295);
-
-  static void check();
-};
-
-void integral_constant_checker::check()
-{
-  assert( int8 == -127 );
-  assert( int_least8 == -127 );
-  assert( int_fast8 == -127 );
-  assert( uint8 == 255u );
-  assert( uint_least8 == 255u );
-  assert( uint_fast8 == 255u );
-  assert( int16 == -32767 );
-  assert( int_least16 == -32767 );
-  assert( int_fast16 == -32767 );
-  assert( uint16 == 65535u );
-  assert( uint_least16 == 65535u );
-  assert( uint_fast16 == 65535u );
-  assert( int32 == -2147483647 );
-  assert( int_least32 == -2147483647 );
-  assert( int_fast32 == -2147483647 );
-  assert( uint32 == 4294967295u );
-  assert( uint_least32 == 4294967295u );
-  assert( uint_fast32 == 4294967295u );
-}
-#endif // BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-
-//
-// the following function simply verifies that the type
-// of an integral constant is correctly defined:
-//
-#ifdef __BORLANDC__
-#pragma option -w-8008
-#pragma option -w-8066
-#endif
-template <class T1, class T2>
-void integral_constant_type_check(T1, T2)
-{
-   //
-   // the types T1 and T2 may not be exactly
-   // the same type, but they should be the
-   // same size and signedness. We could use
-   // numeric_limits to verify this, but
-   // numeric_limits implementations currently
-   // vary too much, or are incomplete or missing.
-   //
-   T1 t1 = static_cast<T1>(-1);  // cast suppresses warnings
-   T2 t2 = static_cast<T2>(-1);  // ditto
-#if defined(BOOST_HAS_STDINT_H)
-   // if we have a native stdint.h
-   // then the INTXX_C macros may define
-   // a type that's wider than required:
-   assert(sizeof(T1) <= sizeof(T2));
-#else
-   assert(sizeof(T1) == sizeof(T2));
-   assert(t1 == t2);
-#endif
-#if defined(BOOST_HAS_STDINT_H)
-   // native headers are permitted to promote small
-   // unsigned types to type int:
-   if(sizeof(T1) >= sizeof(int))
-   {
-      if(t1 > 0)
-        assert(t2 > 0);
-      else
-        assert(!(t2 > 0));
-   }
-   else if(t1 < 0)
-      assert(!(t2 > 0));
-#else
-   if(t1 > 0)
-     assert(t2 > 0);
-   else
-     assert(!(t2 > 0));
-#endif
-}
-
-
-int main()
-{
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-  integral_constant_checker::check();
-#endif
-  //
-  // verify the types of the integral constants:
-  //
-  integral_constant_type_check(boost::int8_t(0), INT8_C(0));
-  integral_constant_type_check(boost::uint8_t(0), UINT8_C(0));
-  integral_constant_type_check(boost::int16_t(0), INT16_C(0));
-  integral_constant_type_check(boost::uint16_t(0), UINT16_C(0));
-  integral_constant_type_check(boost::int32_t(0), INT32_C(0));
-  integral_constant_type_check(boost::uint32_t(0), UINT32_C(0));
-#ifndef BOOST_NO_INT64_T
-  integral_constant_type_check(boost::int64_t(0), INT64_C(0));
-  integral_constant_type_check(boost::uint64_t(0), UINT64_C(0));
-#endif
-  //
-  boost::int8_t          int8          = INT8_C(-127);
-  boost::int_least8_t    int_least8    = INT8_C(-127);
-  boost::int_fast8_t     int_fast8     = INT8_C(-127);
-
-  boost::uint8_t         uint8         = UINT8_C(255);
-  boost::uint_least8_t   uint_least8   = UINT8_C(255);
-  boost::uint_fast8_t    uint_fast8    = UINT8_C(255);
-
-  boost::int16_t         int16         = INT16_C(-32767);
-  boost::int_least16_t   int_least16   = INT16_C(-32767);
-  boost::int_fast16_t    int_fast16    = INT16_C(-32767);
-
-  boost::uint16_t        uint16         = UINT16_C(65535);
-  boost::uint_least16_t  uint_least16   = UINT16_C(65535);
-  boost::uint_fast16_t   uint_fast16    = UINT16_C(65535);
-
-  boost::int32_t         int32         = INT32_C(-2147483647);
-  boost::int_least32_t   int_least32   = INT32_C(-2147483647);
-  boost::int_fast32_t    int_fast32    = INT32_C(-2147483647);
-
-  boost::uint32_t        uint32        = UINT32_C(4294967295);
-  boost::uint_least32_t  uint_least32  = UINT32_C(4294967295);
-  boost::uint_fast32_t   uint_fast32   = UINT32_C(4294967295);
-
-#ifndef BOOST_NO_INT64_T
-  boost::int64_t         int64         = INT64_C(-9223372036854775807);
-  boost::int_least64_t   int_least64   = INT64_C(-9223372036854775807);
-  boost::int_fast64_t    int_fast64    = INT64_C(-9223372036854775807);
-
-  boost::uint64_t        uint64        = UINT64_C(18446744073709551615);
-  boost::uint_least64_t  uint_least64  = UINT64_C(18446744073709551615);
-  boost::uint_fast64_t   uint_fast64   = UINT64_C(18446744073709551615);
-
-  boost::intmax_t        intmax        = INTMAX_C(-9223372036854775807);
-  boost::uintmax_t       uintmax       = UINTMAX_C(18446744073709551615);
-#else
-  boost::intmax_t        intmax        = INTMAX_C(-2147483647);
-  boost::uintmax_t       uintmax       = UINTMAX_C(4294967295);
-#endif
-
-  assert( int8 == -127 );
-  assert( int_least8 == -127 );
-  assert( int_fast8 == -127 );
-  assert( uint8 == 255u );
-  assert( uint_least8 == 255u );
-  assert( uint_fast8 == 255u );
-  assert( int16 == -32767 );
-  assert( int_least16 == -32767 );
-  assert( int_fast16 == -32767 );
-  assert( uint16 == 65535u );
-  assert( uint_least16 == 65535u );
-  assert( uint_fast16 == 65535u );
-  assert( int32 == -2147483647 );
-  assert( int_least32 == -2147483647 );
-  assert( int_fast32 == -2147483647 );
-  assert( uint32 == 4294967295u );
-  assert( uint_least32 == 4294967295u );
-  assert( uint_fast32 == 4294967295u );
-
-#ifndef BOOST_NO_INT64_T
-  assert( int64 == INT64_C(-9223372036854775807) );
-  assert( int_least64 == INT64_C(-9223372036854775807) );
-  assert( int_fast64 == INT64_C(-9223372036854775807) );
-  assert( uint64 == UINT64_C(18446744073709551615) );
-  assert( uint_least64 == UINT64_C(18446744073709551615) );
-  assert( uint_fast64 == UINT64_C(18446744073709551615) );
-  assert( intmax == INT64_C(-9223372036854775807) );
-  assert( uintmax == UINT64_C(18446744073709551615) );
-#else
-  assert( intmax == -2147483647 );
-  assert( uintmax == 4294967295u );
-#endif
-
-
-  std::cout << "OK\n";
-  return 0;
-}
-#endif

include/boost/cstdint.hpp

@@ -36,7 +36,7 @@
       // this is triggered with GCC, because it defines __cplusplus < 199707L
 #     define BOOST_NO_INT64_T
 #   endif 
-# elif defined(__FreeBSD__) || defined(__IBMCPP__)
+# elif defined(__FreeBSD__) || defined(__IBMCPP__) || defined(_AIX)
 #   include <inttypes.h>
 # else
 #   include <stdint.h>

include/boost/detail/extended_integer.hpp

@@ -1,177 +0,0 @@
-// Boost detail/extended_integer.hpp header file  ----------------------------//
-
-// (C) Copyright Daryle Walker 2008.  Distributed under the Boost Software
-// License, Version 1.0.  (See the accompanying file LICENSE_1_0.txt or a copy
-// at <http://www.boost.org/LICENSE_1_0.txt>.)
-
-// Encapsulates the double-long and __int64 type families as a single family,
-// as they are mutually exclusive.
-
-/** \file
-    \brief  Common definition of extended integer types.
-
-    Instead of other Boost headers making separate \#defines for the double-long
-    and __int64 type families, since they're mutually exclusive, make a single
-    set of types and macros for the family that exists (if either).
- */
-
-#ifndef BOOST_DETAIL_EXTENDED_INTEGER_HPP
-#define BOOST_DETAIL_EXTENDED_INTEGER_HPP
-
-#include <boost/config.hpp>  // for BOOST_HAS_LONG_LONG and BOOST_HAS_MS_INT64
-
-#include <climits>  // for CHAR_BIT, etc.
-
-
-namespace boost
-{
-namespace detail
-{
-
-
-//  Extended integer type macro and alias definitions  -----------------------//
-
-// (Unsigned) long long family
-#ifdef BOOST_HAS_LONG_LONG
-
-// Existence
-#define BOOST_HAS_XINT  1
-
-// Extents
-#ifdef ULLONG_MAX
-#define BOOST_XINT_MAX    LLONG_MAX
-#define BOOST_XINT_MIN    LLONG_MIN
-#define BOOST_UXINT_MAX  ULLONG_MAX
-#elif defined(ULONG_LONG_MAX)
-#define BOOST_XINT_MAX    LONG_LONG_MAX
-#define BOOST_XINT_MIN    LONG_LONG_MIN
-#define BOOST_UXINT_MAX  ULONG_LONG_MAX
-#elif defined(ULONGLONG_MAX)
-#define BOOST_XINT_MAX    LONGLONG_MAX
-#define BOOST_XINT_MIN    LONGLONG_MIN
-#define BOOST_UXINT_MAX  ULONGLONG_MAX
-#elif defined(_LLONG_MAX) && defined(_C2)
-#define BOOST_XINT_MAX    _LLONG_MAX
-#define BOOST_XINT_MIN    (-_LLONG_MAX - _C2)
-#define BOOST_UXINT_MAX  _ULLONG_MAX
-#else  // guess
-// Sometimes we get the double-long types without the corresponding constants,
-// e.g. GCC in "-ansi" mode.  In this case, we'll just have to work out the
-// values ourselves.  (Here we assume a two's complement representation.)
-#define BOOST_XINT_MIN   (1LL << (sizeof(::boost::long_long_type) * CHAR_BIT - 1))
-#define BOOST_XINT_MAX   (~ BOOST_XINT_MIN)
-#define BOOST_UXINT_MAX  (~ 0uLL)
-#endif
-
-// Types
-typedef ::boost:: long_long_type   xint_t;
-typedef ::boost::ulong_long_type  uxint_t;
-
-// (Unsigned) __int64 family
-#elif defined(BOOST_HAS_MS_INT64)
-
-// Existence
-#define BOOST_HAS_XINT  1
-
-// Extents
-#ifdef _UI64_MAX
-#define BOOST_XINT_MAX    _I64_MAX
-#define BOOST_XINT_MIN    _I64_MIN
-#define BOOST_UXINT_MAX  _UI64_MAX
-#else  // guess
-// The types are exactly 2's-compl. 64-bit, so we'll enter the values directly.
-#define BOOST_XINT_MAX   0x7FFFFFFFFFFFFFFFi64
-#define BOOST_XINT_MIN   0x8000000000000000i64
-#define BOOST_UXINT_MAX  0xFFFFFFFFFFFFFFFFui64
-#endif
-
-// Types
-typedef          __int64   xint_t;
-typedef unsigned __int64  uxint_t;
-
-// Neither
-#else
-
-// Non-existence
-#define BOOST_HAS_XINT  0
-
-// Dummy extents
-#define BOOST_XINT_MAX    LONG_MAX
-#define BOOST_XINT_MIN    LONG_MIN
-#define BOOST_UXINT_MAX  ULONG_MAX
-
-// Dummy types
-typedef   signed long   xint_t;
-typedef unsigned long  uxint_t;
-
-#endif  // defined(BOOST_HAS_LONG_LONG)/defined(BOOST_HAS_MS_INT64)/else
-
-/** \def  BOOST_HAS_XINT
-
-    \brief  Flag for extended integer types.
-
-    Indicates the presence of one of the two common extended integer type
-    families, either (<code>unsigned</code>) <code>long long</code> or
-    (<code>unsigned</code>) <code>__int64</code>.  \c BOOST_HAS_XINT is \c 1 if
-    either type family is defined, and \c 0 if neither is.
- */
-
-/** \def  BOOST_XINT_MAX
-
-    \brief  Maximum value for the signed extended integer type.
-
-    \pre  \c BOOST_HAS_XINT is \c \#defined to be \c 1.
-
-    Macro constant representing the largest value the signed extended integer
-    type supports.  Its composition may be another macro, an expression, or a
-    literal.  Defaulted to \c LONG_MAX if \c BOOST_HAS_XINT is zero.
- */
-/** \def  BOOST_XINT_MIN
-
-    \brief  Minimum value for the signed extended integer type.
-
-    \pre  \c BOOST_HAS_XINT is \c \#defined to be \c 1.
-
-    Macro constant representing the smallest value the signed extended integer
-    type supports.  Its composition may be another macro, an expression, or a
-    literal.  Defaulted to \c LONG_MIN if \c BOOST_HAS_XINT is zero.
- */
-/** \def  BOOST_UXINT_MAX
-
-    \brief  Maximum value for the unsigned extended integer type.
-
-    \pre  \c BOOST_HAS_XINT is \c \#defined to be \c 1.
-
-    Macro constant representing the largest value the unsigned extended integer
-    type supports.  Its composition may be another macro, an expression, or a
-    literal.  Defaulted to \c ULONG_MAX if \c BOOST_HAS_XINT is zero.  (Use
-    \c 0u for the type's minimum value.)
- */
-
-/** \typedef  signed long  boost::detail::xint_t
-
-    \brief  Alias for the signed extended integer type.
-
-    \pre  \c BOOST_HAS_XINT is \c \#defined to be \c 1.
-
-    Alias representing the signed extended integer type, no matter which type
-    family it came from.  Defaulted to <code>signed long</code> if
-    \c BOOST_HAS_XINT is zero.
- */
-/** \typedef  unsigned long  ::boost::detail::uxint_t
-
-    \brief  Alias for the signed extended integer type.
-
-    \pre  \c BOOST_HAS_XINT is \c \#defined to be \c 1.
-
-    Alias representing the unsigned extended integer type, no matter which type
-    family it came from.  Defaulted to <code>unsigned long</code> if
-    \c BOOST_HAS_XINT is zero.
- */
-
-
-}  // namespace detail
-}  // namespace boost
-
-
-#endif  // BOOST_DETAIL_EXTENDED_INTEGER_HPP

include/boost/integer/static_log2.hpp

@@ -48,7 +48,7 @@ namespace boost {
      template <result_type n>
      struct choose_initial_n {
 
-         enum { c = (argument_type(1) << n << n) != 0 };
+         BOOST_STATIC_CONSTANT(bool, c = (argument_type(1) << n << n) != 0);
          BOOST_STATIC_CONSTANT(
              result_type,
              value = !c*n + choose_initial_n<2*c*n>::value
@@ -85,7 +85,7 @@ namespace boost {
      template <argument_type x, result_type n = initial_n>
      struct static_log2_impl {
 
-         enum { c = (x >> n) > 0 }; // x >= 2**n ?
+         BOOST_STATIC_CONSTANT(bool, c = (x >> n) > 0); // x >= 2**n ?
          BOOST_STATIC_CONSTANT(
              result_type,
              value = c*n + (static_log2_impl< (x>>c*n), n/2 >::value)

integer_test.cpp

@@ -1,291 +0,0 @@
-//  boost integer.hpp test program  ------------------------------------------//
-
-//  Copyright Beman Dawes 1999.  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)
-
-
-//  See http://www.boost.org/libs/integer for documentation.
-
-//  Revision History
-//   04 Oct 01  Added tests for new templates; rewrote code (Daryle Walker)
-//   10 Mar 01  Boost Test Library now used for tests (Beman Dawes)
-//   31 Aug 99  Initial version
-
-#include <boost/test/minimal.hpp>  // for main, BOOST_CHECK
-
-#include <boost/config.hpp>   // for BOOST_NO_USING_TEMPLATE
-#include <boost/cstdlib.hpp>  // for boost::exit_success
-#include <boost/integer.hpp>  // for boost::int_t, boost::uint_t
-
-#include <climits>   // for ULONG_MAX, LONG_MAX, LONG_MIN
-#include <iostream>  // for std::cout (std::endl indirectly)
-#include <typeinfo>  // for std::type_info
-
-
-// Control if the names of the types for each version
-// of the integer templates will be printed.
-#ifndef CONTROL_SHOW_TYPES
-#define CONTROL_SHOW_TYPES  0
-#endif
-
-
-// If specializations have not already been done, then we can confirm
-// the effects of the "fast" types by making a specialization.
-namespace boost
-{
-    template < >
-    struct int_fast_t< short >
-    {
-        typedef long  fast;
-    };
-}
-
-
-// Show the types of an integer template version
-#if CONTROL_SHOW_TYPES
-#define SHOW_TYPE(Template, Number, Type)  ::std::cout << "Type \"" \
- #Template "<" #Number ">::" #Type "\" is \"" << typeid(Template <  \
- Number > :: Type).name() << ".\"\n"
-#else
-#define SHOW_TYPE(Template, Number, Type)
-#endif
-
-#define SHOW_TYPES(Template, Type)  SHOW_TYPE(Template, 32, Type); \
- SHOW_TYPE(Template, 31, Type); SHOW_TYPE(Template, 30, Type); \
- SHOW_TYPE(Template, 29, Type); SHOW_TYPE(Template, 28, Type); \
- SHOW_TYPE(Template, 27, Type); SHOW_TYPE(Template, 26, Type); \
- SHOW_TYPE(Template, 25, Type); SHOW_TYPE(Template, 24, Type); \
- SHOW_TYPE(Template, 23, Type); SHOW_TYPE(Template, 22, Type); \
- SHOW_TYPE(Template, 21, Type); SHOW_TYPE(Template, 20, Type); \
- SHOW_TYPE(Template, 19, Type); SHOW_TYPE(Template, 18, Type); \
- SHOW_TYPE(Template, 17, Type); SHOW_TYPE(Template, 16, Type); \
- SHOW_TYPE(Template, 15, Type); SHOW_TYPE(Template, 14, Type); \
- SHOW_TYPE(Template, 13, Type); SHOW_TYPE(Template, 12, Type); \
- SHOW_TYPE(Template, 11, Type); SHOW_TYPE(Template, 10, Type); \
- SHOW_TYPE(Template, 9, Type); SHOW_TYPE(Template, 8, Type); \
- SHOW_TYPE(Template, 7, Type); SHOW_TYPE(Template, 6, Type); \
- SHOW_TYPE(Template, 5, Type); SHOW_TYPE(Template, 4, Type); \
- SHOW_TYPE(Template, 3, Type); SHOW_TYPE(Template, 2, Type); \
- SHOW_TYPE(Template, 1, Type); SHOW_TYPE(Template, 0, Type)
-
-#define SHOW_SHIFTED_TYPE(Template, Number, Type)  SHOW_TYPE(Template, (1UL << Number), Type)
-
-#define SHOW_SHIFTED_TYPES(Template, Type)  SHOW_SHIFTED_TYPE(Template, 30, Type); \
- SHOW_SHIFTED_TYPE(Template, 29, Type); SHOW_SHIFTED_TYPE(Template, 28, Type); \
- SHOW_SHIFTED_TYPE(Template, 27, Type); SHOW_SHIFTED_TYPE(Template, 26, Type); \
- SHOW_SHIFTED_TYPE(Template, 25, Type); SHOW_SHIFTED_TYPE(Template, 24, Type); \
- SHOW_SHIFTED_TYPE(Template, 23, Type); SHOW_SHIFTED_TYPE(Template, 22, Type); \
- SHOW_SHIFTED_TYPE(Template, 21, Type); SHOW_SHIFTED_TYPE(Template, 20, Type); \
- SHOW_SHIFTED_TYPE(Template, 19, Type); SHOW_SHIFTED_TYPE(Template, 18, Type); \
- SHOW_SHIFTED_TYPE(Template, 17, Type); SHOW_SHIFTED_TYPE(Template, 16, Type); \
- SHOW_SHIFTED_TYPE(Template, 15, Type); SHOW_SHIFTED_TYPE(Template, 14, Type); \
- SHOW_SHIFTED_TYPE(Template, 13, Type); SHOW_SHIFTED_TYPE(Template, 12, Type); \
- SHOW_SHIFTED_TYPE(Template, 11, Type); SHOW_SHIFTED_TYPE(Template, 10, Type); \
- SHOW_SHIFTED_TYPE(Template, 9, Type); SHOW_SHIFTED_TYPE(Template, 8, Type); \
- SHOW_SHIFTED_TYPE(Template, 7, Type); SHOW_SHIFTED_TYPE(Template, 6, Type); \
- SHOW_SHIFTED_TYPE(Template, 5, Type); SHOW_SHIFTED_TYPE(Template, 4, Type); \
- SHOW_SHIFTED_TYPE(Template, 3, Type); SHOW_SHIFTED_TYPE(Template, 2, Type); \
- SHOW_SHIFTED_TYPE(Template, 1, Type); SHOW_SHIFTED_TYPE(Template, 0, Type)
-
-#define SHOW_POS_SHIFTED_TYPE(Template, Number, Type)  SHOW_TYPE(Template, +(1L << Number), Type)
-
-#define SHOW_POS_SHIFTED_TYPES(Template, Type)  SHOW_POS_SHIFTED_TYPE(Template, 30, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 29, Type); SHOW_POS_SHIFTED_TYPE(Template, 28, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 27, Type); SHOW_POS_SHIFTED_TYPE(Template, 26, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 25, Type); SHOW_POS_SHIFTED_TYPE(Template, 24, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 23, Type); SHOW_POS_SHIFTED_TYPE(Template, 22, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 21, Type); SHOW_POS_SHIFTED_TYPE(Template, 20, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 19, Type); SHOW_POS_SHIFTED_TYPE(Template, 18, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 17, Type); SHOW_POS_SHIFTED_TYPE(Template, 16, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 15, Type); SHOW_POS_SHIFTED_TYPE(Template, 14, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 13, Type); SHOW_POS_SHIFTED_TYPE(Template, 12, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 11, Type); SHOW_POS_SHIFTED_TYPE(Template, 10, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 9, Type); SHOW_POS_SHIFTED_TYPE(Template, 8, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 7, Type); SHOW_POS_SHIFTED_TYPE(Template, 6, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 5, Type); SHOW_POS_SHIFTED_TYPE(Template, 4, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 3, Type); SHOW_POS_SHIFTED_TYPE(Template, 2, Type); \
- SHOW_POS_SHIFTED_TYPE(Template, 1, Type); SHOW_POS_SHIFTED_TYPE(Template, 0, Type)
-
-#define SHOW_NEG_SHIFTED_TYPE(Template, Number, Type)  SHOW_TYPE(Template, -(1L << Number), Type)
-
-#define SHOW_NEG_SHIFTED_TYPES(Template, Type)  SHOW_NEG_SHIFTED_TYPE(Template, 30, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 29, Type); SHOW_NEG_SHIFTED_TYPE(Template, 28, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 27, Type); SHOW_NEG_SHIFTED_TYPE(Template, 26, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 25, Type); SHOW_NEG_SHIFTED_TYPE(Template, 24, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 23, Type); SHOW_NEG_SHIFTED_TYPE(Template, 22, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 21, Type); SHOW_NEG_SHIFTED_TYPE(Template, 20, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 19, Type); SHOW_NEG_SHIFTED_TYPE(Template, 18, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 17, Type); SHOW_NEG_SHIFTED_TYPE(Template, 16, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 15, Type); SHOW_NEG_SHIFTED_TYPE(Template, 14, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 13, Type); SHOW_NEG_SHIFTED_TYPE(Template, 12, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 11, Type); SHOW_NEG_SHIFTED_TYPE(Template, 10, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 9, Type); SHOW_NEG_SHIFTED_TYPE(Template, 8, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 7, Type); SHOW_NEG_SHIFTED_TYPE(Template, 6, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 5, Type); SHOW_NEG_SHIFTED_TYPE(Template, 4, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 3, Type); SHOW_NEG_SHIFTED_TYPE(Template, 2, Type); \
- SHOW_NEG_SHIFTED_TYPE(Template, 1, Type); SHOW_NEG_SHIFTED_TYPE(Template, 0, Type)
-
-
-// Test if a constant can fit within a certain type
-#define PRIVATE_FIT_TEST(Template, Number, Type, Value)  BOOST_CHECK( Template < Number > :: Type ( Value ) == Value )
-
-#if ULONG_MAX > 0xFFFFFFFFL
-#define PRIVATE_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
- PRIVATE_FIT_TEST(Template, 64, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 63, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 62, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 61, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 60, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 59, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 58, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 57, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 56, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 55, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 54, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 53, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 52, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 51, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 50, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 49, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 48, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 47, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 46, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 45, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 44, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 43, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 42, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 41, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 40, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 39, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 38, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 37, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 36, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 35, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 34, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 33, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 32, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 31, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 30, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 29, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 28, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 27, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 26, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 25, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 24, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 23, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 22, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 21, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 20, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 19, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 18, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 17, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 16, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 15, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 14, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 13, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 12, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 11, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 10, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 9, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 8, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 7, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 6, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 5, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 4, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 3, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 2, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 1, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 0, Type, v); } while ( false )
-#else
-#define PRIVATE_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
- PRIVATE_FIT_TEST(Template, 32, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 31, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 30, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 29, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 28, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 27, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 26, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 25, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 24, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 23, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 22, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 21, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 20, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 19, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 18, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 17, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 16, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 15, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 14, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 13, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 12, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 11, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 10, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 9, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 8, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 7, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 6, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 5, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 4, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 3, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 2, Type, v); v >>= 1; \
- PRIVATE_FIT_TEST(Template, 1, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 0, Type, v); } while ( false )
-#endif
-
-#define PRIVATE_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_CHECK( Template < (ULONG_MAX >> Number) > :: Type ( Value ) == Value )
-
-#define PRIVATE_SHIFTED_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 0, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 1, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 2, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 3, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 4, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 5, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 6, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 7, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 8, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 9, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 10, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 11, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 12, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 13, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 14, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 15, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 16, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 17, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 18, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 19, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 20, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 21, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 22, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 23, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 24, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 25, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 26, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 27, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 28, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 29, Type, v); v >>= 1; \
- PRIVATE_SHIFTED_FIT_TEST(Template, 30, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 31, Type, v); } while ( false )
-
-#define PRIVATE_POS_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_CHECK( Template < (LONG_MAX >> Number) > :: Type ( Value ) == Value )
-
-#define PRIVATE_POS_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 0, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 1, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 2, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 3, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 4, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 5, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 6, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 7, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 8, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 9, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 10, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 11, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 12, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 13, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 14, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 15, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 16, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 17, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 18, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 19, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 20, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 21, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 22, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 23, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 24, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 25, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 26, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 27, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 28, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 29, Type, v); v >>= 1; \
- PRIVATE_POS_SHIFTED_FIT_TEST(Template, 30, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 31, Type, v); } while ( false )
-
-#define PRIVATE_NEG_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_CHECK( Template < (LONG_MIN >> Number) > :: Type ( Value ) == Value )
-
-#define PRIVATE_NEG_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 0, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 1, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 2, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 3, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 4, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 5, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 6, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 7, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 8, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 9, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 10, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 11, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 12, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 13, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 14, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 15, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 16, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 17, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 18, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 19, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 20, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 21, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 22, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 23, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 24, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 25, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 26, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 27, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 28, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 29, Type, v); v >>= 1; \
- PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 30, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 31, Type, v); } while ( false )
-
-
-// Test program
-int
-test_main
-(
-    int,
-    char*[]
-)
-{
-#ifndef BOOST_NO_USING_TEMPLATE
-    using boost::int_t;
-    using boost::uint_t;
-    using boost::int_max_value_t;
-    using boost::int_min_value_t;
-    using boost::uint_value_t;
-#else
-    using namespace boost;
-#endif
-
-    SHOW_TYPES( int_t, least );
-    SHOW_TYPES( int_t, fast );
-    SHOW_TYPES( uint_t, least );
-    SHOW_TYPES( uint_t, fast );
-    SHOW_POS_SHIFTED_TYPES( int_max_value_t, least );
-    SHOW_POS_SHIFTED_TYPES( int_max_value_t, fast );
-    SHOW_NEG_SHIFTED_TYPES( int_min_value_t, least );
-    SHOW_NEG_SHIFTED_TYPES( int_min_value_t, fast );
-    SHOW_SHIFTED_TYPES( uint_value_t, least );
-    SHOW_SHIFTED_TYPES( uint_value_t, fast );
-     
-    PRIVATE_FIT_TESTS( int_t, least, long, LONG_MAX );
-    PRIVATE_FIT_TESTS( int_t, fast, long, LONG_MAX );
-    PRIVATE_FIT_TESTS( uint_t, least, unsigned long, ULONG_MAX );
-    PRIVATE_FIT_TESTS( uint_t, fast, unsigned long, ULONG_MAX );
-    PRIVATE_POS_FIT_TESTS( int_max_value_t, least, long, LONG_MAX );
-    PRIVATE_POS_FIT_TESTS( int_max_value_t, fast, long, LONG_MAX );
-    PRIVATE_NEG_FIT_TESTS( int_min_value_t, least, long, LONG_MIN );
-    PRIVATE_NEG_FIT_TESTS( int_min_value_t, fast, long, LONG_MIN );
-    PRIVATE_SHIFTED_FIT_TESTS( uint_value_t, least, unsigned long, ULONG_MAX );
-    PRIVATE_SHIFTED_FIT_TESTS( uint_value_t, fast, unsigned long, ULONG_MAX );
-        
-    return boost::exit_success;
-}

integer_traits_test.cpp

@@ -1,102 +0,0 @@
-/* boost integer_traits.hpp tests
- *
- * Copyright Jens Maurer 2000
- * 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
- *  2000-02-22  Small improvements by Beman Dawes
- *  2000-06-27  Rework for better MSVC and BCC co-operation
- */
-
-#include <iostream>
-#include <boost/integer_traits.hpp>
-// use int64_t instead of long long for better portability
-#include <boost/cstdint.hpp>
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-
-/*
- * 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.
- */
-
-#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
-template<typename T> inline T make_char_numeric_for_streaming(T x) { return x; }
-namespace fix{
-inline int make_char_numeric_for_streaming(char c) { return c; }
-inline int make_char_numeric_for_streaming(signed char c) { return c; }
-inline int make_char_numeric_for_streaming(unsigned char c) { return c; }
-}
-using namespace fix;
-#else
-template<typename T> inline T make_char_numeric_for_streaming(T x) { return x; }
-inline int make_char_numeric_for_streaming(char c) { return c; }
-inline int make_char_numeric_for_streaming(signed char c) { return c; }
-inline int make_char_numeric_for_streaming(unsigned char c) { return c; }
-#endif
-
-template<class T>
-void runtest(const char * type, T)
-{
-  typedef boost::integer_traits<T> traits;
-  std::cout << "Checking " << type
-            << "; min is " << make_char_numeric_for_streaming((traits::min)())
-            << ", max is " << make_char_numeric_for_streaming((traits::max)())
-            << std::endl;
-  BOOST_CHECK(traits::is_specialized);
-#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1200)
-  // MSVC++ 6.0 issues a LNK1179 error (duplicate comdat) when the compiler
-  // generates different symbol names with a very long common prefix:
-  // the dummy "&& true" disambiguates between the symbols generated by this
-  // BOOST_CHECK instantiation and the preceding one.
-  BOOST_CHECK(traits::is_integer && true);
-#else
-  BOOST_CHECK(traits::is_integer);
-#endif
-  BOOST_CHECK(traits::is_integral == true);
-  BOOST_CHECK(traits::const_min == (traits::min)());
-  BOOST_CHECK(traits::const_max == (traits::max)());
-}
-
-int test_main(int, char*[])
-{
-  runtest("bool", bool());
-  runtest("char", char());
-  typedef signed char signed_char;
-  runtest("signed char", signed_char());
-  typedef unsigned char unsigned_char;
-  runtest("unsigned char", unsigned_char());
-  runtest("wchar_t", wchar_t());
-  runtest("short", short());
-  typedef unsigned short unsigned_short;
-  runtest("unsigned short", unsigned_short());
-  runtest("int", int());
-  typedef unsigned int unsigned_int;
-  runtest("unsigned int", unsigned_int());
-  runtest("long", long());
-  typedef unsigned long unsigned_long;
-  runtest("unsigned long", unsigned_long());
-#if !defined(BOOST_NO_INT64_T) && (!defined(BOOST_MSVC) || BOOST_MSVC > 1300) && !defined(__BORLANDC__) && !defined(__BEOS__)
-  //
-  // MS/Borland compilers can't support 64-bit member constants
-  // BeOS doesn't have specialisations for long long in SGI's <limits> header.
-  runtest("int64_t (possibly long long)", boost::int64_t());
-  runtest("uint64_t (possibly unsigned long long)", boost::uint64_t());
-#else
-  std::cout << "Skipped int64_t and uint64_t" << std::endl;
-#endif
-  // Some compilers don't pay attention to std:3.6.1/5 and issue a
-  // warning here if "return 0;" is omitted.
-  return 0;
-}
-

test/Jamfile.v2

@@ -16,5 +16,5 @@ test-suite integer
             /boost/test//boost_test_exec_monitor/<link>static ]
         [ run static_min_max_test.cpp
             /boost/test//boost_test_exec_monitor/<link>static ]
-        [ compile issue_2134.cpp ]
+#        [ compile issue_2134.cpp ]
     ;

test/integer_mask_test.cpp

@@ -10,8 +10,7 @@
 //  Revision History
 //  23 Sep 2001  Initial version (Daryle Walker)
 
-#define  BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>  // for main
+#include <boost/test/minimal.hpp>  // for main
 
 #include <boost/cstdlib.hpp>               // for boost::exit_success
 #include <boost/integer/integer_mask.hpp>  // for boost::high_bit_mask_t, etc.

test/integer_test.cpp

@@ -4,69 +4,24 @@
 //  Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+
 //  See http://www.boost.org/libs/integer for documentation.
 
 //  Revision History
-//   16 Jul 08  Added MPL-compatible variants of the minimum-size and value-
-//              based integer templates. (Daryle Walker)
-//   15 Jul 08  Added exact-integer templates; added MPL-compatible variant of
-//              processor-optimized integer template. (Daryle Walker)
-//   14 Jul 08  Improved testing of processor-optimized integer template; added
-//              extended-integer support. (Daryle Walker)
-//   13 Jul 08  Modernized tests w/ MPL instead of giant macros (Daryle Walker)
-//   07 Jul 08  Changed tests to use the unit-test system (Daryle Walker)
 //   04 Oct 01  Added tests for new templates; rewrote code (Daryle Walker)
 //   10 Mar 01  Boost Test Library now used for tests (Beman Dawes)
 //   31 Aug 99  Initial version
 
-#define BOOST_TEST_MODULE  "Integer size-selection tests"
+#include <boost/test/minimal.hpp>  // for main, BOOST_CHECK
 
-#include <boost/test/unit_test.hpp>  // unit testing framework
+#include <boost/config.hpp>   // for BOOST_NO_USING_TEMPLATE
+#include <boost/cstdlib.hpp>  // for boost::exit_success
+#include <boost/integer.hpp>  // for boost::int_t, boost::uint_t
 
-#include <boost/config.hpp>          // for BOOST_NO_SFINAE
-#include <boost/cstdint.hpp>         // for boost::uintmax_t, intmax_t
-#include <boost/integer.hpp>         // for boost::int_t, boost::uint_t, etc.
-#include <boost/integer_traits.hpp>  // for boost::integer_traits
-#include <boost/limits.hpp>          // for std::numeric_limits
+#include <climits>   // for ULONG_MAX, LONG_MAX, LONG_MIN
+#include <iostream>  // for std::cout (std::endl indirectly)
+#include <typeinfo>  // for std::type_info
 
-#include <boost/detail/extended_integer.hpp>  // BOOST_HAS_XINT, BOOST_UXINT_MAX
-
-#include <boost/mpl/arithmetic.hpp>      // for boost::mpl::plus, divides
-#include <boost/mpl/assert.hpp>          // for BOOST_MPL_ASSERT_RELATION, etc.
-#include <boost/mpl/back.hpp>            // for boost::mpl::back
-#include <boost/mpl/copy.hpp>            // for boost::mpl::copy
-#include <boost/mpl/equal.hpp>           // for boost::mpl::equal
-#include <boost/mpl/front_inserter.hpp>  // for boost::mpl::front_inserter
-#include <boost/mpl/int.hpp>             // for boost::mpl::int_
-#include <boost/mpl/integral_c.hpp>      // for boost::mpl::integral_c
-#include <boost/mpl/joint_view.hpp>      // for boost::mpl::joint_view
-#include <boost/mpl/pop_back.hpp>        // for boost::mpl::pop_back
-#include <boost/mpl/push_back.hpp>       // for boost::mpl::push_back 
-#include <boost/mpl/push_front.hpp>      // for boost::mpl::push_front
-#include <boost/mpl/range_c.hpp>         // for boost::mpl::range_c
-#include <boost/mpl/shift_right.hpp>     // for boost::mpl::shift_right
-#include <boost/mpl/sort.hpp>            // for boost::mpl::sort
-#include <boost/mpl/transform.hpp>       // for boost::mpl::transform
-#include <boost/mpl/transform_view.hpp>  // for boost::mpl::transform_view
-#include <boost/mpl/unpack_args.hpp>     // for boost::mpl::unpack_args
-#include <boost/mpl/vector.hpp>          // for boost::mpl::vector
-#include <boost/mpl/zip_view.hpp>        // for boost::mpl::zip_view
-
-#include <boost/type_traits/is_same.hpp>      // for boost::is_same
-#include <boost/type_traits/make_signed.hpp>  // for boost::make_signed
-
-#include <algorithm>  // for std::binary_search
-#include <climits>    // for ULONG_MAX, LONG_MAX, LONG_MIN, etc.
-#include <cstddef>    // for std::size_t
-#include <iostream>   // for std::cout
-#include <ostream>    // for std::endl
-#include <typeinfo>   // for std::type_info
-
-
-// Control what the "fast" specialization of "short" is
-#ifndef CONTROL_FAST_SHORT
-#define CONTROL_FAST_SHORT  long
-#endif
 
 // Control if the names of the types for each version
 // of the integer templates will be printed.
@@ -74,612 +29,263 @@
 #define CONTROL_SHOW_TYPES  0
 #endif
 
-// Control if every potential bit-count is used, or only a selection
-// For me, full counts increase compile time from 90 seconds to 20 minutes!
-#ifndef CONTROL_FULL_COUNTS
-#define CONTROL_FULL_COUNTS  1
-#endif
-
 
 // If specializations have not already been done, then we can confirm
-// the effects of the fast types by making a specialization.  If there
-// is a specialization for "short," make sure that CONTROL_FAST_SHORT
-// is set to a type distinct from "short" and the default implementation.
+// the effects of the "fast" types by making a specialization.
 namespace boost
 {
     template < >
-    struct fast_integral< short >
+    struct int_fast_t< short >
     {
-        typedef CONTROL_FAST_SHORT  type;
+        typedef long  fast;
     };
 }
 
 
-// Logging
+// Show the types of an integer template version
 #if CONTROL_SHOW_TYPES
-#define PRIVATE_SHOW_MESSAGE( m )  std::cout << m << std::endl
+#define SHOW_TYPE(Template, Number, Type)  ::std::cout << "Type \"" \
+ #Template "<" #Number ">::" #Type "\" is \"" << typeid(Template <  \
+ Number > :: Type).name() << ".\"\n"
 #else
-#define PRIVATE_SHOW_MESSAGE( m )  BOOST_TEST_MESSAGE( m )
+#define SHOW_TYPE(Template, Number, Type)
 #endif
 
+#define SHOW_TYPES(Template, Type)  SHOW_TYPE(Template, 32, Type); \
+ SHOW_TYPE(Template, 31, Type); SHOW_TYPE(Template, 30, Type); \
+ SHOW_TYPE(Template, 29, Type); SHOW_TYPE(Template, 28, Type); \
+ SHOW_TYPE(Template, 27, Type); SHOW_TYPE(Template, 26, Type); \
+ SHOW_TYPE(Template, 25, Type); SHOW_TYPE(Template, 24, Type); \
+ SHOW_TYPE(Template, 23, Type); SHOW_TYPE(Template, 22, Type); \
+ SHOW_TYPE(Template, 21, Type); SHOW_TYPE(Template, 20, Type); \
+ SHOW_TYPE(Template, 19, Type); SHOW_TYPE(Template, 18, Type); \
+ SHOW_TYPE(Template, 17, Type); SHOW_TYPE(Template, 16, Type); \
+ SHOW_TYPE(Template, 15, Type); SHOW_TYPE(Template, 14, Type); \
+ SHOW_TYPE(Template, 13, Type); SHOW_TYPE(Template, 12, Type); \
+ SHOW_TYPE(Template, 11, Type); SHOW_TYPE(Template, 10, Type); \
+ SHOW_TYPE(Template, 9, Type); SHOW_TYPE(Template, 8, Type); \
+ SHOW_TYPE(Template, 7, Type); SHOW_TYPE(Template, 6, Type); \
+ SHOW_TYPE(Template, 5, Type); SHOW_TYPE(Template, 4, Type); \
+ SHOW_TYPE(Template, 3, Type); SHOW_TYPE(Template, 2, Type); \
+ SHOW_TYPE(Template, 1, Type); SHOW_TYPE(Template, 0, Type)
 
-// Custom types/templates, helper functions, and objects
-namespace
-{
+#define SHOW_SHIFTED_TYPE(Template, Number, Type)  SHOW_TYPE(Template, (1UL << Number), Type)
 
-// List the built-in integral types, excluding the ones that are strong-typedefs
-// of a lower type.
-typedef boost::mpl::vector<
-    unsigned char
-#if USHRT_MAX > UCHAR_MAX
-    , unsigned short
-#endif
-#if UINT_MAX > USHRT_MAX
-    , unsigned int
-#endif
-#if ULONG_MAX > UINT_MAX
-    , unsigned long
-#endif
-#if BOOST_HAS_XINT && (BOOST_UXINT_MAX > ULONG_MAX)
-    , boost::detail::uxint_t
-#endif
->  distinct_unsigned_types;
+#define SHOW_SHIFTED_TYPES(Template, Type)  SHOW_SHIFTED_TYPE(Template, 30, Type); \
+ SHOW_SHIFTED_TYPE(Template, 29, Type); SHOW_SHIFTED_TYPE(Template, 28, Type); \
+ SHOW_SHIFTED_TYPE(Template, 27, Type); SHOW_SHIFTED_TYPE(Template, 26, Type); \
+ SHOW_SHIFTED_TYPE(Template, 25, Type); SHOW_SHIFTED_TYPE(Template, 24, Type); \
+ SHOW_SHIFTED_TYPE(Template, 23, Type); SHOW_SHIFTED_TYPE(Template, 22, Type); \
+ SHOW_SHIFTED_TYPE(Template, 21, Type); SHOW_SHIFTED_TYPE(Template, 20, Type); \
+ SHOW_SHIFTED_TYPE(Template, 19, Type); SHOW_SHIFTED_TYPE(Template, 18, Type); \
+ SHOW_SHIFTED_TYPE(Template, 17, Type); SHOW_SHIFTED_TYPE(Template, 16, Type); \
+ SHOW_SHIFTED_TYPE(Template, 15, Type); SHOW_SHIFTED_TYPE(Template, 14, Type); \
+ SHOW_SHIFTED_TYPE(Template, 13, Type); SHOW_SHIFTED_TYPE(Template, 12, Type); \
+ SHOW_SHIFTED_TYPE(Template, 11, Type); SHOW_SHIFTED_TYPE(Template, 10, Type); \
+ SHOW_SHIFTED_TYPE(Template, 9, Type); SHOW_SHIFTED_TYPE(Template, 8, Type); \
+ SHOW_SHIFTED_TYPE(Template, 7, Type); SHOW_SHIFTED_TYPE(Template, 6, Type); \
+ SHOW_SHIFTED_TYPE(Template, 5, Type); SHOW_SHIFTED_TYPE(Template, 4, Type); \
+ SHOW_SHIFTED_TYPE(Template, 3, Type); SHOW_SHIFTED_TYPE(Template, 2, Type); \
+ SHOW_SHIFTED_TYPE(Template, 1, Type); SHOW_SHIFTED_TYPE(Template, 0, Type)
 
-typedef boost::mpl::transform<
-    distinct_unsigned_types,
-    boost::make_signed< boost::mpl::_1 >
->::type  distinct_signed_types;
+#define SHOW_POS_SHIFTED_TYPE(Template, Number, Type)  SHOW_TYPE(Template, +(1L << Number), Type)
 
-// List the digit counts for each integral type
-template < typename T >
-struct digits_of
-    : boost::mpl::int_< std::numeric_limits<T>::digits >
-{
-};
+#define SHOW_POS_SHIFTED_TYPES(Template, Type)  SHOW_POS_SHIFTED_TYPE(Template, 30, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 29, Type); SHOW_POS_SHIFTED_TYPE(Template, 28, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 27, Type); SHOW_POS_SHIFTED_TYPE(Template, 26, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 25, Type); SHOW_POS_SHIFTED_TYPE(Template, 24, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 23, Type); SHOW_POS_SHIFTED_TYPE(Template, 22, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 21, Type); SHOW_POS_SHIFTED_TYPE(Template, 20, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 19, Type); SHOW_POS_SHIFTED_TYPE(Template, 18, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 17, Type); SHOW_POS_SHIFTED_TYPE(Template, 16, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 15, Type); SHOW_POS_SHIFTED_TYPE(Template, 14, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 13, Type); SHOW_POS_SHIFTED_TYPE(Template, 12, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 11, Type); SHOW_POS_SHIFTED_TYPE(Template, 10, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 9, Type); SHOW_POS_SHIFTED_TYPE(Template, 8, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 7, Type); SHOW_POS_SHIFTED_TYPE(Template, 6, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 5, Type); SHOW_POS_SHIFTED_TYPE(Template, 4, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 3, Type); SHOW_POS_SHIFTED_TYPE(Template, 2, Type); \
+ SHOW_POS_SHIFTED_TYPE(Template, 1, Type); SHOW_POS_SHIFTED_TYPE(Template, 0, Type)
 
-typedef boost::mpl::transform<
-    distinct_unsigned_types,
-    digits_of< boost::mpl::_1 >
->::type  distinct_integral_bit_counts;
+#define SHOW_NEG_SHIFTED_TYPE(Template, Number, Type)  SHOW_TYPE(Template, -(1L << Number), Type)
 
-// Make list of bit counts between each offical point, plus CHAR_BIT/2
-typedef boost::mpl::transform_view<
-    boost::mpl::zip_view<
-        boost::mpl::vector<
-            boost::mpl::push_front<
-                boost::mpl::pop_back< distinct_integral_bit_counts >::type,
-                boost::mpl::integral_c< int, 0 >
-            >::type,
-            distinct_integral_bit_counts
-        >
-    >,
-    boost::mpl::unpack_args<
-        boost::mpl::divides<
-            boost::mpl::plus< boost::mpl::_1, boost::mpl::_2 >,
-            boost::mpl::integral_c< int, 2 >
-        >
-    >
->  median_bit_counts;
+#define SHOW_NEG_SHIFTED_TYPES(Template, Type)  SHOW_NEG_SHIFTED_TYPE(Template, 30, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 29, Type); SHOW_NEG_SHIFTED_TYPE(Template, 28, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 27, Type); SHOW_NEG_SHIFTED_TYPE(Template, 26, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 25, Type); SHOW_NEG_SHIFTED_TYPE(Template, 24, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 23, Type); SHOW_NEG_SHIFTED_TYPE(Template, 22, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 21, Type); SHOW_NEG_SHIFTED_TYPE(Template, 20, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 19, Type); SHOW_NEG_SHIFTED_TYPE(Template, 18, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 17, Type); SHOW_NEG_SHIFTED_TYPE(Template, 16, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 15, Type); SHOW_NEG_SHIFTED_TYPE(Template, 14, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 13, Type); SHOW_NEG_SHIFTED_TYPE(Template, 12, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 11, Type); SHOW_NEG_SHIFTED_TYPE(Template, 10, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 9, Type); SHOW_NEG_SHIFTED_TYPE(Template, 8, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 7, Type); SHOW_NEG_SHIFTED_TYPE(Template, 6, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 5, Type); SHOW_NEG_SHIFTED_TYPE(Template, 4, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 3, Type); SHOW_NEG_SHIFTED_TYPE(Template, 2, Type); \
+ SHOW_NEG_SHIFTED_TYPE(Template, 1, Type); SHOW_NEG_SHIFTED_TYPE(Template, 0, Type)
 
-// Maximum number of bits allowed
-typedef std::numeric_limits<boost:: intmax_t>   intmax_limits;
-typedef std::numeric_limits<boost::uintmax_t>  uintmax_limits;
 
-int const   intmax_bits =  intmax_limits::digits + 1;
-int const  uintmax_bits = uintmax_limits::digits;
+// Test if a constant can fit within a certain type
+#define PRIVATE_FIT_TEST(Template, Number, Type, Value)  BOOST_CHECK( Template < Number > :: Type ( Value ) == Value )
 
-// Make master lists including an outlier beyond all valid bit counts
-#if CONTROL_FULL_COUNTS
-typedef boost::mpl::range_c<int, 0, uintmax_bits + 2>  bits_list;
+#if ULONG_MAX > 0xFFFFFFFFL
+#define PRIVATE_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
+ PRIVATE_FIT_TEST(Template, 64, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 63, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 62, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 61, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 60, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 59, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 58, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 57, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 56, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 55, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 54, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 53, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 52, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 51, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 50, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 49, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 48, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 47, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 46, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 45, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 44, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 43, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 42, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 41, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 40, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 39, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 38, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 37, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 36, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 35, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 34, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 33, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 32, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 31, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 30, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 29, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 28, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 27, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 26, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 25, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 24, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 23, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 22, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 21, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 20, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 19, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 18, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 17, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 16, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 15, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 14, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 13, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 12, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 11, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 10, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 9, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 8, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 7, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 6, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 5, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 4, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 3, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 2, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 1, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 0, Type, v); } while ( false )
 #else
-typedef boost::mpl::sort<
-    boost::mpl::copy<
-        boost::mpl::joint_view<
-            distinct_integral_bit_counts,
-            median_bit_counts
-        >,
-        boost::mpl::front_inserter<
-            boost::mpl::vector<
-                boost::mpl::integral_c<int, uintmax_bits + 1>
-            >
-        >
-    >::type
->::type  bits_list;
+#define PRIVATE_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
+ PRIVATE_FIT_TEST(Template, 32, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 31, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 30, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 29, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 28, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 27, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 26, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 25, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 24, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 23, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 22, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 21, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 20, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 19, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 18, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 17, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 16, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 15, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 14, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 13, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 12, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 11, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 10, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 9, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 8, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 7, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 6, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 5, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 4, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 3, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 2, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 1, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 0, Type, v); } while ( false )
 #endif
 
-// Remove the outlier when all bits counts must be valid
-#if CONTROL_FULL_COUNTS
-typedef boost::mpl::range_c<int, 0, uintmax_bits + 1>  valid_bits_list;
+#define PRIVATE_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_CHECK( Template < (ULONG_MAX >> Number) > :: Type ( Value ) == Value )
+
+#define PRIVATE_SHIFTED_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 0, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 1, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 2, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 3, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 4, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 5, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 6, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 7, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 8, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 9, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 10, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 11, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 12, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 13, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 14, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 15, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 16, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 17, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 18, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 19, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 20, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 21, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 22, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 23, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 24, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 25, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 26, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 27, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 28, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 29, Type, v); v >>= 1; \
+ PRIVATE_SHIFTED_FIT_TEST(Template, 30, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 31, Type, v); } while ( false )
+
+#define PRIVATE_POS_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_CHECK( Template < (LONG_MAX >> Number) > :: Type ( Value ) == Value )
+
+#define PRIVATE_POS_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 0, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 1, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 2, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 3, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 4, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 5, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 6, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 7, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 8, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 9, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 10, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 11, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 12, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 13, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 14, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 15, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 16, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 17, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 18, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 19, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 20, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 21, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 22, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 23, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 24, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 25, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 26, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 27, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 28, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 29, Type, v); v >>= 1; \
+ PRIVATE_POS_SHIFTED_FIT_TEST(Template, 30, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 31, Type, v); } while ( false )
+
+#define PRIVATE_NEG_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_CHECK( Template < (LONG_MIN >> Number) > :: Type ( Value ) == Value )
+
+#define PRIVATE_NEG_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 0, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 1, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 2, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 3, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 4, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 5, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 6, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 7, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 8, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 9, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 10, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 11, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 12, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 13, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 14, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 15, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 16, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 17, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 18, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 19, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 20, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 21, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 22, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 23, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 24, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 25, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 26, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 27, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 28, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 29, Type, v); v >>= 1; \
+ PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 30, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 31, Type, v); } while ( false )
+
+
+// Test program
+int
+test_main
+(
+    int,
+    char*[]
+)
+{
+#ifndef BOOST_NO_USING_TEMPLATE
+    using boost::int_t;
+    using boost::uint_t;
+    using boost::int_max_value_t;
+    using boost::int_min_value_t;
+    using boost::uint_value_t;
 #else
-typedef boost::mpl::pop_back<bits_list>::type  valid_bits_list;
+    using namespace boost;
 #endif
 
-// Replace the minimum bit count with one more, so right-shifting by a stored
-// value doesn't give an invalid result
-#if CONTROL_FULL_COUNTS
-typedef boost::mpl::range_c<int, 1, uintmax_bits + 1>
-  valid_to_decrease_bits_list;
-#else
-typedef valid_bits_list  valid_to_decrease_bits_list;
-#endif
-
-// Replace the maximum bit count with one less, so left-shifting by a stored
-// value doesn't give an invalid result
-#if CONTROL_FULL_COUNTS
-typedef boost::mpl::range_c<int, 0, uintmax_bits>  valid_to_increase_ubits_list;
-#else
-typedef boost::mpl::push_back<
-    boost::mpl::pop_back< valid_bits_list >::type,
-    boost::mpl::integral_c< int, uintmax_bits - 1 >
->::type  valid_to_increase_ubits_list;
-#endif
-
-// Do it again for signed types since they have one-less bit to use for the
-// mantissa (don't want to shift into the sign bit)
-#if CONTROL_FULL_COUNTS
-typedef boost::mpl::range_c<int, 0, intmax_bits - 2>
-  valid_to_increase_sbits_list;
-#else
-typedef boost::mpl::push_back<
-    boost::mpl::pop_back< valid_bits_list >::type,
-    boost::mpl::integral_c< int, intmax_bits - 3 >
->::type  valid_to_increase_sbits_list;
-#endif
-
-// List the digit counts for each integral type, this time as an object, an
-// array working as a sorted list
-int const  integral_bit_lengths[] = {
-    std::numeric_limits< unsigned char >::digits
-#if USHRT_MAX > UCHAR_MAX
-    , std::numeric_limits< unsigned short >::digits
-#endif
-#if UINT_MAX > USHRT_MAX
-    , std::numeric_limits< unsigned int >::digits
-#endif
-#if ULONG_MAX > UINT_MAX
-    , std::numeric_limits< unsigned long >::digits
-#endif
-#if BOOST_HAS_XINT && (BOOST_UXINT_MAX > ULONG_MAX)
-    , std::numeric_limits< boost::detail::uxint_t >::digits
-#endif
-};
-
-std::size_t const  integral_type_count = sizeof(integral_bit_lengths) /
- sizeof(integral_bit_lengths[0]);
-
-// "Template-typedefs" to reduce two-argument templates to single-argument.
-// This way, all the MPL-compatible templates have the same form, for below.
-template < int Bits >
-struct signed_sized_integral  : boost::sized_integral<Bits, signed>  {};
-
-template < int Bits >
-struct unsigned_sized_integral  : boost::sized_integral<Bits, unsigned>  {};
-
-template < int Bits >
-struct signed_exact_integral  : boost::exact_integral<Bits, signed>  {};
-
-template < int Bits >
-struct unsigned_exact_integral  : boost::exact_integral<Bits, unsigned>  {};
-
-// Use SFINAE to check if a particular parameter is supported
-#ifndef BOOST_NO_SFINAE
-template < typename ValueT, template<ValueT> class Tmpl, ValueT Value >
-bool
-print_out_template( Tmpl<Value> const &, ValueT setting, char const
- *template_pre_name, char const *template_post_name, typename Tmpl<Value>::type
- *unused = 0 )
-{
-    // Too bad the type-id expression couldn't use the compact form "*unused",
-    // but type-ids of dereferenced null pointers throw by order of C++ 2003,
-    // sect. 5.2.8, para. 2 (although the result is not conceptually needed).
-    PRIVATE_SHOW_MESSAGE( "This is " << template_pre_name << setting
-     << template_post_name << " specialization, with type '" << typeid(typename
-     Tmpl<Value>::type).name() << "'." );
-    return true;
+    SHOW_TYPES( int_t, least );
+    SHOW_TYPES( int_t, fast );
+    SHOW_TYPES( uint_t, least );
+    SHOW_TYPES( uint_t, fast );
+    SHOW_POS_SHIFTED_TYPES( int_max_value_t, least );
+    SHOW_POS_SHIFTED_TYPES( int_max_value_t, fast );
+    SHOW_NEG_SHIFTED_TYPES( int_min_value_t, least );
+    SHOW_NEG_SHIFTED_TYPES( int_min_value_t, fast );
+    SHOW_SHIFTED_TYPES( uint_value_t, least );
+    SHOW_SHIFTED_TYPES( uint_value_t, fast );
+     
+    PRIVATE_FIT_TESTS( int_t, least, long, LONG_MAX );
+    PRIVATE_FIT_TESTS( int_t, fast, long, LONG_MAX );
+    PRIVATE_FIT_TESTS( uint_t, least, unsigned long, ULONG_MAX );
+    PRIVATE_FIT_TESTS( uint_t, fast, unsigned long, ULONG_MAX );
+    PRIVATE_POS_FIT_TESTS( int_max_value_t, least, long, LONG_MAX );
+    PRIVATE_POS_FIT_TESTS( int_max_value_t, fast, long, LONG_MAX );
+    PRIVATE_NEG_FIT_TESTS( int_min_value_t, least, long, LONG_MIN );
+    PRIVATE_NEG_FIT_TESTS( int_min_value_t, fast, long, LONG_MIN );
+    PRIVATE_SHIFTED_FIT_TESTS( uint_value_t, least, unsigned long, ULONG_MAX );
+    PRIVATE_SHIFTED_FIT_TESTS( uint_value_t, fast, unsigned long, ULONG_MAX );
+        
+    return boost::exit_success;
 }
-
-template < typename ValueT, typename T >
-bool
-print_out_template( T const &, ValueT setting, char const *template_pre_name,
- char const *template_post_name )
-{
-    PRIVATE_SHOW_MESSAGE( "Looking for " << template_pre_name << setting
-     << template_post_name << " specialization?  It doesn't exist." );
-    return false;
-}
-#else
-#error "These tests cannot work without Substitution-Failure-Is-Not-An-Error"
-#endif
-
-// Get the extreme values for each integral type
-template < typename T >
-struct minimum_of
-    : boost::mpl::integral_c< T, boost::integer_traits<T>::const_min >
-{
-};
-
-template < typename T >
-struct maximum_of
-    : boost::mpl::integral_c< T, boost::integer_traits<T>::const_max >
-{
-};
-
-}  // unnamed namespace
-
-
-// Check the processor-optimzed type system
-BOOST_AUTO_TEST_SUITE( optimized_type_tests )
-
-// Check the optimzed type override of a given type
-BOOST_AUTO_TEST_CASE( fast_type_test )
-{
-    typedef short                               least_type;
-    typedef boost::int_fast_t<least_type>::fast  fast_type;
-    typedef std::numeric_limits<least_type>     least_limits;
-    typedef std::numeric_limits<fast_type>       fast_limits;
-
-    typedef boost::fast_integral<least_type>::type  real_fast_type;
-
-    BOOST_MPL_ASSERT_RELATION( (boost::is_same<least_type, fast_type>::value),
-     ==, false );
-    BOOST_MPL_ASSERT_RELATION( (boost::is_same<fast_type,
-     real_fast_type>::value), ==, true );
-    BOOST_MPL_ASSERT_RELATION( fast_limits::is_specialized, ==, true );
-    BOOST_MPL_ASSERT_RELATION( fast_limits::is_signed &&
-     fast_limits::is_bounded, ==, true );
-    BOOST_MPL_ASSERT_RELATION( fast_limits::radix, ==, 2 );
-    BOOST_MPL_ASSERT_RELATION( fast_limits::digits, >=, least_limits::digits );
-}
-
-BOOST_AUTO_TEST_SUITE_END()
-
-// Check if given types can support given size parameters
-BOOST_AUTO_TEST_SUITE( show_type_tests )
-
-// Check the specialization type status of given bit lengths, minimum
-BOOST_AUTO_TEST_CASE_TEMPLATE( show_types_for_lengths_test, T, bits_list )
-{
-    BOOST_CHECK_EQUAL( print_out_template(signed_sized_integral<T::value>(),
-     T::value, "a sized_integral<", ", signed>"), T::value && (T::value <=
-     intmax_bits) );
-    BOOST_CHECK_EQUAL( print_out_template(unsigned_sized_integral<T::value>(),
-     T::value, "a sized_integral<", ", unsigned>"), T::value <= uintmax_bits );
-}
-
-// Check the classic specialization type status of given bit lengths, minimum,
-// unsigned
-BOOST_AUTO_TEST_CASE_TEMPLATE( show_types_for_classic_lengths_unsigned_test, T,
- valid_bits_list )
-{
-    // This test is supposed to replace the following printouts given in
-    // puesdo-code by:
-    // Routine: Template, Type
-    //  for N := 32 downto 0
-    //      cout << "Type '" << Template << "<" N << ">::" << Type << "' is '"
-    //      << typeid(Template<N>::Type).name << ".'\n"
-    //  end for
-    // end Routine
-    // with Template = {int_t, uint_t}; Type = {least, fast}
-    // But now we'll use template meta-programming instead of macros.  The limit
-    // of type-lists is usually less than 32 (not to mention 64) elements, so we
-    // have to take selected values.  The only interesting part is if the bit
-    // count is too large, and we can't check that yet.
-    BOOST_MPL_ASSERT_RELATION( std::numeric_limits<typename
-     boost::uint_t<T::value>::least>::digits, >=, T::value );
-    BOOST_MPL_ASSERT_RELATION( std::numeric_limits<typename
-     boost::uint_t<T::value>::fast>::digits, >=, T::value );
-}
-
-// Check the classic specialization type status of given bit lengths, minimum,
-// signed
-BOOST_AUTO_TEST_CASE_TEMPLATE( show_types_for_classic_lengths_signed_test, T,
- valid_to_decrease_bits_list )
-{
-    BOOST_MPL_ASSERT_RELATION( std::numeric_limits<typename
-     boost::int_t<T::value>::least>::digits, >=, T::value - 1 );
-    BOOST_MPL_ASSERT_RELATION( std::numeric_limits<typename
-     boost::int_t<T::value>::fast>::digits, >=, T::value - 1 );
-}
-
-// Check size comparisons of given value support, unsigned
-BOOST_AUTO_TEST_CASE_TEMPLATE( show_types_for_shifted_unsigned_values_test, T,
- valid_to_increase_ubits_list )
-{
-    // This test is supposed to replace the following printouts given in
-    // puesdo-code by:
-    // Routine: Type
-    //  for N := 30 downto 0
-    //      cout << "Type '" << uint_value_t << "<" (1ul << N) << ">::" << Type
-    //       << "' is '"<< typeid(uint_value_t<(1ul << N)>::Type).name << ".'\n"
-    //  end for
-    // end Routine
-    // with Type = {least, fast}
-    // But now we'll use template meta-programming instead of macros.  The limit
-    // of type-lists is usually less than 32 (not to mention 64) elements, so we
-    // have to take selected values.  The interesting parts are where N is the
-    // length of a integral type, so 1 << N would have to fit in the next larger
-    // type.  (This is why N can't be more than bitlength(uintmax_t) - 1.)
-    boost::uintmax_t const  one = 1u;
-
-    BOOST_MPL_ASSERT( (boost::mpl::equal< boost::maximum_unsigned_integral<(one
-     << T::value)>, unsigned_sized_integral<T::value + 1> >) );
-}
-
-// Check size comparisons of given value support, signed
-BOOST_AUTO_TEST_CASE_TEMPLATE( show_types_for_shifted_signed_values_test, T,
- valid_to_increase_sbits_list )
-{
-    // This test is supposed to replace the following printouts given in
-    // puesdo-code by:
-    // Routine: Type
-    //  for N := 30 downto 0
-    //      cout << "Type '" << int_max_value_t << "<" +(1ul << N) << ">::" <<
-    //       Type << "' is '" << typeid(int_max_value_t<+(1ul << N)>::Type).name
-    //       << ".'\n"
-    //      cout << "Type '" << int_min_value_t << "<" -(1ul << N) << ">::" <<
-    //       Type << "' is '" << typeid(int_min_value_t<-(1ul << N)>::Type).name
-    //       << ".'\n"
-    //  end for
-    // end Routine
-    // with Type = {least, fast}
-    // But now we'll use template meta-programming instead of macros.  The limit
-    // of type-lists is usually less than 32 (not to mention 64) elements, so we
-    // have to take selected values.  The interesting parts are where N is the
-    // length of a integral type, so 1 << N would have to fit in the next larger
-    // type.  (This is why N can't be more than bitlength(intmax_t) - 1.  Note
-    // that bitlength(intmax_t) + 1 == bitlength(uintmax_t).)
-    static  boost::intmax_t const  one = 1;
-
-    BOOST_MPL_ASSERT( (boost::mpl::equal< boost::maximum_signed_integral<+(one
-     << T::value)>, signed_sized_integral<T::value + 1> >) );
-    BOOST_MPL_ASSERT( (boost::mpl::equal< boost::minimum_signed_integral<-(one
-     << T::value)>, signed_sized_integral<T::value + 1> >) );
-}
-
-// Check the specialization type status of given bit lengths, exact only
-BOOST_AUTO_TEST_CASE_TEMPLATE( show_types_for_exact_lengths_test, T, bits_list )
-{
-    bool const  is_exact_length = std::binary_search( integral_bit_lengths,
-     integral_bit_lengths + integral_type_count, T::value );
-
-    BOOST_CHECK_EQUAL( print_out_template(signed_exact_integral<T::value>(),
-     T::value, "an exact_integral<", ", signed>"), is_exact_length );
-    BOOST_CHECK_EQUAL( print_out_template(unsigned_exact_integral<T::value>(),
-     T::value, "an exact_integral<", ", unsigned>"), is_exact_length );
-}
-
-// Check the classic specialization type status of given bit lengths, exact only
-BOOST_AUTO_TEST_CASE_TEMPLATE( show_types_for_classic_exact_lengths_test, T,
- distinct_integral_bit_counts )
-{
-    BOOST_MPL_ASSERT_RELATION( std::numeric_limits<typename
-     boost::int_exact_t<T::value>::exact>::digits, ==, T::value - 1 );
-    BOOST_MPL_ASSERT_RELATION( std::numeric_limits<typename
-     boost::uint_exact_t<T::value>::exact>::digits, ==, T::value );
-}
-
-// Check if MPL-compatible templates give bad returns for out-of-range values
-BOOST_AUTO_TEST_CASE( show_not_type_for_parameter_test )
-{
-    typedef signed_sized_integral< 3>   ssz3_type;
-    typedef signed_sized_integral< 0>   ssz0_type;
-    typedef signed_sized_integral<-3>  ssz3n_type;
-
-    BOOST_CHECK(  print_out_template(ssz3_type(), ssz3_type::bit_count,
-     "a sized_integral<", ", signed>") );
-    BOOST_CHECK( !print_out_template(ssz0_type(), ssz0_type::bit_count,
-     "a sized_integral<", ", signed>") );
-    BOOST_CHECK( !print_out_template(ssz3n_type(), ssz3n_type::bit_count,
-     "a sized_integral<", ", signed>") );
-
-    typedef unsigned_sized_integral< 3>   usz3_type;
-    typedef unsigned_sized_integral< 0>   usz0_type;
-    typedef unsigned_sized_integral<-3>  usz3n_type;
-
-    BOOST_CHECK(  print_out_template(usz3_type(), usz3_type::bit_count,
-     "a sized_integral<", ", unsigned>") );
-    BOOST_CHECK(  print_out_template(usz0_type(), usz0_type::bit_count,
-     "a sized_integral<", ", unsigned>") );
-    BOOST_CHECK( !print_out_template(usz3n_type(), usz3n_type::bit_count,
-     "a sized_integral<", ", unsigned>") );
-
-    typedef signed_exact_integral< CHAR_BIT >     se8_type;
-    typedef signed_exact_integral< 3>             se3_type;
-    typedef signed_exact_integral< 0>             se0_type;
-    typedef signed_exact_integral<-3>            se3n_type;
-    typedef signed_exact_integral< - CHAR_BIT >  se8n_type;
-
-    BOOST_CHECK(  print_out_template(se8_type(), se8_type::bit_count,
-     "an exact_integral<", ", signed>") );
-    BOOST_CHECK( !print_out_template(se3_type(), se3_type::bit_count,
-     "an exact_integral<", ", signed>") );
-    BOOST_CHECK( !print_out_template(se0_type(), se0_type::bit_count,
-     "an exact_integral<", ", signed>") );
-    BOOST_CHECK( !print_out_template(se3n_type(), se3n_type::bit_count,
-     "an exact_integral<", ", signed>") );
-    BOOST_CHECK( !print_out_template(se8n_type(), se8n_type::bit_count,
-     "an exact_integral<", ", signed>") );
-
-    typedef unsigned_exact_integral< CHAR_BIT >     ue8_type;
-    typedef unsigned_exact_integral< 3>             ue3_type;
-    typedef unsigned_exact_integral< 0>             ue0_type;
-    typedef unsigned_exact_integral<-3>            ue3n_type;
-    typedef unsigned_exact_integral< - CHAR_BIT >  ue8n_type;
-
-    BOOST_CHECK(  print_out_template(ue8_type(), ue8_type::bit_count,
-     "an exact_integral<", ", unsigned>") );
-    BOOST_CHECK( !print_out_template(ue3_type(), ue3_type::bit_count,
-     "an exact_integral<", ", unsigned>") );
-    BOOST_CHECK( !print_out_template(ue0_type(), ue0_type::bit_count,
-     "an exact_integral<", ", unsigned>") );
-    BOOST_CHECK( !print_out_template(ue3n_type(), ue3n_type::bit_count,
-     "an exact_integral<", ", unsigned>") );
-    BOOST_CHECK( !print_out_template(ue8n_type(), ue8n_type::bit_count,
-     "an exact_integral<", ", unsigned>") );
-
-    typedef boost::maximum_signed_integral< 15>   max15_type;
-    typedef boost::maximum_signed_integral<  0>    max0_type;
-    typedef boost::maximum_signed_integral<-15>  max15n_type;
-
-    BOOST_CHECK(  print_out_template(max15_type(), max15_type::bound,
-     "a maximum_signed_integral<", ">") );
-    BOOST_CHECK( !print_out_template(max0_type(), max0_type::bound,
-     "a maximum_signed_integral<", ">") );
-    BOOST_CHECK( !print_out_template(max15n_type(), max15n_type::bound,
-     "a maximum_signed_integral<", ">") );
-
-    typedef boost::minimum_signed_integral< 15>   min15_type;
-    typedef boost::minimum_signed_integral<  0>    min0_type;
-    typedef boost::minimum_signed_integral<-15>  min15n_type;
-
-    BOOST_CHECK( !print_out_template(min15_type(), min15_type::bound,
-     "a minimum_signed_integral<", ">") );
-    BOOST_CHECK( !print_out_template(min0_type(), min0_type::bound,
-     "a minimum_signed_integral<", ">") );
-    BOOST_CHECK(  print_out_template(min15n_type(), min15n_type::bound,
-     "a minimum_signed_integral<", ">") );
-
-    typedef boost::maximum_unsigned_integral<15>   umax15_type;
-    typedef boost::maximum_unsigned_integral< 0>    umax0_type;
-
-    BOOST_CHECK( print_out_template(umax15_type(), umax15_type::bound,
-     "a maximum_unsigned_integral<", ">") );
-    BOOST_CHECK( print_out_template(umax0_type(), umax0_type::bound,
-     "a maximum_unsigned_integral<", ">") );
-}
-
-BOOST_AUTO_TEST_SUITE_END()
-
-// Check if given constants can fit in given types
-BOOST_AUTO_TEST_SUITE( fit_type_tests )
-
-// Check if large value can fit its minimum required size, by size
-BOOST_AUTO_TEST_CASE_TEMPLATE( fit_for_masked_values_test, T,
- valid_to_decrease_bits_list )
-{
-    // This test is supposed to replace the following checks given in
-    // puesdo-code by:
-    // Routine: Template, Type
-    //  for ( N = 32, V = Template:Max ; N >= 0 ; --N, V >>= 1 )
-    //      Confirm( static_cast<typename Template<N>::Type>(V) == V );
-    //  end for
-    // end Routine
-    // with Template = {int_t, uint_t}; Type = {least, fast};
-    //      Template:Max = { intmax_t.Max for int_t, uintmax_t.Max for uint_t }
-    // In other words, the selected type doesn't mask out any bits it's not
-    // supposed to.  But now we'll use template meta-programming instead of
-    // macros.  The limit of type-lists is usually less than 32 (not to mention
-    // 64) elements, so we have to take selected values.
-    static  int const       count = T::value;
-    int const               shift = uintmax_bits - count;
-    boost::uintmax_t const  value_u = uintmax_limits::max
-     BOOST_PREVENT_MACRO_SUBSTITUTION () >> shift;
-    boost::intmax_t const   value_s = intmax_limits::max
-     BOOST_PREVENT_MACRO_SUBSTITUTION () >> shift;
-
-    BOOST_CHECK_EQUAL( static_cast<typename
-     unsigned_sized_integral<count>::type>(value_u), value_u );
-    BOOST_CHECK_EQUAL( static_cast<typename
-     boost::uint_t<count>::least>(value_u), value_u );
-    BOOST_CHECK_EQUAL( static_cast<typename
-     boost::uint_t<count>::fast>(value_u), value_u );
-
-    BOOST_CHECK_EQUAL( static_cast<typename
-     signed_sized_integral<count>::type>(value_s), value_s );
-    BOOST_CHECK_EQUAL( static_cast<typename
-     boost::int_t<count>::least>(value_s), value_s );
-    BOOST_CHECK_EQUAL( static_cast<typename
-     boost::int_t<count>::fast>(value_s), value_s );
-}
-
-// Check if a large value can only fit of its exact bit length
-BOOST_AUTO_TEST_CASE_TEMPLATE( fit_for_exact_lengths_test, T,
- distinct_integral_bit_counts )
-{
-    typename boost::exact_integral<T::value, unsigned>::type const  one_u( 1u ),
-     high_bit_u( one_u << (T::value - 1) ), repeated_bits_u( (high_bit_u << 1) |
-     high_bit_u );
-
-    BOOST_CHECK( high_bit_u );
-    BOOST_CHECK_EQUAL( repeated_bits_u, high_bit_u );
-
-    typename boost::exact_integral<T::value, signed>::type const  one_s( 1 ),
-     high_bit_s( one_s << (T::value - 2) ), repeated_bits_s( (high_bit_s << 1) |
-     high_bit_s ), repeated_2bits_s( (repeated_bits_s << 1) | high_bit_s );
-
-    BOOST_CHECK( high_bit_s > 0 );
-    BOOST_CHECK( repeated_bits_s < 0 );
-    BOOST_CHECK_EQUAL( repeated_bits_s, repeated_2bits_s );
-}
-
-// Check if large value can fit its minimum required size, by value, unsigned
-BOOST_AUTO_TEST_CASE_TEMPLATE( fit_for_shifted_unsigned_values_test, T,
- valid_to_increase_ubits_list )
-{
-    // This test is supposed to replace the following checks given in
-    // puesdo-code by:
-    // Routine: Template, Type
-    //  for ( N = 0, V = Template:Extreme ; N < 32 ; ++N, V >>= 1 )
-    //      Confirm( static_cast<typename Template<V>::Type>(V) == V );
-    //  end for
-    // end Routine
-    // with Template = {uint_value_t}; Type = {least, fast}; Template:Extreme =
-    //      {uintmax_t.Max for uint_value_t}
-    // In other words, the selected type doesn't mask out any bits it's not
-    // supposed to.  But now we'll use template meta-programming instead of
-    // macros.  The limit of type-lists is usually less than 32 (not to mention
-    // 64) elements, so we have to take selected values.
-    using boost::uintmax_t;
-
-    typedef boost::mpl::shift_right<maximum_of<uintmax_t>, T>  maxi_type;
-
-    uintmax_t const  maxi = maxi_type::value;
-
-    BOOST_CHECK_EQUAL( static_cast<typename
-     boost::uint_value_t<maxi_type::value>::least>(maxi), maxi );
-    BOOST_CHECK_EQUAL( static_cast<typename
-     boost::uint_value_t<maxi_type::value>::fast>(maxi), maxi );
-}
-
-// Check if large value can fit its minimum required size, by value, signed
-BOOST_AUTO_TEST_CASE_TEMPLATE( fit_for_shifted_signed_values_test, T,
- valid_to_increase_sbits_list )
-{
-    // This test is supposed to replace the following checks given in
-    // puesdo-code by:
-    // Routine: Template, Type
-    //  for ( N = 0, V = Template:Extreme ; N < 32 ; ++N, V >>= 1 )
-    //      Confirm( static_cast<typename Template<V>::Type>(V) == V );
-    //  end for
-    // end Routine
-    // with Template = {int_max_value_t, int_min_value_t}; Type = {least, fast};
-    //      Template:Extreme = {intmax_t.Min for int_min_value_t, intmax_t.Max
-    //      for int_max_value_t}
-    // In other words, the selected type doesn't mask out any bits it's not
-    // supposed to.  But now we'll use template meta-programming instead of
-    // macros.  The limit of type-lists is usually less than 32 (not to mention
-    // 64) elements, so we have to take selected values.
-    using boost::intmax_t;
-
-    typedef boost::mpl::shift_right<minimum_of<intmax_t>, T>  mini_type;
-    typedef boost::mpl::shift_right<maximum_of<intmax_t>, T>  maxi_type;
-
-    intmax_t const  maxi = maxi_type::value, mini = mini_type::value;
-
-    BOOST_CHECK_EQUAL( static_cast<typename
-     boost::int_max_value_t<maxi_type::value>::least>(maxi), maxi );
-    BOOST_CHECK_EQUAL( static_cast<typename
-     boost::int_max_value_t<maxi_type::value>::fast>(maxi), maxi );
-
-    BOOST_CHECK_EQUAL( static_cast<typename
-     boost::int_min_value_t<mini_type::value>::least>(mini), mini );
-    BOOST_CHECK_EQUAL( static_cast<typename
-     boost::int_min_value_t<mini_type::value>::fast>(mini), mini );
-}
-
-BOOST_AUTO_TEST_SUITE_END()
-
-// Verification of bugs and their fixes
-BOOST_AUTO_TEST_SUITE( bug_fix_tests )
-
-BOOST_AUTO_TEST_SUITE_END()

test/issue_2134.cpp

@@ -1,33 +0,0 @@
-//  boost Issue #2134 test program  ------------------------------------------//
-
-//  Copyright Daryle Walker 2008.  Distributed under the Boost
-//  Software License, Version 1.0. (See the accompanying file
-//  LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
-
-//  See <http://www.boost.org/libs/integer> for documentation.
-//  See <http://svn.boost.org/trac/boost/ticket/2134> for the issue involved.
-
-//  Revision History
-//   23 Jul 2008  Initial version
-
-// Control if the inclusion error is triggered
-#ifndef CONTROL_INCLUDE_TRAITS
-#define CONTROL_INCLUDE_TRAITS  1
-#endif
-
-#if CONTROL_INCLUDE_TRAITS
-// This file defines boost::detail::integer_traits.
-#include <boost/detail/numeric_traits.hpp>
-#endif
-
-// This is the file with the issue.  It has items within the boost::detail
-// namespace that referenced an unadorned "integer_traits".  This was meant to
-// refer to boost::integer_traits.  However, <boost/detail/numeric_traits.hpp>
-// defines a boost::detail::integer_traits.  If that header is #included before
-// this one, then b.d.integer_traits (rightfully) took priority, which lead to a
-// syntax error.
-#include <boost/integer.hpp>
-
-
-// Main program, minimal (since this is a compile test)
-int  main()  { return 0; }