[Boost-commit] svn:boost r47586 - in branches/release: . libs/functional/hash/test

From: daniel_james_at_[hidden]
Date: 2008-07-19 05:02:13

Author: danieljames
Date: 2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
New Revision: 47586
URL: http://svn.boost.org/trac/boost/changeset/47586

Log:
Revert conversion from lightweight test to Boost.Test.

Merged revisions 47545 via svnmerge from 
https://svn.boost.org/svn/boost/trunk

........
  r47545 | danieljames | 2008-07-18 13:31:18 +0100 (Fri, 18 Jul 2008) | 1 line
  
  Revert conversion from lightweight test to Boost.Test.
........

Properties modified: 
   branches/release/   (props changed)
Text files modified: 
   branches/release/libs/functional/hash/test/container_fwd_test.cpp         |     2                                         
   branches/release/libs/functional/hash/test/hash_built_in_array_test.cpp   |    16 ++++----                                
   branches/release/libs/functional/hash/test/hash_complex_test.cpp          |    10 ++--                                    
   branches/release/libs/functional/hash/test/hash_custom_test.cpp           |    16 ++++----                                
   branches/release/libs/functional/hash/test/hash_deprecated_headers.cpp    |     2                                         
   branches/release/libs/functional/hash/test/hash_deque_test.cpp            |     6 +-                                      
   branches/release/libs/functional/hash/test/hash_float_test.cpp            |     4 +-                                      
   branches/release/libs/functional/hash/test/hash_float_test.hpp            |    76 ++++++++++++++++++++--------------------
   branches/release/libs/functional/hash/test/hash_friend_test.cpp           |    16 ++++----                                
   branches/release/libs/functional/hash/test/hash_function_pointer_test.cpp |    32 ++++++++--------                        
   branches/release/libs/functional/hash/test/hash_fwd_test_1.cpp            |    18 ++++----                                
   branches/release/libs/functional/hash/test/hash_fwd_test_2.cpp            |     6 +-                                      
   branches/release/libs/functional/hash/test/hash_global_namespace_test.cpp |    16 ++++----                                
   branches/release/libs/functional/hash/test/hash_list_test.cpp             |     6 +-                                      
   branches/release/libs/functional/hash/test/hash_long_double_test.cpp      |     4 +-                                      
   branches/release/libs/functional/hash/test/hash_map_test.cpp              |     6 +-                                      
   branches/release/libs/functional/hash/test/hash_map_test.hpp              |     8 ++--                                    
   branches/release/libs/functional/hash/test/hash_no_ext_fail_test.cpp      |     2                                         
   branches/release/libs/functional/hash/test/hash_no_ext_macro_1.cpp        |     8 ++--                                    
   branches/release/libs/functional/hash/test/hash_no_ext_macro_2.cpp        |     8 ++--                                    
   branches/release/libs/functional/hash/test/hash_number_test.cpp           |    62 ++++++++++++++++----------------        
   branches/release/libs/functional/hash/test/hash_pointer_test.cpp          |    18 ++++----                                
   branches/release/libs/functional/hash/test/hash_range_test.cpp            |    28 +++++++-------                          
   branches/release/libs/functional/hash/test/hash_sequence_test.hpp         |     8 ++--                                    
   branches/release/libs/functional/hash/test/hash_set_test.cpp              |     6 +-                                      
   branches/release/libs/functional/hash/test/hash_set_test.hpp              |     8 ++--                                    
   branches/release/libs/functional/hash/test/hash_string_test.cpp           |    30 +++++++-------                          
   branches/release/libs/functional/hash/test/hash_value_array_test.cpp      |    14 +++---                                  
   branches/release/libs/functional/hash/test/hash_vector_test.cpp           |     6 +-                                      
   branches/release/libs/functional/hash/test/link_ext_test.cpp              |     4 +-                                      
   branches/release/libs/functional/hash/test/link_no_ext_test.cpp           |     9 ++--                                    
   branches/release/libs/functional/hash/test/link_test.cpp                  |     2                                         
   32 files changed, 228 insertions(+), 229 deletions(-)

Modified: branches/release/libs/functional/hash/test/container_fwd_test.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/container_fwd_test.cpp	(original)
+++ branches/release/libs/functional/hash/test/container_fwd_test.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -77,7 +77,7 @@
 #include <complex>
 #include <utility>
 
