This commit was manufactured by cvs2svn to create tag

'Version_1_32_0'.

[SVN r26264]

cstdint_test.cpp

@@ -113,24 +113,10 @@ void integral_constant_type_check(T1, T2)
    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
 }
 
 

doc/integer_mask.html

@@ -202,9 +202,10 @@ href="../../../people/daryle_walker.html">Daryle Walker</a>.</p>
 
 <p>Revised September 23, 2001</p>
 
-<p>&copy; Copyright Daryle Walker 2001.  Use, modification, and distribution are
+<p>&copy; Copyright Daryle Walker 2001.  Permission to copy, use,
-subject to the Boost Software License, Version 1.0.  (See accompanying file <a
+modify, sell and distribute this document is granted provided this
-href="../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at &lt;<a
+copyright notice appears in all copies.  This document is provided
-href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</p>
+&quot;as is&quot; without express or implied warranty, and with no claim
+as to its suitability for any purpose.</p>
 </body>
 </html>

doc/static_min_max.html

@@ -112,9 +112,10 @@ href="../../../people/daryle_walker.html">Daryle Walker</a>.</p>
 
 <p>Revised October 12, 2001</p>
 
-<p>&copy; Copyright Daryle Walker 2001.  Use, modification, and distribution are
+<p>&copy; Copyright Daryle Walker 2001.  Permission to copy, use,
-subject to the Boost Software License, Version 1.0.  (See accompanying file <a
+modify, sell and distribute this document is granted provided this
-href="../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at &lt;<a
+copyright notice appears in all copies.  This document is provided
-href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</p>
+&quot;as is&quot; without express or implied warranty, and with no claim
+as to its suitability for any purpose.</p>
 </body>
 </html>

include/boost/cstdint.hpp

@@ -40,48 +40,8 @@
 #   include <inttypes.h>
 # else
 #   include <stdint.h>
-
-// There is a bug in Cygwin two _C macros
-#   if defined(__STDC_CONSTANT_MACROS) && defined(__CYGWIN__)
-#     undef INTMAX_C
-#     undef UINTMAX_C
-#     define INTMAX_C(c) c##LL
-#     define UINTMAX_C(c) c##ULL
 # endif
 
-# endif
-
-#ifdef __QNX__
-
-// QNX (Dinkumware stdlib) defines these as non-standard names.
-// Reflect to the standard names.
-
-typedef ::intleast8_t int_least8_t;
-typedef ::intfast8_t int_fast8_t;
-typedef ::uintleast8_t uint_least8_t;
-typedef ::uintfast8_t uint_fast8_t;
-
-typedef ::intleast16_t int_least16_t;
-typedef ::intfast16_t int_fast16_t;
-typedef ::uintleast16_t uint_least16_t;
-typedef ::uintfast16_t uint_fast16_t;
-
-typedef ::intleast32_t int_least32_t;
-typedef ::intfast32_t int_fast32_t;
-typedef ::uintleast32_t uint_least32_t;
-typedef ::uintfast32_t uint_fast32_t;
-
-# ifndef BOOST_NO_INT64_T
-
-typedef ::intleast64_t int_least64_t;
-typedef ::intfast64_t int_fast64_t;
-typedef ::uintleast64_t uint_least64_t;
-typedef ::uintfast64_t uint_fast64_t;
-
-# endif
-
-#endif
-
 namespace boost
 {
 
@@ -173,7 +133,6 @@ namespace boost {
 #else  // BOOST_HAS_STDINT_H
 
 # include <boost/limits.hpp> // implementation artifact; not part of interface
-# include <limits.h>         // needed for limits macros
 
 
 namespace boost

include/boost/integer_traits.hpp

@@ -21,9 +21,7 @@
 
 // These are an implementation detail and not part of the interface
 #include <limits.h>
-// we need wchar.h for WCHAR_MAX/MIN but not all platforms provide it,
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T) && !defined(BOOST_NO_CWCHAR)
-// and some may have <wchar.h> but not <cwchar> ...
-#if !defined(BOOST_NO_INTRINSIC_WCHAR_T) && (!defined(BOOST_NO_CWCHAR) || defined(sun) || defined(__sun) || defined(__QNX__))
 #include <wchar.h>
 #endif
 
@@ -88,9 +86,7 @@ class integer_traits<unsigned char>
 template<>
 class integer_traits<wchar_t>
   : public std::numeric_limits<wchar_t>,
-    // Don't trust WCHAR_MIN and WCHAR_MAX with Mac OS X's native
+#if defined(WCHAR_MIN) && defined(WCHAR_MAX)
-    // library: they are wrong!
-#if defined(WCHAR_MIN) && defined(WCHAR_MAX) && !defined(__APPLE__)
     public detail::integer_traits_base<wchar_t, WCHAR_MIN, WCHAR_MAX>
 #elif defined(__BORLANDC__) || defined(__CYGWIN__) || defined(__MINGW32__) || (defined(__BEOS__) && defined(__GNUC__))
     // No WCHAR_MIN and WCHAR_MAX, whar_t is short and unsigned:
@@ -100,7 +96,6 @@ class integer_traits<wchar_t>
     || (defined(__OpenBSD__) && defined(__GNUC__))\
     || (defined(__NetBSD__) && defined(__GNUC__))\
     || (defined(__FreeBSD__) && defined(__GNUC__))\
-    || (defined(__DragonFly__) && defined(__GNUC__))\
     || (defined(__hpux) && defined(__GNUC__) && (__GNUC__ == 3) && !defined(__SGI_STL_PORT))
     // No WCHAR_MIN and WCHAR_MAX, wchar_t has the same range as int.
     //  - SGI MIPSpro with native library

integer.htm

@@ -204,9 +204,10 @@ value-based sized templates.</p>
 
 <p>Revised May 20, 2001</p>
 
-<p>&copy; Copyright Beman Dawes 1999.  Use, modification, and distribution are
+<p>&copy; Copyright Beman Dawes 1999.  Permission to copy, use, modify,
-subject to the Boost Software License, Version 1.0.  (See accompanying file <a
+sell and distribute this document is granted provided this copyright
-href="../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at &lt;<a
+notice appears in all copies.  This document is provided &quot;as
-href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</p>
+is&quot; without express or implied warranty, and with no claim as to
+its suitability for any purpose.</p>
 </body>
 </html>

integer_test.cpp

@@ -12,7 +12,7 @@
 //   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/test/minimal.hpp>  // for main, BOOST_TEST
 
 #include <boost/config.hpp>   // for BOOST_NO_USING_TEMPLATE
 #include <boost/cstdlib.hpp>  // for boost::exit_success
@@ -128,27 +128,9 @@ namespace boost
 
 
 // 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 )
+#define PRIVATE_FIT_TEST(Template, Number, Type, Value)  BOOST_TEST( 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, 32, Type, v); v >>= 1; \
-#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; \
@@ -165,28 +147,8 @@ namespace boost
  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_TEST(Template, Number, Type, Value)  BOOST_TEST( 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; \
@@ -206,7 +168,7 @@ namespace boost
  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_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_TEST( 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; \
@@ -226,7 +188,7 @@ namespace boost
  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_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_TEST( 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; \

integer_traits_test.cpp

@@ -53,19 +53,11 @@ void runtest(const char * type, T)
             << "; 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);
+  BOOST_TEST(traits::is_specialized);
-#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1200)
+  BOOST_TEST(traits::is_integer);
-  // MSVC++ 6.0 issues a LNK1179 error (duplicate comdat) when the compiler
+  BOOST_TEST(traits::is_integral);
-  // generates different symbol names with a very long common prefix:
+  BOOST_TEST(traits::const_min == (traits::min)());
-  // the dummy "&& true" disambiguates between the symbols generated by this
+  BOOST_TEST(traits::const_max == (traits::max)());
-  // 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*[])

test/integer_mask_test.cpp

@@ -19,16 +19,16 @@
 #include <iostream>  // for std::cout (std::endl indirectly)
 
 
-#define PRIVATE_HIGH_BIT_SLOW_TEST(v)  BOOST_CHECK( ::boost::high_bit_mask_t< \
+#define PRIVATE_HIGH_BIT_SLOW_TEST(v)  BOOST_TEST( ::boost::high_bit_mask_t< \
  (v) >::high_bit == (1ul << (v)) );
-#define PRIVATE_HIGH_BIT_FAST_TEST(v)  BOOST_CHECK( ::boost::high_bit_mask_t< \
+#define PRIVATE_HIGH_BIT_FAST_TEST(v)  BOOST_TEST( ::boost::high_bit_mask_t< \
  (v) >::high_bit_fast == (1ul << (v)) );
 #define PRIVATE_HIGH_BIT_TEST(v)  do { PRIVATE_HIGH_BIT_SLOW_TEST(v); \
  PRIVATE_HIGH_BIT_FAST_TEST(v); } while (false)
 
-#define PRIVATE_LOW_BITS_SLOW_TEST(v)  BOOST_CHECK( ::boost::low_bits_mask_t< \
+#define PRIVATE_LOW_BITS_SLOW_TEST(v)  BOOST_TEST( ::boost::low_bits_mask_t< \
  (v) >::sig_bits == ((1ul << (v)) - 1) );
-#define PRIVATE_LOW_BITS_FAST_TEST(v)  BOOST_CHECK( ::boost::low_bits_mask_t< \
+#define PRIVATE_LOW_BITS_FAST_TEST(v)  BOOST_TEST( ::boost::low_bits_mask_t< \
  (v) >::sig_bits_fast == ((1ul << (v)) - 1) );
 #define PRIVATE_LOW_BITS_TEST(v)  do { PRIVATE_LOW_BITS_SLOW_TEST(v); \
  PRIVATE_LOW_BITS_FAST_TEST(v); } while (false)

test/static_log2_test.cpp

@@ -20,7 +20,7 @@
 
 
 // Macros to compact code
-#define PRIVATE_LB_TEST( v, e )  BOOST_CHECK( ::boost::static_log2<v>::value == e )
+#define PRIVATE_LB_TEST( v, e )  BOOST_TEST( ::boost::static_log2<v>::value == e )
 
 #define PRIVATE_PRINT_LB( v )    ::std::cout << "boost::static_log2<" << (v) \
  << "> = " << ::boost::static_log2< (v) >::value << '.' << ::std::endl

test/static_min_max_test.cpp

@@ -11,7 +11,7 @@
 //  23 Sep 2001  Initial version (Daryle Walker)
 
 #define  BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>  // for main, BOOST_CHECK
+#include <boost/test/test_tools.hpp>  // for main, BOOST_TEST
 
 #include <boost/cstdlib.hpp>                 // for boost::exit_success
 #include <boost/integer/static_min_max.hpp>  // for boost::static_signed_min, etc.
@@ -37,57 +37,57 @@ test_main
     // Two positives
     cout << "Doing tests with two positive values." << endl;
 
-    BOOST_CHECK( (static_signed_min< 9, 14>::value) ==  9 );
+    BOOST_TEST( (static_signed_min< 9, 14>::value) ==  9 );
-    BOOST_CHECK( (static_signed_max< 9, 14>::value) == 14 );
+    BOOST_TEST( (static_signed_max< 9, 14>::value) == 14 );
-    BOOST_CHECK( (static_signed_min<14,  9>::value) ==  9 );
+    BOOST_TEST( (static_signed_min<14,  9>::value) ==  9 );
-    BOOST_CHECK( (static_signed_max<14,  9>::value) == 14 );
+    BOOST_TEST( (static_signed_max<14,  9>::value) == 14 );
 
-    BOOST_CHECK( (static_unsigned_min< 9, 14>::value) ==  9 );
+    BOOST_TEST( (static_unsigned_min< 9, 14>::value) ==  9 );
-    BOOST_CHECK( (static_unsigned_max< 9, 14>::value) == 14 );
+    BOOST_TEST( (static_unsigned_max< 9, 14>::value) == 14 );
-    BOOST_CHECK( (static_unsigned_min<14,  9>::value) ==  9 );
+    BOOST_TEST( (static_unsigned_min<14,  9>::value) ==  9 );
-    BOOST_CHECK( (static_unsigned_max<14,  9>::value) == 14 );
+    BOOST_TEST( (static_unsigned_max<14,  9>::value) == 14 );
 
     // Two negatives
     cout << "Doing tests with two negative values." << endl;
 
-    BOOST_CHECK( (static_signed_min<  -8, -101>::value) == -101 );
+    BOOST_TEST( (static_signed_min<  -8, -101>::value) == -101 );
-    BOOST_CHECK( (static_signed_max<  -8, -101>::value) ==   -8 );
+    BOOST_TEST( (static_signed_max<  -8, -101>::value) ==   -8 );
-    BOOST_CHECK( (static_signed_min<-101,   -8>::value) == -101 );
+    BOOST_TEST( (static_signed_min<-101,   -8>::value) == -101 );
-    BOOST_CHECK( (static_signed_max<-101,   -8>::value) ==   -8 );
+    BOOST_TEST( (static_signed_max<-101,   -8>::value) ==   -8 );
 
     // With zero
     cout << "Doing tests with zero and a positive or negative value." << endl;
 
-    BOOST_CHECK( (static_signed_min< 0, 14>::value) ==  0 );
+    BOOST_TEST( (static_signed_min< 0, 14>::value) ==  0 );
-    BOOST_CHECK( (static_signed_max< 0, 14>::value) == 14 );
+    BOOST_TEST( (static_signed_max< 0, 14>::value) == 14 );
-    BOOST_CHECK( (static_signed_min<14,  0>::value) ==  0 );
+    BOOST_TEST( (static_signed_min<14,  0>::value) ==  0 );
-    BOOST_CHECK( (static_signed_max<14,  0>::value) == 14 );
+    BOOST_TEST( (static_signed_max<14,  0>::value) == 14 );
 
-    BOOST_CHECK( (static_unsigned_min< 0, 14>::value) ==  0 );
+    BOOST_TEST( (static_unsigned_min< 0, 14>::value) ==  0 );
-    BOOST_CHECK( (static_unsigned_max< 0, 14>::value) == 14 );
+    BOOST_TEST( (static_unsigned_max< 0, 14>::value) == 14 );
-    BOOST_CHECK( (static_unsigned_min<14,  0>::value) ==  0 );
+    BOOST_TEST( (static_unsigned_min<14,  0>::value) ==  0 );
-    BOOST_CHECK( (static_unsigned_max<14,  0>::value) == 14 );
+    BOOST_TEST( (static_unsigned_max<14,  0>::value) == 14 );
 
-    BOOST_CHECK( (static_signed_min<   0, -101>::value) == -101 );
+    BOOST_TEST( (static_signed_min<   0, -101>::value) == -101 );
-    BOOST_CHECK( (static_signed_max<   0, -101>::value) ==    0 );
+    BOOST_TEST( (static_signed_max<   0, -101>::value) ==    0 );
-    BOOST_CHECK( (static_signed_min<-101,    0>::value) == -101 );
+    BOOST_TEST( (static_signed_min<-101,    0>::value) == -101 );
-    BOOST_CHECK( (static_signed_max<-101,    0>::value) ==    0 );
+    BOOST_TEST( (static_signed_max<-101,    0>::value) ==    0 );
 
     // With identical
     cout << "Doing tests with two identical values." << endl;
 
-    BOOST_CHECK( (static_signed_min<0, 0>::value) == 0 );
+    BOOST_TEST( (static_signed_min<0, 0>::value) == 0 );
-    BOOST_CHECK( (static_signed_max<0, 0>::value) == 0 );
+    BOOST_TEST( (static_signed_max<0, 0>::value) == 0 );
-    BOOST_CHECK( (static_unsigned_min<0, 0>::value) == 0 );
+    BOOST_TEST( (static_unsigned_min<0, 0>::value) == 0 );
-    BOOST_CHECK( (static_unsigned_max<0, 0>::value) == 0 );
+    BOOST_TEST( (static_unsigned_max<0, 0>::value) == 0 );
 
-    BOOST_CHECK( (static_signed_min<14, 14>::value) == 14 );
+    BOOST_TEST( (static_signed_min<14, 14>::value) == 14 );
-    BOOST_CHECK( (static_signed_max<14, 14>::value) == 14 );
+    BOOST_TEST( (static_signed_max<14, 14>::value) == 14 );
-    BOOST_CHECK( (static_unsigned_min<14, 14>::value) == 14 );
+    BOOST_TEST( (static_unsigned_min<14, 14>::value) == 14 );
-    BOOST_CHECK( (static_unsigned_max<14, 14>::value) == 14 );
+    BOOST_TEST( (static_unsigned_max<14, 14>::value) == 14 );
 
-    BOOST_CHECK( (static_signed_min< -101, -101>::value) == -101 );
+    BOOST_TEST( (static_signed_min< -101, -101>::value) == -101 );
-    BOOST_CHECK( (static_signed_max< -101, -101>::value) == -101 );
+    BOOST_TEST( (static_signed_max< -101, -101>::value) == -101 );
 
     return boost::exit_success;
 }