text: //  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
  
  //
  // There are two ways to test this: in version 1, we include cstdint.hpp as the first
  // include, which means we get decide whether __STDC_CONSTANT_MACROS is defined.
  // In version two we include stdint.h with __STDC_CONSTANT_MACROS *NOT* defined first,
  // and check that we still end up with compatible definitions for the INT#_C macros.
  //
  // This is version 1.
  //
  
  #if defined(__GNUC__) && (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4))
  // We can't suppress this warning on the command line as not all GCC versions support -Wno-type-limits :
  #pragma GCC diagnostic ignored "-Wtype-limits"
  #endif
  
  #include <boost/cstdint.hpp>
  #include <boost/detail/lightweight_test.hpp>
  #include <iostream>
  
  #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()
  {
    BOOST_TEST( int8 == -127 );
    BOOST_TEST( int_least8 == -127 );
    BOOST_TEST( int_fast8 == -127 );
    BOOST_TEST( uint8 == 255u );
    BOOST_TEST( uint_least8 == 255u );
    BOOST_TEST( uint_fast8 == 255u );
    BOOST_TEST( int16 == -32767 );
    BOOST_TEST( int_least16 == -32767 );
    BOOST_TEST( int_fast16 == -32767 );
    BOOST_TEST( uint16 == 65535u );
    BOOST_TEST( uint_least16 == 65535u );
    BOOST_TEST( uint_fast16 == 65535u );
    BOOST_TEST( int32 == -2147483647 );
    BOOST_TEST( int_least32 == -2147483647 );
    BOOST_TEST( int_fast32 == -2147483647 );
    BOOST_TEST( uint32 == 4294967295u );
    BOOST_TEST( uint_least32 == 4294967295u );
    BOOST_TEST( 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 BOOST_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:
     BOOST_TEST(sizeof(T1) <= sizeof(T2));
  #else
     BOOST_TEST(sizeof(T1) == sizeof(T2));
     BOOST_TEST(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)
          BOOST_TEST(t2 > 0);
        else
          BOOST_TEST(!(t2 > 0));
     }
     else if(t1 < 0)
        BOOST_TEST(!(t2 > 0));
  #else
     if(t1 > 0)
       BOOST_TEST(t2 > 0);
     else
       BOOST_TEST(!(t2 > 0));
  #endif
  }
  
  
  int main(int, char*[])
  {
  #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
  
    BOOST_TEST( int8 == -127 );
    BOOST_TEST( int_least8 == -127 );
    BOOST_TEST( int_fast8 == -127 );
    BOOST_TEST( uint8 == 255u );
    BOOST_TEST( uint_least8 == 255u );
    BOOST_TEST( uint_fast8 == 255u );
    BOOST_TEST( int16 == -32767 );
    BOOST_TEST( int_least16 == -32767 );
    BOOST_TEST( int_fast16 == -32767 );
    BOOST_TEST( uint16 == 65535u );
    BOOST_TEST( uint_least16 == 65535u );
    BOOST_TEST( uint_fast16 == 65535u );
    BOOST_TEST( int32 == -2147483647 );
    BOOST_TEST( int_least32 == -2147483647 );
    BOOST_TEST( int_fast32 == -2147483647 );
    BOOST_TEST( uint32 == 4294967295u );
    BOOST_TEST( uint_least32 == 4294967295u );
    BOOST_TEST( uint_fast32 == 4294967295u );
  
  #ifndef BOOST_NO_INT64_T
    BOOST_TEST( int64 == INT64_C(-9223372036854775807) );
    BOOST_TEST( int_least64 == INT64_C(-9223372036854775807) );
    BOOST_TEST( int_fast64 == INT64_C(-9223372036854775807) );
    BOOST_TEST( uint64 == UINT64_C(18446744073709551615) );
    BOOST_TEST( uint_least64 == UINT64_C(18446744073709551615) );
    BOOST_TEST( uint_fast64 == UINT64_C(18446744073709551615) );
    BOOST_TEST( intmax == INT64_C(-9223372036854775807) );
    BOOST_TEST( uintmax == UINT64_C(18446744073709551615) );
  #else
    BOOST_TEST( intmax == -2147483647 );
    BOOST_TEST( uintmax == 4294967295u );
  #endif
  
  
    std::cout << "OK\n";
    return boost::report_errors();
  }
  