-int main(int, char**)
+int main()
 {
     std::deque<int> x1;
     std::list<std::string> x2;

Modified: branches/release/libs/functional/hash/test/hash_built_in_array_test.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_built_in_array_test.cpp	(original)
+++ branches/release/libs/functional/hash/test/hash_built_in_array_test.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -13,7 +13,7 @@
 #  endif
 #endif
 
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -37,11 +37,11 @@
     int array3[2] = {2, 3};
     HASH_NAMESPACE::hash<int[2]> hasher3;
 
-    BOOST_CHECK(hasher1(array1)
+    BOOST_TEST(hasher1(array1)
             == HASH_NAMESPACE::hash_range(array1, array1 + length1));
-    BOOST_CHECK(hasher2(array2)
+    BOOST_TEST(hasher2(array2)
             == HASH_NAMESPACE::hash_range(array2, array2 + length2));
-    BOOST_CHECK(hasher3(array3)
+    BOOST_TEST(hasher3(array3)
             == HASH_NAMESPACE::hash_range(array3, array3 + length3));
 }
 
@@ -59,17 +59,17 @@
         HASH_NAMESPACE::hash_combine(seed1, seed2);
     }
 
-    BOOST_CHECK(hasher(array) == seed1);
-    BOOST_CHECK(hasher(array) == HASH_NAMESPACE::hash_range(array, array + 3));
+    BOOST_TEST(hasher(array) == seed1);
+    BOOST_TEST(hasher(array) == HASH_NAMESPACE::hash_range(array, array + 3));
 }
 
 #endif // TEST_EXTENSIONS
 
-int test_main(int, char**)
+int main()
 {
 #ifdef TEST_EXTENSIONS
     array_int_test();
     two_dimensional_array_test();
 #endif
-    return 0;
+    return boost::report_errors();
 }

Modified: branches/release/libs/functional/hash/test/hash_complex_test.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_complex_test.cpp	(original)
+++ branches/release/libs/functional/hash/test/hash_complex_test.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -13,7 +13,7 @@
 #  endif
 #endif
 
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -41,13 +41,13 @@
 {
     HASH_NAMESPACE::hash<std::complex<T> > complex_hasher;
 
-    BOOST_CHECK(complex_hasher(v) == complex_hasher(v));
+    BOOST_TEST(complex_hasher(v) == complex_hasher(v));
 
     HASH_NAMESPACE::hash<T> real_hasher;
     T real = v.real();
     T imag = v.imag();
 
-    BOOST_CHECK(real_hasher(real) == complex_hasher(std::complex<T>(real)));
+    BOOST_TEST(real_hasher(real) == complex_hasher(std::complex<T>(real)));
 
     if(imag != 0 && real_hasher(real) == complex_hasher(v)) {
         std::ostringstream os;
@@ -90,7 +90,7 @@
     }
 }
 
-int test_main(int, char**)
+int main()
 {
     complex_float_tests((float*) 0);
     complex_float_tests((double*) 0);
@@ -102,7 +102,7 @@
     complex_integral_tests((unsigned int*) 0);
     complex_integral_tests((unsigned long*) 0);
 
-    return 0;
+    return boost::report_errors();
 }
 
 #endif

Modified: branches/release/libs/functional/hash/test/hash_custom_test.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_custom_test.cpp	(original)
+++ branches/release/libs/functional/hash/test/hash_custom_test.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -48,7 +48,7 @@
 #  endif
 #endif
 
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -59,13 +59,13 @@
 void custom_tests()
 {
     HASH_NAMESPACE::hash<test::custom> custom_hasher;
-    BOOST_CHECK(custom_hasher(10) == 100u);
+    BOOST_TEST(custom_hasher(10) == 100u);
     test::custom x(55);
-    BOOST_CHECK(custom_hasher(x) == 550u);
+    BOOST_TEST(custom_hasher(x) == 550u);
 
     {
         using namespace HASH_NAMESPACE;
-        BOOST_CHECK(custom_hasher(x) == hash_value(x));
+        BOOST_TEST(custom_hasher(x) == hash_value(x));
     }
 
     std::vector<test::custom> custom_vector;
@@ -83,17 +83,17 @@
     HASH_NAMESPACE::hash_combine(seed2, 250u);
     HASH_NAMESPACE::hash_combine(seed2, 350u);
 
-    BOOST_CHECK(seed ==
+    BOOST_TEST(seed ==
             HASH_NAMESPACE::hash_range(custom_vector.begin(), custom_vector.end()));
-    BOOST_CHECK(seed == seed2);
+    BOOST_TEST(seed == seed2);
 }
 
 #endif // TEST_EXTENSIONS
 
-int test_main(int, char**)
+int main()
 {
 #ifdef TEST_EXTENSIONS
     custom_tests();
 #endif
-    return 0;
+    return boost::report_errors();
 }

Modified: branches/release/libs/functional/hash/test/hash_deprecated_headers.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_deprecated_headers.cpp	(original)
+++ branches/release/libs/functional/hash/test/hash_deprecated_headers.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -19,7 +19,7 @@
 
 #include <vector>
 
-int main(int, char**) {
+int main() {
     std::vector<int> v;
     boost::hash<std::vector<int> > x;
     x(v);

Modified: branches/release/libs/functional/hash/test/hash_deque_test.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_deque_test.cpp	(original)
+++ branches/release/libs/functional/hash/test/hash_deque_test.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -13,7 +13,7 @@
 #  endif
 #endif
 
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -25,11 +25,11 @@
 
 #endif // TEST_EXTENSIONS
 
-int test_main(int, char**)
+int main()
 {
 #ifdef TEST_EXTENSIONS
     deque_tests::deque_hash_integer_tests();
 #endif
 
-    return 0;
+    return boost::report_errors();
 }

Modified: branches/release/libs/functional/hash/test/hash_float_test.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_float_test.cpp	(original)
+++ branches/release/libs/functional/hash/test/hash_float_test.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -5,7 +5,7 @@
 
 #include "hash_float_test.hpp"
 
-int test_main(int, char**)
+int main()
 {
     std::cerr<<"Compiler: "<<BOOST_COMPILER<<"\n";
     std::cerr<<"Platform: "<<BOOST_PLATFORM<<"\n";
@@ -14,5 +14,5 @@
     float_tests("float", (float*) 0);
     float_tests("double", (double*) 0);
 
-    return 0;
+    return boost::report_errors();
 }

Modified: branches/release/libs/functional/hash/test/hash_float_test.hpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_float_test.hpp	(original)
+++ branches/release/libs/functional/hash/test/hash_float_test.hpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -11,7 +11,7 @@
 #  include <boost/functional/hash.hpp>
 #endif
 
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #include <cmath>
 #include <boost/limits.hpp>
@@ -43,11 +43,11 @@
     T zero = 0;
     T minus_zero = (T) -1 * zero;
 
-    BOOST_CHECK(zero == minus_zero);
-    BOOST_CHECK(x1(zero) == x1(minus_zero));
+    BOOST_TEST(zero == minus_zero);
+    BOOST_TEST(x1(zero) == x1(minus_zero));
 
-    BOOST_CHECK(x1(zero) == HASH_NAMESPACE::hash_value(zero));
-    BOOST_CHECK(x1(minus_zero) == HASH_NAMESPACE::hash_value(minus_zero));
+    BOOST_TEST(x1(zero) == HASH_NAMESPACE::hash_value(zero));
+    BOOST_TEST(x1(minus_zero) == HASH_NAMESPACE::hash_value(minus_zero));
 
     using namespace std;
 
@@ -65,23 +65,23 @@
         T minus_infinity2 = (T) -1. / zero;
         T minus_infinity3 = (T) 1. / minus_zero;
 
-        BOOST_CHECK(x1(infinity) == HASH_NAMESPACE::hash_value(infinity));
-        BOOST_CHECK(x1(minus_infinity)
+        BOOST_TEST(x1(infinity) == HASH_NAMESPACE::hash_value(infinity));
+        BOOST_TEST(x1(minus_infinity)
                 == HASH_NAMESPACE::hash_value(minus_infinity));
 
         if(infinity == infinity2)
-            BOOST_CHECK(x1(infinity) == x1(infinity2));
+            BOOST_TEST(x1(infinity) == x1(infinity2));
         if(infinity == infinity3)
-            BOOST_CHECK(x1(infinity) == x1(infinity3));
+            BOOST_TEST(x1(infinity) == x1(infinity3));
         if(infinity == infinity4)
-            BOOST_CHECK(x1(infinity) == x1(infinity4));
+            BOOST_TEST(x1(infinity) == x1(infinity4));
 
         if(minus_infinity == minus_infinity2)
-            BOOST_CHECK(x1(minus_infinity) == x1(minus_infinity2));
+            BOOST_TEST(x1(minus_infinity) == x1(minus_infinity2));
         if(minus_infinity == minus_infinity3)
-            BOOST_CHECK(x1(minus_infinity) == x1(minus_infinity3));
+            BOOST_TEST(x1(minus_infinity) == x1(minus_infinity3));
 
-        BOOST_CHECK(infinity != minus_infinity);
+        BOOST_TEST(infinity != minus_infinity);
 
         if(x1(infinity) == x1(minus_infinity)) {
             std::cerr<<"x1(infinity) == x1(-infinity) == "<<x1(infinity)<<"\n";
@@ -113,22 +113,22 @@
     T quarter_max = max / 4;
     T three_quarter_max = max - quarter_max;
 
-    BOOST_CHECK(x1(max) == HASH_NAMESPACE::hash_value(max));
-    BOOST_CHECK(x1(half_max) == HASH_NAMESPACE::hash_value(half_max));
-    BOOST_CHECK(x1(quarter_max) == HASH_NAMESPACE::hash_value(quarter_max));
-    BOOST_CHECK(x1(three_quarter_max) == HASH_NAMESPACE::hash_value(three_quarter_max));
+    BOOST_TEST(x1(max) == HASH_NAMESPACE::hash_value(max));
+    BOOST_TEST(x1(half_max) == HASH_NAMESPACE::hash_value(half_max));
+    BOOST_TEST(x1(quarter_max) == HASH_NAMESPACE::hash_value(quarter_max));
+    BOOST_TEST(x1(three_quarter_max) == HASH_NAMESPACE::hash_value(three_quarter_max));
 
     // The '!=' tests could legitimately fail, but with my hash it indicates a bug.
-    BOOST_CHECK(x1(max) == x1(max));
-    BOOST_CHECK(x1(max) != x1(quarter_max));
-    BOOST_CHECK(x1(max) != x1(half_max));
-    BOOST_CHECK(x1(max) != x1(three_quarter_max));
-    BOOST_CHECK(x1(quarter_max) == x1(quarter_max));
-    BOOST_CHECK(x1(quarter_max) != x1(half_max));
-    BOOST_CHECK(x1(quarter_max) != x1(three_quarter_max));
-    BOOST_CHECK(x1(half_max) == x1(half_max));
-    BOOST_CHECK(x1(half_max) != x1(three_quarter_max));
-    BOOST_CHECK(x1(three_quarter_max) == x1(three_quarter_max));
+    BOOST_TEST(x1(max) == x1(max));
+    BOOST_TEST(x1(max) != x1(quarter_max));
+    BOOST_TEST(x1(max) != x1(half_max));
+    BOOST_TEST(x1(max) != x1(three_quarter_max));
+    BOOST_TEST(x1(quarter_max) == x1(quarter_max));
+    BOOST_TEST(x1(quarter_max) != x1(half_max));
+    BOOST_TEST(x1(quarter_max) != x1(three_quarter_max));
+    BOOST_TEST(x1(half_max) == x1(half_max));
+    BOOST_TEST(x1(half_max) != x1(three_quarter_max));
+    BOOST_TEST(x1(three_quarter_max) == x1(three_quarter_max));
 
 // Intel with gcc stdlib sometimes segfaults on calls to asin and acos.
 #if !((defined(__INTEL_COMPILER) || defined(__ICL) || \
@@ -137,35 +137,35 @@
     T v1 = asin((T) 1);
     T v2 = acos((T) 0);
     if(v1 == v2)
-        BOOST_CHECK(x1(v1) == x1(v2));
-    BOOST_CHECK(x1(v1) == HASH_NAMESPACE::hash_value(v1));
-    BOOST_CHECK(x1(v2) == HASH_NAMESPACE::hash_value(v2));
+        BOOST_TEST(x1(v1) == x1(v2));
+    BOOST_TEST(x1(v1) == HASH_NAMESPACE::hash_value(v1));
+    BOOST_TEST(x1(v2) == HASH_NAMESPACE::hash_value(v2));
 #endif
 
-    BOOST_CHECK(x1(boost::hash_detail::limits<T>::epsilon()) ==
+    BOOST_TEST(x1(boost::hash_detail::limits<T>::epsilon()) ==
             HASH_NAMESPACE::hash_value(boost::hash_detail::limits<T>::epsilon()));
 
-    BOOST_CHECK(boost::hash_detail::limits<T>::epsilon() != (T) 0);
+    BOOST_TEST(boost::hash_detail::limits<T>::epsilon() != (T) 0);
     if(x1(boost::hash_detail::limits<T>::epsilon()) == x1((T) 0))
         std::cerr<<"x1(epsilon) == x1(0) == "<<x1((T) 0)<<"\n";
 
-    BOOST_CHECK(-boost::hash_detail::limits<T>::epsilon() != (T) 0);
+    BOOST_TEST(-boost::hash_detail::limits<T>::epsilon() != (T) 0);
     if(x1(-boost::hash_detail::limits<T>::epsilon()) == x1((T) 0))
         std::cerr<<"x1(-epsilon) == x1(0) == "<<x1((T) 0)<<"\n";
 
-    BOOST_CHECK((T) 1 + boost::hash_detail::limits<T>::epsilon() != (T) 1);
+    BOOST_TEST((T) 1 + boost::hash_detail::limits<T>::epsilon() != (T) 1);
     if(x1((T) 1 + boost::hash_detail::limits<T>::epsilon()) == x1((T) 1))
         std::cerr<<"x1(1 + epsilon) == x1(1) == "<<x1((T) 1)<<"\n";
 
-    BOOST_CHECK((T) 1 - boost::hash_detail::limits<T>::epsilon() != (T) 1);
+    BOOST_TEST((T) 1 - boost::hash_detail::limits<T>::epsilon() != (T) 1);
     if(x1((T) 1 - boost::hash_detail::limits<T>::epsilon()) == x1((T) 1))
         std::cerr<<"x1(1 - epsilon) == x1(1) == "<<x1((T) 1)<<"\n";
 
-    BOOST_CHECK((T) -1 + boost::hash_detail::limits<T>::epsilon() != (T) -1);
+    BOOST_TEST((T) -1 + boost::hash_detail::limits<T>::epsilon() != (T) -1);
     if(x1((T) -1 + boost::hash_detail::limits<T>::epsilon()) == x1((T) -1))
         std::cerr<<"x1(-1 + epsilon) == x1(-1) == "<<x1((T) -1)<<"\n";
 
-    BOOST_CHECK((T) -1 - boost::hash_detail::limits<T>::epsilon() != (T) -1);
+    BOOST_TEST((T) -1 - boost::hash_detail::limits<T>::epsilon() != (T) -1);
     if(x1((T) -1 - boost::hash_detail::limits<T>::epsilon()) == x1((T) -1))
         std::cerr<<"x1(-1 - epsilon) == x1(-1) == "<<x1((T) -1)<<"\n";
 
@@ -197,7 +197,7 @@
         if(x1(boost::hash_detail::limits<T>::quiet_NaN()) == x1(1.0)) {
             std::cerr<<"x1(quiet_NaN) == x1(1.0) == "<<x1(1.0)<<"\n";
         }
-        BOOST_CHECK(x1(boost::hash_detail::limits<T>::quiet_NaN()) ==
+        BOOST_TEST(x1(boost::hash_detail::limits<T>::quiet_NaN()) ==
             HASH_NAMESPACE::hash_value(boost::hash_detail::limits<T>::quiet_NaN()));
     }
 #endif

Modified: branches/release/libs/functional/hash/test/hash_friend_test.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_friend_test.cpp	(original)
+++ branches/release/libs/functional/hash/test/hash_friend_test.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -50,7 +50,7 @@
 #  endif
 #endif
 
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -61,13 +61,13 @@
 void custom_tests()
 {
     HASH_NAMESPACE::hash<test::custom<int> > custom_hasher;
-    BOOST_CHECK(custom_hasher(10) == 100u);
+    BOOST_TEST(custom_hasher(10) == 100u);
     test::custom<int> x(55);
-    BOOST_CHECK(custom_hasher(x) == 550u);
+    BOOST_TEST(custom_hasher(x) == 550u);
 
     {
         using namespace HASH_NAMESPACE;
-        BOOST_CHECK(custom_hasher(x) == hash_value(x));
+        BOOST_TEST(custom_hasher(x) == hash_value(x));
     }
 
     std::vector<test::custom<int> > custom_vector;
@@ -85,17 +85,17 @@
     HASH_NAMESPACE::hash_combine(seed2, 250u);
     HASH_NAMESPACE::hash_combine(seed2, 350u);
 
-    BOOST_CHECK(seed ==
+    BOOST_TEST(seed ==
             HASH_NAMESPACE::hash_range(custom_vector.begin(), custom_vector.end()));
-    BOOST_CHECK(seed == seed2);
+    BOOST_TEST(seed == seed2);
 }
 
 #endif // TEST_EXTENSIONS
 
-int test_main(int, char**)
+int main()
 {
 #ifdef TEST_EXTENSIONS
     custom_tests();
 #endif
-    return 0;
+    return boost::report_errors();
 }

Modified: branches/release/libs/functional/hash/test/hash_function_pointer_test.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_function_pointer_test.cpp	(original)
+++ branches/release/libs/functional/hash/test/hash_function_pointer_test.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -11,7 +11,7 @@
 #  include <boost/functional/hash.hpp>
 #endif
 
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #include <boost/limits.hpp>
 #include <boost/mpl/assert.hpp>
@@ -32,31 +32,31 @@
     HASH_NAMESPACE::hash<void(*)()> hasher_void;
     HASH_NAMESPACE::hash<int(*)(int)> hasher_int;
 
-    BOOST_CHECK(&void_func1 != &void_func2);
-    BOOST_CHECK(&int_func1 != &int_func2);
+    BOOST_TEST(&void_func1 != &void_func2);
+    BOOST_TEST(&int_func1 != &int_func2);
 
-    BOOST_CHECK(hasher_void(0) == hasher_void(0));
-    BOOST_CHECK(hasher_void(&void_func1) == hasher_void(&void_func1));
-    BOOST_CHECK(hasher_void(&void_func1) != hasher_void(&void_func2));
-    BOOST_CHECK(hasher_void(&void_func1) != hasher_void(0));
-    BOOST_CHECK(hasher_int(0) == hasher_int(0));
-    BOOST_CHECK(hasher_int(&int_func1) == hasher_int(&int_func1));
-    BOOST_CHECK(hasher_int(&int_func1) != hasher_int(&int_func2));
-    BOOST_CHECK(hasher_int(&int_func1) != hasher_int(0));
+    BOOST_TEST(hasher_void(0) == hasher_void(0));
+    BOOST_TEST(hasher_void(&void_func1) == hasher_void(&void_func1));
+    BOOST_TEST(hasher_void(&void_func1) != hasher_void(&void_func2));
+    BOOST_TEST(hasher_void(&void_func1) != hasher_void(0));
+    BOOST_TEST(hasher_int(0) == hasher_int(0));
+    BOOST_TEST(hasher_int(&int_func1) == hasher_int(&int_func1));
+    BOOST_TEST(hasher_int(&int_func1) != hasher_int(&int_func2));
+    BOOST_TEST(hasher_int(&int_func1) != hasher_int(0));
 #if defined(TEST_EXTENSIONS)
-    BOOST_CHECK(hasher_void(&void_func1)
+    BOOST_TEST(hasher_void(&void_func1)
             == HASH_NAMESPACE::hash_value(&void_func1));
-    BOOST_CHECK(hasher_int(&int_func1)
+    BOOST_TEST(hasher_int(&int_func1)
             == HASH_NAMESPACE::hash_value(&int_func1));
 
     // This isn't specified in Peter's proposal:
-    BOOST_CHECK(hasher_void(0) == 0);
+    BOOST_TEST(hasher_void(0) == 0);
 #endif
 }
 
-int test_main(int, char**)
+int main()
 {
     function_pointer_tests();
 
-    return 0;
+    return boost::report_errors();
 }

Modified: branches/release/libs/functional/hash/test/hash_fwd_test_1.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_fwd_test_1.cpp	(original)
+++ branches/release/libs/functional/hash/test/hash_fwd_test_1.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -7,7 +7,7 @@
 
 #include "./hash_fwd_test.hpp"
 
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #if defined(TEST_EXTENSIONS) && !defined(TEST_STD_INCLUDES)
 
@@ -24,8 +24,8 @@
     HASH_NAMESPACE::hash<test::test_type1<int> > hasher_test_int;
     HASH_NAMESPACE::hash<test::test_type1<std::string> > hasher_test_string;
 
-    BOOST_CHECK(hasher_int(5) == hasher_test_int(x));
-    BOOST_CHECK(hasher_string("Test") == hasher_test_string(y));
+    BOOST_TEST(hasher_int(5) == hasher_test_int(x));
+    BOOST_TEST(hasher_string("Test") == hasher_test_string(y));
 }
 
 void fwd_test2()
@@ -44,8 +44,8 @@
     HASH_NAMESPACE::hash<test::test_type2<int> > hasher_test_int;
     HASH_NAMESPACE::hash<test::test_type2<std::string> > hasher_test_string;
 
-    BOOST_CHECK(seed1 == hasher_test_int(x));
-    BOOST_CHECK(seed2 == hasher_test_string(y));
+    BOOST_TEST(seed1 == hasher_test_int(x));
+    BOOST_TEST(seed2 == hasher_test_string(y));
 }
 
 void fwd_test3()
@@ -75,19 +75,19 @@
     HASH_NAMESPACE::hash<test::test_type3<int> > hasher_test_int;
     HASH_NAMESPACE::hash<test::test_type3<std::string> > hasher_test_string;
 
-    BOOST_CHECK(seed1 == hasher_test_int(x));
-    BOOST_CHECK(seed2 == hasher_test_string(y));
+    BOOST_TEST(seed1 == hasher_test_int(x));
+    BOOST_TEST(seed2 == hasher_test_string(y));
 }
 
 #endif
 
-int test_main(int, char**)
+int main()
 {
 #ifdef TEST_EXTENSIONS
     fwd_test1();
     fwd_test2();
     fwd_test3();
 #endif
-    return 0;
+    return boost::report_errors();
 }
 

Modified: branches/release/libs/functional/hash/test/hash_fwd_test_2.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_fwd_test_2.cpp	(original)
+++ branches/release/libs/functional/hash/test/hash_fwd_test_2.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -8,7 +8,7 @@
 
 #include "./hash_fwd_test.hpp"
 
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 template <class T> void unused(T const&) {}
 
@@ -31,9 +31,9 @@
 }
 
 
-int test_main(int, char**)
+int main()
 {
     fwd_test();
-    return 0;
+    return boost::report_errors();
 }
 

Modified: branches/release/libs/functional/hash/test/hash_global_namespace_test.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_global_namespace_test.cpp	(original)
+++ branches/release/libs/functional/hash/test/hash_global_namespace_test.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -48,7 +48,7 @@
 #  endif
 #endif
 
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -59,13 +59,13 @@
 void custom_tests()
 {
     HASH_NAMESPACE::hash<custom> custom_hasher;
-    BOOST_CHECK(custom_hasher(10) == 100u);
+    BOOST_TEST(custom_hasher(10) == 100u);
     custom x(55);
-    BOOST_CHECK(custom_hasher(x) == 550u);
+    BOOST_TEST(custom_hasher(x) == 550u);
 
     {
         using namespace HASH_NAMESPACE;
-        BOOST_CHECK(custom_hasher(x) == hash_value(x));
+        BOOST_TEST(custom_hasher(x) == hash_value(x));
     }
 
     std::vector<custom> custom_vector;
@@ -83,19 +83,19 @@
     HASH_NAMESPACE::hash_combine(seed2, 250u);
     HASH_NAMESPACE::hash_combine(seed2, 350u);
 
-    BOOST_CHECK(seed ==
+    BOOST_TEST(seed ==
             HASH_NAMESPACE::hash_range(custom_vector.begin(), custom_vector.end()));
-    BOOST_CHECK(seed == seed2);
+    BOOST_TEST(seed == seed2);
 }
 
 #endif // TEST_EXTENSIONS
 
 
-int test_main(int, char**)
+int main()
 {
 #ifdef TEST_EXTENSIONS
     custom_tests();
 #endif
-    return 0;
+    return boost::report_errors();
 }
 

Modified: branches/release/libs/functional/hash/test/hash_list_test.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_list_test.cpp	(original)
+++ branches/release/libs/functional/hash/test/hash_list_test.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -13,7 +13,7 @@
 #  endif
 #endif
 
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -25,11 +25,11 @@
 
 #endif // TEST_EXTENSIONS
 
-int test_main(int, char**)
+int main()
 {
 #ifdef TEST_EXTENSIONS
     list_tests::list_hash_integer_tests();
 #endif
 
-    return 0;
+    return boost::report_errors();
 }

Modified: branches/release/libs/functional/hash/test/hash_long_double_test.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_long_double_test.cpp	(original)
+++ branches/release/libs/functional/hash/test/hash_long_double_test.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -5,7 +5,7 @@
 
 #include "hash_float_test.hpp"
 
-int test_main(int, char**)
+int main()
 {
     std::cerr<<"Compiler: "<<BOOST_COMPILER<<"\n";
     std::cerr<<"Platform: "<<BOOST_PLATFORM<<"\n";
@@ -13,5 +13,5 @@
 
     float_tests("long double", (long double*) 0);
 
-    return 0;
+    return boost::report_errors();
 }

Modified: branches/release/libs/functional/hash/test/hash_map_test.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_map_test.cpp	(original)
+++ branches/release/libs/functional/hash/test/hash_map_test.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -13,7 +13,7 @@
 #  endif
 #endif
 
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #include <map>
 
@@ -29,12 +29,12 @@
 
 #endif // TEST_EXTENSTIONS
 
-int test_main(int, char**)
+int main()
 {
 #ifdef TEST_EXTENSIONS
     map_tests::map_hash_integer_tests();
     multimap_tests::multimap_hash_integer_tests();
 #endif
 
-    return 0;
+    return boost::report_errors();
 }

Modified: branches/release/libs/functional/hash/test/hash_map_test.hpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_map_test.hpp	(original)
+++ branches/release/libs/functional/hash/test/hash_map_test.hpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -38,17 +38,17 @@
         HASH_NAMESPACE::hash<T> hasher;
 
         for(int i2 = 0; i2 < number_of_containers; ++i2) {
-            BOOST_CHECK(hasher(containers[i2]) == hasher(containers[i2]));
+            BOOST_TEST(hasher(containers[i2]) == hasher(containers[i2]));
 
-            BOOST_CHECK(hasher(containers[i2]) ==
+            BOOST_TEST(hasher(containers[i2]) ==
                     HASH_NAMESPACE::hash_value(containers[i2]));
 
-            BOOST_CHECK(hasher(containers[i2])
+            BOOST_TEST(hasher(containers[i2])
                     == HASH_NAMESPACE::hash_range(
                         containers[i2].begin(), containers[i2].end()));
 
             for(int j2 = i2 + 1; j2 < number_of_containers; ++j2) {
-                BOOST_CHECK(
+                BOOST_TEST(
                         (containers[i2] == containers[j2]) ==
                         (hasher(containers[i2]) == hasher(containers[j2]))
                         );

Modified: branches/release/libs/functional/hash/test/hash_no_ext_fail_test.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_no_ext_fail_test.cpp	(original)
+++ branches/release/libs/functional/hash/test/hash_no_ext_fail_test.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -12,7 +12,7 @@
 #include <boost/functional/hash.hpp>
 #include <boost/functional/hash.hpp>
 
-int test_main(int, char**)
+int main()
 {
     HASH_NAMESPACE::hash< int[10] > hasher;
     return 0;

Modified: branches/release/libs/functional/hash/test/hash_no_ext_macro_1.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_no_ext_macro_1.cpp	(original)
+++ branches/release/libs/functional/hash/test/hash_no_ext_macro_1.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -7,11 +7,11 @@
 #include <boost/functional/hash.hpp>
 #define BOOST_HASH_NO_EXTENSIONS
 #include <boost/functional/hash.hpp>
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <deque>
 #include <cassert>
 
-int test_main(int, char**)
+int main()
 {
     std::deque<int> x;
 
@@ -19,7 +19,7 @@
     x.push_back(2);
 
     HASH_NAMESPACE::hash<std::deque<int> > hasher;
-    BOOST_CHECK(hasher(x) == HASH_NAMESPACE::hash_value(x));
+    BOOST_TEST(hasher(x) == HASH_NAMESPACE::hash_value(x));
 
-    return 0;
+    return boost::report_errors();
 }

Modified: branches/release/libs/functional/hash/test/hash_no_ext_macro_2.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_no_ext_macro_2.cpp	(original)
+++ branches/release/libs/functional/hash/test/hash_no_ext_macro_2.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -8,10 +8,10 @@
 #include <boost/functional/hash.hpp>
 #undef BOOST_HASH_NO_EXTENSIONS
 #include <boost/functional/hash.hpp>
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <map>
 
-int test_main(int, char**)
+int main()
 {
     std::map<int, int> x;
 
@@ -19,7 +19,7 @@
     x.insert(std::map<int, int>::value_type(14, -75));
 
     HASH_NAMESPACE::hash<std::map<int, int> > hasher;
-    BOOST_CHECK(hasher(x) == HASH_NAMESPACE::hash_value(x));
+    BOOST_TEST(hasher(x) == HASH_NAMESPACE::hash_value(x));
     
-    return 0;
+    return boost::report_errors();
 }

Modified: branches/release/libs/functional/hash/test/hash_number_test.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_number_test.cpp	(original)
+++ branches/release/libs/functional/hash/test/hash_number_test.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -12,7 +12,7 @@
 #endif
 
 #include <iostream>
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #include <boost/preprocessor/cat.hpp>
 #include <boost/limits.hpp>
@@ -39,27 +39,27 @@
     HASH_NAMESPACE::hash<T> x2;
 
     T v1 = (T) -5;
-    BOOST_CHECK(x1(v1) == x2(v1));
-    BOOST_CHECK(x1(T(-5)) == x2(T(-5)));
-    BOOST_CHECK(x1(T(0)) == x2(T(0)));
-    BOOST_CHECK(x1(T(10)) == x2(T(10)));
-    BOOST_CHECK(x1(T(25)) == x2(T(25)));
-    BOOST_CHECK(x1(T(5) - T(5)) == x2(T(0)));
-    BOOST_CHECK(x1(T(6) + T(4)) == x2(T(10)));
+    BOOST_TEST(x1(v1) == x2(v1));
+    BOOST_TEST(x1(T(-5)) == x2(T(-5)));
+    BOOST_TEST(x1(T(0)) == x2(T(0)));
+    BOOST_TEST(x1(T(10)) == x2(T(10)));
+    BOOST_TEST(x1(T(25)) == x2(T(25)));
+    BOOST_TEST(x1(T(5) - T(5)) == x2(T(0)));
+    BOOST_TEST(x1(T(6) + T(4)) == x2(T(10)));
 
 #if defined(TEST_EXTENSIONS)
-    BOOST_CHECK(x1(T(-5)) == HASH_NAMESPACE::hash_value(T(-5)));
-    BOOST_CHECK(x1(T(0)) == HASH_NAMESPACE::hash_value(T(0)));
-    BOOST_CHECK(x1(T(10)) == HASH_NAMESPACE::hash_value(T(10)));
-    BOOST_CHECK(x1(T(25)) == HASH_NAMESPACE::hash_value(T(25)));
+    BOOST_TEST(x1(T(-5)) == HASH_NAMESPACE::hash_value(T(-5)));
+    BOOST_TEST(x1(T(0)) == HASH_NAMESPACE::hash_value(T(0)));
+    BOOST_TEST(x1(T(10)) == HASH_NAMESPACE::hash_value(T(10)));
+    BOOST_TEST(x1(T(25)) == HASH_NAMESPACE::hash_value(T(25)));
 
     if (limits::is_integer)
     {
         if(limits::is_signed || limits::digits <= boost::hash_detail::limits<std::size_t>::digits)
-            BOOST_CHECK(HASH_NAMESPACE::hash_value(T(-5)) == (std::size_t)T(-5));
-        BOOST_CHECK(HASH_NAMESPACE::hash_value(T(0)) == (std::size_t)T(0u));
-        BOOST_CHECK(HASH_NAMESPACE::hash_value(T(10)) == (std::size_t)T(10u));
-        BOOST_CHECK(HASH_NAMESPACE::hash_value(T(25)) == (std::size_t)T(25u));
+            BOOST_TEST(HASH_NAMESPACE::hash_value(T(-5)) == (std::size_t)T(-5));
+        BOOST_TEST(HASH_NAMESPACE::hash_value(T(0)) == (std::size_t)T(0u));
+        BOOST_TEST(HASH_NAMESPACE::hash_value(T(10)) == (std::size_t)T(10u));
+        BOOST_TEST(HASH_NAMESPACE::hash_value(T(25)) == (std::size_t)T(25u));
     }
 #endif
 }
@@ -77,18 +77,18 @@
         T min_value = (limits::min)();
         T max_value = (limits::max)();
 
-        BOOST_CHECK(x1(min_value) == x2((limits::min)()));
-        BOOST_CHECK(x1(max_value) == x2((limits::max)()));
+        BOOST_TEST(x1(min_value) == x2((limits::min)()));
+        BOOST_TEST(x1(max_value) == x2((limits::max)()));
 
 #if defined(TEST_EXTENSIONS)
-        BOOST_CHECK(x1(min_value) == HASH_NAMESPACE::hash_value(min_value));
-        BOOST_CHECK(x1(max_value) == HASH_NAMESPACE::hash_value(max_value));
+        BOOST_TEST(x1(min_value) == HASH_NAMESPACE::hash_value(min_value));
+        BOOST_TEST(x1(max_value) == HASH_NAMESPACE::hash_value(max_value));
 
         if (limits::is_integer)
         {
-            BOOST_CHECK(HASH_NAMESPACE::hash_value(min_value)
+            BOOST_TEST(HASH_NAMESPACE::hash_value(min_value)
                     == std::size_t(min_value));
-            BOOST_CHECK(HASH_NAMESPACE::hash_value(max_value)
+            BOOST_TEST(HASH_NAMESPACE::hash_value(max_value)
                     == std::size_t(max_value));
         }
 #endif
@@ -106,11 +106,11 @@
     // A hash function can legally fail these tests, but it'll not be a good
     // sign.
     if(T(1) != T(-1))
-        BOOST_CHECK(x1(T(1)) !=  x2(T(-1)));
+        BOOST_TEST(x1(T(1)) !=  x2(T(-1)));
     if(T(1) != T(2))
-        BOOST_CHECK(x1(T(1)) !=  x2(T(2)));
+        BOOST_TEST(x1(T(1)) !=  x2(T(2)));
     if((limits::max)() != (limits::max)() - 1)
-        BOOST_CHECK(x1((limits::max)()) != x2((limits::max)() - 1));
+        BOOST_TEST(x1((limits::max)()) != x2((limits::max)() - 1));
 }
 
 void bool_test()
@@ -118,10 +118,10 @@
     HASH_NAMESPACE::hash<bool> x1;
     HASH_NAMESPACE::hash<bool> x2;
     
-    BOOST_CHECK(x1(true) == x2(true));
-    BOOST_CHECK(x1(false) == x2(false));
-    BOOST_CHECK(x1(true) != x2(false));
-    BOOST_CHECK(x1(false) != x2(true));
+    BOOST_TEST(x1(true) == x2(true));
+    BOOST_TEST(x1(false) == x2(false));
+    BOOST_TEST(x1(true) != x2(false));
+    BOOST_TEST(x1(false) != x2(true));
 }
 
 #define NUMERIC_TEST(type, name) \
@@ -134,7 +134,7 @@
     numeric_test((type*) 0); \
     poor_quality_tests((type*) 0);
 
-int test_main(int, char**)
+int main()
 {
     NUMERIC_TEST(char, char)
     NUMERIC_TEST(signed char, schar)
@@ -159,7 +159,7 @@
 
     bool_test();
 
-    return 0;
+    return boost::report_errors();
 }
 
 #if defined(BOOST_MSVC)

Modified: branches/release/libs/functional/hash/test/hash_pointer_test.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_pointer_test.cpp	(original)
+++ branches/release/libs/functional/hash/test/hash_pointer_test.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -11,7 +11,7 @@
 #  include <boost/functional/hash.hpp>
 #endif
 
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #include <boost/limits.hpp>
 #include <boost/mpl/assert.hpp>
@@ -30,20 +30,20 @@
     int int1;
     int int2;
 
-    BOOST_CHECK(x1(0) == x2(0));
-    BOOST_CHECK(x1(&int1) == x2(&int1));
-    BOOST_CHECK(x1(&int2) == x2(&int2));
+    BOOST_TEST(x1(0) == x2(0));
+    BOOST_TEST(x1(&int1) == x2(&int1));
+    BOOST_TEST(x1(&int2) == x2(&int2));
 #if defined(TEST_EXTENSIONS)
-    BOOST_CHECK(x1(&int1) == HASH_NAMESPACE::hash_value(&int1));
-    BOOST_CHECK(x1(&int2) == HASH_NAMESPACE::hash_value(&int2));
+    BOOST_TEST(x1(&int1) == HASH_NAMESPACE::hash_value(&int1));
+    BOOST_TEST(x1(&int2) == HASH_NAMESPACE::hash_value(&int2));
 
     // This isn't specified in Peter's proposal:
-    BOOST_CHECK(x1(0) == 0);
+    BOOST_TEST(x1(0) == 0);
 #endif
 }
 
-int test_main(int, char**)
+int main()
 {
     pointer_tests();
-    return 0;
+    return boost::report_errors();
 }

Modified: branches/release/libs/functional/hash/test/hash_range_test.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_range_test.cpp	(original)
+++ branches/release/libs/functional/hash/test/hash_range_test.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -13,7 +13,7 @@
 #  endif
 #endif
 
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -41,45 +41,45 @@
     std::vector<int> x;
 
     std::size_t x_seed = 0;
-    BOOST_CHECK(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
+    BOOST_TEST(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
 
-    BOOST_CHECK(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
+    BOOST_TEST(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
         == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
-    BOOST_CHECK(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
+    BOOST_TEST(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
         != HASH_NAMESPACE::hash_range(values1.begin(), values1.end()));
 
     x.push_back(10);
     HASH_NAMESPACE::hash_combine(x_seed, 10);
-    BOOST_CHECK(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
+    BOOST_TEST(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
 
-    BOOST_CHECK(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
+    BOOST_TEST(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
         != HASH_NAMESPACE::hash_range(x.begin(), x.end()));
-    BOOST_CHECK(HASH_NAMESPACE::hash_range(values2.begin(), values2.end())
+    BOOST_TEST(HASH_NAMESPACE::hash_range(values2.begin(), values2.end())
         == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
 
     x.push_back(20);
     HASH_NAMESPACE::hash_combine(x_seed, 20);
-    BOOST_CHECK(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
+    BOOST_TEST(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
 
-    BOOST_CHECK(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
+    BOOST_TEST(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
         != HASH_NAMESPACE::hash_range(x.begin(), x.end()));
-    BOOST_CHECK(HASH_NAMESPACE::hash_range(values2.begin(), values2.end())
+    BOOST_TEST(HASH_NAMESPACE::hash_range(values2.begin(), values2.end())
         != HASH_NAMESPACE::hash_range(x.begin(), x.end()));
-    BOOST_CHECK(HASH_NAMESPACE::hash_range(values3.begin(), values3.end())
+    BOOST_TEST(HASH_NAMESPACE::hash_range(values3.begin(), values3.end())
         == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
 
     std::size_t seed = HASH_NAMESPACE::hash_range(values3.begin(), values3.end());
     HASH_NAMESPACE::hash_range(seed, values4.begin(), values4.end());
     HASH_NAMESPACE::hash_range(seed, x.begin(), x.end());
-    BOOST_CHECK(seed == HASH_NAMESPACE::hash_range(values5.begin(), values5.end()));
+    BOOST_TEST(seed == HASH_NAMESPACE::hash_range(values5.begin(), values5.end()));
 }
 
 #endif
 
-int test_main(int, char**)
+int main()
 {
     hash_range_tests();
 
-    return 0;
+    return boost::report_errors();
 }
 

Modified: branches/release/libs/functional/hash/test/hash_sequence_test.hpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_sequence_test.hpp	(original)
+++ branches/release/libs/functional/hash/test/hash_sequence_test.hpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -41,17 +41,17 @@
         HASH_NAMESPACE::hash<T> hasher;
 
         for(int i2 = 0; i2 < number_of_containers; ++i2) {
-            BOOST_CHECK(hasher(containers[i2]) == hasher(containers[i2]));
+            BOOST_TEST(hasher(containers[i2]) == hasher(containers[i2]));
 
-            BOOST_CHECK(hasher(containers[i2]) ==
+            BOOST_TEST(hasher(containers[i2]) ==
                     HASH_NAMESPACE::hash_value(containers[i2]));
 
-            BOOST_CHECK(hasher(containers[i2])
+            BOOST_TEST(hasher(containers[i2])
                     == HASH_NAMESPACE::hash_range(
                         containers[i2].begin(), containers[i2].end()));
 
             for(int j2 = i2 + 1; j2 < number_of_containers; ++j2) {
-                BOOST_CHECK(
+                BOOST_TEST(
                         (containers[i2] == containers[j2]) ==
                         (hasher(containers[i2]) == hasher(containers[j2]))
                         );

Modified: branches/release/libs/functional/hash/test/hash_set_test.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_set_test.cpp	(original)
+++ branches/release/libs/functional/hash/test/hash_set_test.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -13,7 +13,7 @@
 #  endif
 #endif
 
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -29,12 +29,12 @@
 
 #endif
 
-int test_main(int, char**)
+int main()
 {
 #ifdef TEST_EXTENSIONS
     set_tests::set_hash_integer_tests();
     multiset_tests::multiset_hash_integer_tests();
 #endif
 
-    return 0;
+    return boost::report_errors();
 }

Modified: branches/release/libs/functional/hash/test/hash_set_test.hpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_set_test.hpp	(original)
+++ branches/release/libs/functional/hash/test/hash_set_test.hpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -44,17 +44,17 @@
         HASH_NAMESPACE::hash<T> hasher;
 
         for(int i2 = 0; i2 < number_of_containers; ++i2) {
-            BOOST_CHECK(hasher(containers[i2]) == hasher(containers[i2]));
+            BOOST_TEST(hasher(containers[i2]) == hasher(containers[i2]));
 
-            BOOST_CHECK(hasher(containers[i2]) ==
+            BOOST_TEST(hasher(containers[i2]) ==
                     HASH_NAMESPACE::hash_value(containers[i2]));
 
-            BOOST_CHECK(hasher(containers[i2])
+            BOOST_TEST(hasher(containers[i2])
                     == HASH_NAMESPACE::hash_range(
                         containers[i2].begin(), containers[i2].end()));
 
             for(int j2 = i2 + 1; j2 < number_of_containers; ++j2) {
-                BOOST_CHECK(
+                BOOST_TEST(
                         (containers[i2] == containers[j2]) ==
                         (hasher(containers[i2]) == hasher(containers[j2]))
                         );

Modified: branches/release/libs/functional/hash/test/hash_string_test.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_string_test.cpp	(original)
+++ branches/release/libs/functional/hash/test/hash_string_test.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -11,7 +11,7 @@
 #  include <boost/functional/hash.hpp>
 #endif
 
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #include <boost/limits.hpp>
 #include <boost/mpl/assert.hpp>
@@ -27,18 +27,18 @@
     HASH_NAMESPACE::hash<std::string> x1;
     HASH_NAMESPACE::hash<std::string> x2;
 
-    BOOST_CHECK(x1("Hello") == x2(std::string("Hel") + "lo"));
-    BOOST_CHECK(x1("") == x2(std::string()));
+    BOOST_TEST(x1("Hello") == x2(std::string("Hel") + "lo"));
+    BOOST_TEST(x1("") == x2(std::string()));
 
 #if defined(TEST_EXTENSIONS)
     std::string value1;
     std::string value2("Hello");
 
-    BOOST_CHECK(x1(value1) == HASH_NAMESPACE::hash_value(value1));
-    BOOST_CHECK(x1(value2) == HASH_NAMESPACE::hash_value(value2));
-    BOOST_CHECK(HASH_NAMESPACE::hash_value(value1) ==
+    BOOST_TEST(x1(value1) == HASH_NAMESPACE::hash_value(value1));
+    BOOST_TEST(x1(value2) == HASH_NAMESPACE::hash_value(value2));
+    BOOST_TEST(HASH_NAMESPACE::hash_value(value1) ==
             HASH_NAMESPACE::hash_range(value1.begin(), value1.end()));
-    BOOST_CHECK(HASH_NAMESPACE::hash_value(value2) ==
+    BOOST_TEST(HASH_NAMESPACE::hash_value(value2) ==
             HASH_NAMESPACE::hash_range(value2.begin(), value2.end()));
 #endif
 }
@@ -51,28 +51,28 @@
     HASH_NAMESPACE::hash<std::wstring> x1;
     HASH_NAMESPACE::hash<std::wstring> x2;
 
-    BOOST_CHECK(x1(L"Hello") == x2(std::wstring(L"Hel") + L"lo"));
-    BOOST_CHECK(x1(L"") == x2(std::wstring()));
+    BOOST_TEST(x1(L"Hello") == x2(std::wstring(L"Hel") + L"lo"));
+    BOOST_TEST(x1(L"") == x2(std::wstring()));
 
 #if defined(TEST_EXTENSIONS)
     std::wstring value1;
     std::wstring value2(L"Hello");
 
-    BOOST_CHECK(x1(value1) == HASH_NAMESPACE::hash_value(value1));
-    BOOST_CHECK(x1(value2) == HASH_NAMESPACE::hash_value(value2));
-    BOOST_CHECK(HASH_NAMESPACE::hash_value(value1) ==
+    BOOST_TEST(x1(value1) == HASH_NAMESPACE::hash_value(value1));
+    BOOST_TEST(x1(value2) == HASH_NAMESPACE::hash_value(value2));
+    BOOST_TEST(HASH_NAMESPACE::hash_value(value1) ==
             HASH_NAMESPACE::hash_range(value1.begin(), value1.end()));
-    BOOST_CHECK(HASH_NAMESPACE::hash_value(value2) ==
+    BOOST_TEST(HASH_NAMESPACE::hash_value(value2) ==
             HASH_NAMESPACE::hash_range(value2.begin(), value2.end()));
 #endif
 }
 #endif
 
-int test_main(int, char**)
+int main()
 {
     string_tests();
 #if !defined(BOOST_NO_STD_WSTRING)
     wstring_tests();
 #endif
-    return 0;
+    return boost::report_errors();
 }

Modified: branches/release/libs/functional/hash/test/hash_value_array_test.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_value_array_test.cpp	(original)
+++ branches/release/libs/functional/hash/test/hash_value_array_test.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -16,7 +16,7 @@
 #  endif
 #endif
 
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -37,9 +37,9 @@
     int array3[2] = {2, 3};
     HASH_NAMESPACE::hash<int[2]> hasher3;
 
-    BOOST_CHECK(hasher1(array1) == HASH_NAMESPACE::hash_value(array1));
-    BOOST_CHECK(hasher2(array2) == HASH_NAMESPACE::hash_value(array2));
-    BOOST_CHECK(hasher3(array3) == HASH_NAMESPACE::hash_value(array3));
+    BOOST_TEST(hasher1(array1) == HASH_NAMESPACE::hash_value(array1));
+    BOOST_TEST(hasher2(array2) == HASH_NAMESPACE::hash_value(array2));
+    BOOST_TEST(hasher3(array3) == HASH_NAMESPACE::hash_value(array3));
 }
 
 void two_dimensional_array_test()
@@ -47,18 +47,18 @@
     int array[3][2] = {{-5, 6}, {7, -3}, {26, 1}};
     HASH_NAMESPACE::hash<int[3][2]> hasher;
 
-    BOOST_CHECK(hasher(array) == HASH_NAMESPACE::hash_value(array));
+    BOOST_TEST(hasher(array) == HASH_NAMESPACE::hash_value(array));
 }
 
 #endif
 
-int test_main(int, char**)
+int main()
 {
 #ifdef TEST_EXTENSIONS
     array_int_test();
     two_dimensional_array_test();
 #endif
 
-    return 0;
+    return boost::report_errors();
 }
 

Modified: branches/release/libs/functional/hash/test/hash_vector_test.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/hash_vector_test.cpp	(original)
+++ branches/release/libs/functional/hash/test/hash_vector_test.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -13,7 +13,7 @@
 #  endif
 #endif
 
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -25,11 +25,11 @@
 
 #endif // TEST_EXTENSIONS
 
-int test_main(int, char**)
+int main()
 {
 #ifdef TEST_EXTENSIONS
     vector_tests::vector_hash_integer_tests();
 #endif
 
-    return 0;
+    return boost::report_errors();
 }

Modified: branches/release/libs/functional/hash/test/link_ext_test.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/link_ext_test.cpp	(original)
+++ branches/release/libs/functional/hash/test/link_ext_test.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -5,13 +5,13 @@
 
 #define HASH_NAMESPACE boost
 #include <boost/functional/hash.hpp>
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <vector>
 
 int f(std::size_t hash1, int* x1) {
     // Check that HASH_NAMESPACE::hash<int*> works in both files.
     HASH_NAMESPACE::hash<int*> ptr_hasher;
-    BOOST_CHECK(hash1 == ptr_hasher(x1));
+    BOOST_TEST(hash1 == ptr_hasher(x1));
 
     // Check that std::vector<std::size_t> is avaiable in this file.
     std::vector<std::size_t> x;

Modified: branches/release/libs/functional/hash/test/link_no_ext_test.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/link_no_ext_test.cpp	(original)
+++ branches/release/libs/functional/hash/test/link_no_ext_test.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -6,14 +6,13 @@
 #define HASH_NAMESPACE boost
 #define BOOST_HASH_NO_EXTENSIONS
 #include <boost/functional/hash.hpp>
-#include <boost/assert.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 extern int f(std::size_t, int*);
 
-int test_main(int, char**) {
+int main() {
     HASH_NAMESPACE::hash<int*> ptr_hasher;
     int x = 55;
-
-    BOOST_ASSERT(!f(ptr_hasher(&x), &x));
-    return 0;
+    BOOST_TEST(!f(ptr_hasher(&x), &x));
+    return boost::report_errors();
 }

Modified: branches/release/libs/functional/hash/test/link_test.cpp
==============================================================================
--- branches/release/libs/functional/hash/test/link_test.cpp	(original)
+++ branches/release/libs/functional/hash/test/link_test.cpp	2008-07-19 05:02:10 EDT (Sat, 19 Jul 2008)
@@ -6,4 +6,4 @@
 #include <boost/functional/hash.hpp>
 
 extern int f();
-int main(int, char**) { return f(); }
+int main() { return f(); }