Boost logo

Boost-Commit :

From: daniel_james_at_[hidden]
Date: 2008-04-14 14:02:08


Author: danieljames
Date: 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
New Revision: 44420
URL: http://svn.boost.org/trac/boost/changeset/44420

Log:
Use Boost.Test's minimal test library.
Text files modified:
   branches/unordered/trunk/libs/functional/hash/test/container_fwd_test.cpp | 2
   branches/unordered/trunk/libs/functional/hash/test/hash_built_in_array_test.cpp | 16 ++--
   branches/unordered/trunk/libs/functional/hash/test/hash_complex_test.cpp | 10 +-
   branches/unordered/trunk/libs/functional/hash/test/hash_custom_test.cpp | 16 ++--
   branches/unordered/trunk/libs/functional/hash/test/hash_deprecated_headers.cpp | 2
   branches/unordered/trunk/libs/functional/hash/test/hash_deque_test.cpp | 6
   branches/unordered/trunk/libs/functional/hash/test/hash_float_test.cpp | 4
   branches/unordered/trunk/libs/functional/hash/test/hash_float_test.hpp | 76 ++++++++++++------------
   branches/unordered/trunk/libs/functional/hash/test/hash_friend_test.cpp | 16 ++--
   branches/unordered/trunk/libs/functional/hash/test/hash_function_pointer_test.cpp | 32 +++++-----
   branches/unordered/trunk/libs/functional/hash/test/hash_fwd_test_1.cpp | 18 ++--
   branches/unordered/trunk/libs/functional/hash/test/hash_fwd_test_2.cpp | 6
   branches/unordered/trunk/libs/functional/hash/test/hash_global_namespace_test.cpp | 16 ++--
   branches/unordered/trunk/libs/functional/hash/test/hash_list_test.cpp | 6
   branches/unordered/trunk/libs/functional/hash/test/hash_long_double_test.cpp | 4
   branches/unordered/trunk/libs/functional/hash/test/hash_map_test.cpp | 6
   branches/unordered/trunk/libs/functional/hash/test/hash_map_test.hpp | 8 +-
   branches/unordered/trunk/libs/functional/hash/test/hash_no_ext_fail_test.cpp | 2
   branches/unordered/trunk/libs/functional/hash/test/hash_no_ext_macro_1.cpp | 8 +-
   branches/unordered/trunk/libs/functional/hash/test/hash_no_ext_macro_2.cpp | 8 +-
   branches/unordered/trunk/libs/functional/hash/test/hash_number_test.cpp | 62 ++++++++++----------
   branches/unordered/trunk/libs/functional/hash/test/hash_pointer_test.cpp | 18 ++--
   branches/unordered/trunk/libs/functional/hash/test/hash_range_test.cpp | 28 ++++----
   branches/unordered/trunk/libs/functional/hash/test/hash_sequence_test.hpp | 8 +-
   branches/unordered/trunk/libs/functional/hash/test/hash_set_test.cpp | 6
   branches/unordered/trunk/libs/functional/hash/test/hash_set_test.hpp | 8 +-
   branches/unordered/trunk/libs/functional/hash/test/hash_string_test.cpp | 30 ++++----
   branches/unordered/trunk/libs/functional/hash/test/hash_value_array_test.cpp | 14 ++--
   branches/unordered/trunk/libs/functional/hash/test/hash_vector_test.cpp | 6
   branches/unordered/trunk/libs/functional/hash/test/link_ext_test.cpp | 4
   branches/unordered/trunk/libs/functional/hash/test/link_no_ext_test.cpp | 9 +-
   branches/unordered/trunk/libs/functional/hash/test/link_test.cpp | 2
   branches/unordered/trunk/libs/unordered/test/exception/erase_exception_tests.cpp | 2
   branches/unordered/trunk/libs/unordered/test/exception/insert_exception_tests.cpp | 14 ++--
   branches/unordered/trunk/libs/unordered/test/exception/swap_exception_tests.cpp | 4
   branches/unordered/trunk/libs/unordered/test/helpers/exception_test.hpp | 6
   branches/unordered/trunk/libs/unordered/test/helpers/test.hpp | 10 --
   branches/unordered/trunk/libs/unordered/test/helpers/tracker.hpp | 4
   branches/unordered/trunk/libs/unordered/test/objects/memory.hpp | 18 ++--
   branches/unordered/trunk/libs/unordered/test/unordered/assign_tests.cpp | 18 ++--
   branches/unordered/trunk/libs/unordered/test/unordered/at_tests.cpp | 4
   branches/unordered/trunk/libs/unordered/test/unordered/bucket_tests.cpp | 14 ++--
   branches/unordered/trunk/libs/unordered/test/unordered/compile_tests.hpp | 10 +-
   branches/unordered/trunk/libs/unordered/test/unordered/constructor_tests.cpp | 122 ++++++++++++++++++++--------------------
   branches/unordered/trunk/libs/unordered/test/unordered/copy_tests.cpp | 36 +++++-----
   branches/unordered/trunk/libs/unordered/test/unordered/erase_equiv_tests.cpp | 12 +-
   branches/unordered/trunk/libs/unordered/test/unordered/erase_tests.cpp | 46 +++++++-------
   branches/unordered/trunk/libs/unordered/test/unordered/find_tests.cpp | 20 +++---
   branches/unordered/trunk/libs/unordered/test/unordered/insert_stable_tests.cpp | 28 ++++----
   branches/unordered/trunk/libs/unordered/test/unordered/insert_tests.cpp | 97 ++++++++++++++++---------------
   branches/unordered/trunk/libs/unordered/test/unordered/load_factor_tests.cpp | 10 +-
   branches/unordered/trunk/libs/unordered/test/unordered/move_tests.cpp | 44 +++++++-------
   branches/unordered/trunk/libs/unordered/test/unordered/rehash_tests.cpp | 12 +-
   branches/unordered/trunk/libs/unordered/test/unordered/simple_tests.cpp | 46 +++++++-------
   branches/unordered/trunk/libs/unordered/test/unordered/unnecessary_copy_tests.cpp | 4
   55 files changed, 518 insertions(+), 520 deletions(-)

Modified: branches/unordered/trunk/libs/functional/hash/test/container_fwd_test.cpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/container_fwd_test.cpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/container_fwd_test.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -77,7 +77,7 @@
 #include <complex>
 #include <utility>
 
-int main()
+int main(int, char**)
 {
     std::deque<int> x1;
     std::list<std::string> x2;

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

Modified: branches/unordered/trunk/libs/functional/hash/test/hash_complex_test.cpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/hash_complex_test.cpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/hash_complex_test.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -13,7 +13,7 @@
 # endif
 #endif
 
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/test/minimal.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -41,13 +41,13 @@
 {
     HASH_NAMESPACE::hash<std::complex<T> > complex_hasher;
 
- BOOST_TEST(complex_hasher(v) == complex_hasher(v));
+ BOOST_CHECK(complex_hasher(v) == complex_hasher(v));
 
     HASH_NAMESPACE::hash<T> real_hasher;
     T real = v.real();
     T imag = v.imag();
 
- BOOST_TEST(real_hasher(real) == complex_hasher(std::complex<T>(real)));
+ BOOST_CHECK(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 main()
+int test_main(int, char**)
 {
     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 boost::report_errors();
+ return 0;
 }
 
 #endif

Modified: branches/unordered/trunk/libs/functional/hash/test/hash_custom_test.cpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/hash_custom_test.cpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/hash_custom_test.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -48,7 +48,7 @@
 # endif
 #endif
 
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/test/minimal.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -59,13 +59,13 @@
 void custom_tests()
 {
     HASH_NAMESPACE::hash<test::custom> custom_hasher;
- BOOST_TEST(custom_hasher(10) == 100u);
+ BOOST_CHECK(custom_hasher(10) == 100u);
     test::custom x(55);
- BOOST_TEST(custom_hasher(x) == 550u);
+ BOOST_CHECK(custom_hasher(x) == 550u);
 
     {
         using namespace HASH_NAMESPACE;
- BOOST_TEST(custom_hasher(x) == hash_value(x));
+ BOOST_CHECK(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_TEST(seed ==
+ BOOST_CHECK(seed ==
             HASH_NAMESPACE::hash_range(custom_vector.begin(), custom_vector.end()));
- BOOST_TEST(seed == seed2);
+ BOOST_CHECK(seed == seed2);
 }
 
 #endif // TEST_EXTENSIONS
 
-int main()
+int test_main(int, char**)
 {
 #ifdef TEST_EXTENSIONS
     custom_tests();
 #endif
- return boost::report_errors();
+ return 0;
 }

Modified: branches/unordered/trunk/libs/functional/hash/test/hash_deprecated_headers.cpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/hash_deprecated_headers.cpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/hash_deprecated_headers.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -19,7 +19,7 @@
 
 #include <vector>
 
-int main() {
+int main(int, char**) {
     std::vector<int> v;
     boost::hash<std::vector<int> > x;
     x(v);

Modified: branches/unordered/trunk/libs/functional/hash/test/hash_deque_test.cpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/hash_deque_test.cpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/hash_deque_test.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -13,7 +13,7 @@
 # endif
 #endif
 
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/test/minimal.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -25,11 +25,11 @@
 
 #endif // TEST_EXTENSIONS
 
-int main()
+int test_main(int, char**)
 {
 #ifdef TEST_EXTENSIONS
     deque_tests::deque_hash_integer_tests();
 #endif
 
- return boost::report_errors();
+ return 0;
 }

Modified: branches/unordered/trunk/libs/functional/hash/test/hash_float_test.cpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/hash_float_test.cpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/hash_float_test.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -5,7 +5,7 @@
 
 #include "hash_float_test.hpp"
 
-int main()
+int test_main(int, char**)
 {
     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 boost::report_errors();
+ return 0;
 }

Modified: branches/unordered/trunk/libs/functional/hash/test/hash_float_test.hpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/hash_float_test.hpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/hash_float_test.hpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -11,7 +11,7 @@
 # include <boost/functional/hash.hpp>
 #endif
 
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/test/minimal.hpp>
 
 #include <cmath>
 #include <boost/limits.hpp>
@@ -43,11 +43,11 @@
     T zero = 0;
     T minus_zero = (T) -1 * zero;
 
- BOOST_TEST(zero == minus_zero);
- BOOST_TEST(x1(zero) == x1(minus_zero));
+ BOOST_CHECK(zero == minus_zero);
+ BOOST_CHECK(x1(zero) == x1(minus_zero));
 
- BOOST_TEST(x1(zero) == HASH_NAMESPACE::hash_value(zero));
- BOOST_TEST(x1(minus_zero) == HASH_NAMESPACE::hash_value(minus_zero));
+ BOOST_CHECK(x1(zero) == HASH_NAMESPACE::hash_value(zero));
+ BOOST_CHECK(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_TEST(x1(infinity) == HASH_NAMESPACE::hash_value(infinity));
- BOOST_TEST(x1(minus_infinity)
+ BOOST_CHECK(x1(infinity) == HASH_NAMESPACE::hash_value(infinity));
+ BOOST_CHECK(x1(minus_infinity)
                 == HASH_NAMESPACE::hash_value(minus_infinity));
 
         if(infinity == infinity2)
- BOOST_TEST(x1(infinity) == x1(infinity2));
+ BOOST_CHECK(x1(infinity) == x1(infinity2));
         if(infinity == infinity3)
- BOOST_TEST(x1(infinity) == x1(infinity3));
+ BOOST_CHECK(x1(infinity) == x1(infinity3));
         if(infinity == infinity4)
- BOOST_TEST(x1(infinity) == x1(infinity4));
+ BOOST_CHECK(x1(infinity) == x1(infinity4));
 
         if(minus_infinity == minus_infinity2)
- BOOST_TEST(x1(minus_infinity) == x1(minus_infinity2));
+ BOOST_CHECK(x1(minus_infinity) == x1(minus_infinity2));
         if(minus_infinity == minus_infinity3)
- BOOST_TEST(x1(minus_infinity) == x1(minus_infinity3));
+ BOOST_CHECK(x1(minus_infinity) == x1(minus_infinity3));
 
- BOOST_TEST(infinity != minus_infinity);
+ BOOST_CHECK(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_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));
+ 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));
 
     // The '!=' tests could legitimately fail, but with my hash it indicates a bug.
- 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));
+ 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));
 
 // 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_TEST(x1(v1) == x1(v2));
- BOOST_TEST(x1(v1) == HASH_NAMESPACE::hash_value(v1));
- BOOST_TEST(x1(v2) == HASH_NAMESPACE::hash_value(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));
 #endif
 
- BOOST_TEST(x1(boost::hash_detail::limits<T>::epsilon()) ==
+ BOOST_CHECK(x1(boost::hash_detail::limits<T>::epsilon()) ==
             HASH_NAMESPACE::hash_value(boost::hash_detail::limits<T>::epsilon()));
 
- BOOST_TEST(boost::hash_detail::limits<T>::epsilon() != (T) 0);
+ BOOST_CHECK(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_TEST(-boost::hash_detail::limits<T>::epsilon() != (T) 0);
+ BOOST_CHECK(-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_TEST((T) 1 + boost::hash_detail::limits<T>::epsilon() != (T) 1);
+ BOOST_CHECK((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_TEST((T) 1 - boost::hash_detail::limits<T>::epsilon() != (T) 1);
+ BOOST_CHECK((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_TEST((T) -1 + boost::hash_detail::limits<T>::epsilon() != (T) -1);
+ BOOST_CHECK((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_TEST((T) -1 - boost::hash_detail::limits<T>::epsilon() != (T) -1);
+ BOOST_CHECK((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_TEST(x1(boost::hash_detail::limits<T>::quiet_NaN()) ==
+ BOOST_CHECK(x1(boost::hash_detail::limits<T>::quiet_NaN()) ==
             HASH_NAMESPACE::hash_value(boost::hash_detail::limits<T>::quiet_NaN()));
     }
 #endif

Modified: branches/unordered/trunk/libs/functional/hash/test/hash_friend_test.cpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/hash_friend_test.cpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/hash_friend_test.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -50,7 +50,7 @@
 # endif
 #endif
 
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/test/minimal.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -61,13 +61,13 @@
 void custom_tests()
 {
     HASH_NAMESPACE::hash<test::custom<int> > custom_hasher;
- BOOST_TEST(custom_hasher(10) == 100u);
+ BOOST_CHECK(custom_hasher(10) == 100u);
     test::custom<int> x(55);
- BOOST_TEST(custom_hasher(x) == 550u);
+ BOOST_CHECK(custom_hasher(x) == 550u);
 
     {
         using namespace HASH_NAMESPACE;
- BOOST_TEST(custom_hasher(x) == hash_value(x));
+ BOOST_CHECK(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_TEST(seed ==
+ BOOST_CHECK(seed ==
             HASH_NAMESPACE::hash_range(custom_vector.begin(), custom_vector.end()));
- BOOST_TEST(seed == seed2);
+ BOOST_CHECK(seed == seed2);
 }
 
 #endif // TEST_EXTENSIONS
 
-int main()
+int test_main(int, char**)
 {
 #ifdef TEST_EXTENSIONS
     custom_tests();
 #endif
- return boost::report_errors();
+ return 0;
 }

Modified: branches/unordered/trunk/libs/functional/hash/test/hash_function_pointer_test.cpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/hash_function_pointer_test.cpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/hash_function_pointer_test.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -11,7 +11,7 @@
 # include <boost/functional/hash.hpp>
 #endif
 
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/test/minimal.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_TEST(&void_func1 != &void_func2);
- BOOST_TEST(&int_func1 != &int_func2);
+ BOOST_CHECK(&void_func1 != &void_func2);
+ BOOST_CHECK(&int_func1 != &int_func2);
 
- 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));
+ 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));
 #if defined(TEST_EXTENSIONS)
- BOOST_TEST(hasher_void(&void_func1)
+ BOOST_CHECK(hasher_void(&void_func1)
             == HASH_NAMESPACE::hash_value(&void_func1));
- BOOST_TEST(hasher_int(&int_func1)
+ BOOST_CHECK(hasher_int(&int_func1)
             == HASH_NAMESPACE::hash_value(&int_func1));
 
     // This isn't specified in Peter's proposal:
- BOOST_TEST(hasher_void(0) == 0);
+ BOOST_CHECK(hasher_void(0) == 0);
 #endif
 }
 
-int main()
+int test_main(int, char**)
 {
     function_pointer_tests();
 
- return boost::report_errors();
+ return 0;
 }

Modified: branches/unordered/trunk/libs/functional/hash/test/hash_fwd_test_1.cpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/hash_fwd_test_1.cpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/hash_fwd_test_1.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -7,7 +7,7 @@
 
 #include "./hash_fwd_test.hpp"
 
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/test/minimal.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_TEST(hasher_int(5) == hasher_test_int(x));
- BOOST_TEST(hasher_string("Test") == hasher_test_string(y));
+ BOOST_CHECK(hasher_int(5) == hasher_test_int(x));
+ BOOST_CHECK(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_TEST(seed1 == hasher_test_int(x));
- BOOST_TEST(seed2 == hasher_test_string(y));
+ BOOST_CHECK(seed1 == hasher_test_int(x));
+ BOOST_CHECK(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_TEST(seed1 == hasher_test_int(x));
- BOOST_TEST(seed2 == hasher_test_string(y));
+ BOOST_CHECK(seed1 == hasher_test_int(x));
+ BOOST_CHECK(seed2 == hasher_test_string(y));
 }
 
 #endif
 
-int main()
+int test_main(int, char**)
 {
 #ifdef TEST_EXTENSIONS
     fwd_test1();
     fwd_test2();
     fwd_test3();
 #endif
- return boost::report_errors();
+ return 0;
 }
 

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

Modified: branches/unordered/trunk/libs/functional/hash/test/hash_global_namespace_test.cpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/hash_global_namespace_test.cpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/hash_global_namespace_test.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -48,7 +48,7 @@
 # endif
 #endif
 
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/test/minimal.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -59,13 +59,13 @@
 void custom_tests()
 {
     HASH_NAMESPACE::hash<custom> custom_hasher;
- BOOST_TEST(custom_hasher(10) == 100u);
+ BOOST_CHECK(custom_hasher(10) == 100u);
     custom x(55);
- BOOST_TEST(custom_hasher(x) == 550u);
+ BOOST_CHECK(custom_hasher(x) == 550u);
 
     {
         using namespace HASH_NAMESPACE;
- BOOST_TEST(custom_hasher(x) == hash_value(x));
+ BOOST_CHECK(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_TEST(seed ==
+ BOOST_CHECK(seed ==
             HASH_NAMESPACE::hash_range(custom_vector.begin(), custom_vector.end()));
- BOOST_TEST(seed == seed2);
+ BOOST_CHECK(seed == seed2);
 }
 
 #endif // TEST_EXTENSIONS
 
 
-int main()
+int test_main(int, char**)
 {
 #ifdef TEST_EXTENSIONS
     custom_tests();
 #endif
- return boost::report_errors();
+ return 0;
 }
 

Modified: branches/unordered/trunk/libs/functional/hash/test/hash_list_test.cpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/hash_list_test.cpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/hash_list_test.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -13,7 +13,7 @@
 # endif
 #endif
 
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/test/minimal.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -25,11 +25,11 @@
 
 #endif // TEST_EXTENSIONS
 
-int main()
+int test_main(int, char**)
 {
 #ifdef TEST_EXTENSIONS
     list_tests::list_hash_integer_tests();
 #endif
 
- return boost::report_errors();
+ return 0;
 }

Modified: branches/unordered/trunk/libs/functional/hash/test/hash_long_double_test.cpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/hash_long_double_test.cpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/hash_long_double_test.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -5,7 +5,7 @@
 
 #include "hash_float_test.hpp"
 
-int main()
+int test_main(int, char**)
 {
     std::cerr<<"Compiler: "<<BOOST_COMPILER<<"\n";
     std::cerr<<"Platform: "<<BOOST_PLATFORM<<"\n";
@@ -13,5 +13,5 @@
 
     float_tests("long double", (long double*) 0);
 
- return boost::report_errors();
+ return 0;
 }

Modified: branches/unordered/trunk/libs/functional/hash/test/hash_map_test.cpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/hash_map_test.cpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/hash_map_test.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -13,7 +13,7 @@
 # endif
 #endif
 
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/test/minimal.hpp>
 
 #include <map>
 
@@ -29,12 +29,12 @@
 
 #endif // TEST_EXTENSTIONS
 
-int main()
+int test_main(int, char**)
 {
 #ifdef TEST_EXTENSIONS
     map_tests::map_hash_integer_tests();
     multimap_tests::multimap_hash_integer_tests();
 #endif
 
- return boost::report_errors();
+ return 0;
 }

Modified: branches/unordered/trunk/libs/functional/hash/test/hash_map_test.hpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/hash_map_test.hpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/hash_map_test.hpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -38,17 +38,17 @@
         HASH_NAMESPACE::hash<T> hasher;
 
         for(int i2 = 0; i2 < number_of_containers; ++i2) {
- BOOST_TEST(hasher(containers[i2]) == hasher(containers[i2]));
+ BOOST_CHECK(hasher(containers[i2]) == hasher(containers[i2]));
 
- BOOST_TEST(hasher(containers[i2]) ==
+ BOOST_CHECK(hasher(containers[i2]) ==
                     HASH_NAMESPACE::hash_value(containers[i2]));
 
- BOOST_TEST(hasher(containers[i2])
+ BOOST_CHECK(hasher(containers[i2])
                     == HASH_NAMESPACE::hash_range(
                         containers[i2].begin(), containers[i2].end()));
 
             for(int j2 = i2 + 1; j2 < number_of_containers; ++j2) {
- BOOST_TEST(
+ BOOST_CHECK(
                         (containers[i2] == containers[j2]) ==
                         (hasher(containers[i2]) == hasher(containers[j2]))
                         );

Modified: branches/unordered/trunk/libs/functional/hash/test/hash_no_ext_fail_test.cpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/hash_no_ext_fail_test.cpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/hash_no_ext_fail_test.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -12,7 +12,7 @@
 #include <boost/functional/hash.hpp>
 #include <boost/functional/hash.hpp>
 
-int main()
+int test_main(int, char**)
 {
     HASH_NAMESPACE::hash< int[10] > hasher;
     return 0;

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

Modified: branches/unordered/trunk/libs/functional/hash/test/hash_no_ext_macro_2.cpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/hash_no_ext_macro_2.cpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/hash_no_ext_macro_2.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -8,10 +8,10 @@
 #include <boost/functional/hash.hpp>
 #undef BOOST_HASH_NO_EXTENSIONS
 #include <boost/functional/hash.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/test/minimal.hpp>
 #include <map>
 
-int main()
+int test_main(int, char**)
 {
     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_TEST(hasher(x) == HASH_NAMESPACE::hash_value(x));
+ BOOST_CHECK(hasher(x) == HASH_NAMESPACE::hash_value(x));
     
- return boost::report_errors();
+ return 0;
 }

Modified: branches/unordered/trunk/libs/functional/hash/test/hash_number_test.cpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/hash_number_test.cpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/hash_number_test.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -12,7 +12,7 @@
 #endif
 
 #include <iostream>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/test/minimal.hpp>
 
 #include <boost/preprocessor/cat.hpp>
 #include <boost/limits.hpp>
@@ -39,27 +39,27 @@
     HASH_NAMESPACE::hash<T> x2;
 
     T v1 = (T) -5;
- 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)));
+ 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)));
 
 #if defined(TEST_EXTENSIONS)
- 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)));
+ 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)));
 
     if (limits::is_integer)
     {
         if(limits::is_signed || limits::digits <= boost::hash_detail::limits<std::size_t>::digits)
- 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));
+ 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));
     }
 #endif
 }
@@ -77,18 +77,18 @@
         T min_value = (limits::min)();
         T max_value = (limits::max)();
 
- BOOST_TEST(x1(min_value) == x2((limits::min)()));
- BOOST_TEST(x1(max_value) == x2((limits::max)()));
+ BOOST_CHECK(x1(min_value) == x2((limits::min)()));
+ BOOST_CHECK(x1(max_value) == x2((limits::max)()));
 
 #if defined(TEST_EXTENSIONS)
- BOOST_TEST(x1(min_value) == HASH_NAMESPACE::hash_value(min_value));
- BOOST_TEST(x1(max_value) == HASH_NAMESPACE::hash_value(max_value));
+ BOOST_CHECK(x1(min_value) == HASH_NAMESPACE::hash_value(min_value));
+ BOOST_CHECK(x1(max_value) == HASH_NAMESPACE::hash_value(max_value));
 
         if (limits::is_integer)
         {
- BOOST_TEST(HASH_NAMESPACE::hash_value(min_value)
+ BOOST_CHECK(HASH_NAMESPACE::hash_value(min_value)
                     == std::size_t(min_value));
- BOOST_TEST(HASH_NAMESPACE::hash_value(max_value)
+ BOOST_CHECK(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_TEST(x1(T(1)) != x2(T(-1)));
+ BOOST_CHECK(x1(T(1)) != x2(T(-1)));
     if(T(1) != T(2))
- BOOST_TEST(x1(T(1)) != x2(T(2)));
+ BOOST_CHECK(x1(T(1)) != x2(T(2)));
     if((limits::max)() != (limits::max)() - 1)
- BOOST_TEST(x1((limits::max)()) != x2((limits::max)() - 1));
+ BOOST_CHECK(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_TEST(x1(true) == x2(true));
- BOOST_TEST(x1(false) == x2(false));
- BOOST_TEST(x1(true) != x2(false));
- BOOST_TEST(x1(false) != x2(true));
+ BOOST_CHECK(x1(true) == x2(true));
+ BOOST_CHECK(x1(false) == x2(false));
+ BOOST_CHECK(x1(true) != x2(false));
+ BOOST_CHECK(x1(false) != x2(true));
 }
 
 #define NUMERIC_TEST(type, name) \
@@ -134,7 +134,7 @@
     numeric_test((type*) 0); \
     poor_quality_tests((type*) 0);
 
-int main()
+int test_main(int, char**)
 {
     NUMERIC_TEST(char, char)
     NUMERIC_TEST(signed char, schar)
@@ -159,7 +159,7 @@
 
     bool_test();
 
- return boost::report_errors();
+ return 0;
 }
 
 #if defined(BOOST_MSVC)

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

Modified: branches/unordered/trunk/libs/functional/hash/test/hash_range_test.cpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/hash_range_test.cpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/hash_range_test.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -13,7 +13,7 @@
 # endif
 #endif
 
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/test/minimal.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -41,45 +41,45 @@
     std::vector<int> x;
 
     std::size_t x_seed = 0;
- BOOST_TEST(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
+ BOOST_CHECK(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
 
- BOOST_TEST(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
+ BOOST_CHECK(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
         == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
- BOOST_TEST(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
+ BOOST_CHECK(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_TEST(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
+ BOOST_CHECK(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
 
- BOOST_TEST(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
+ BOOST_CHECK(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
         != HASH_NAMESPACE::hash_range(x.begin(), x.end()));
- BOOST_TEST(HASH_NAMESPACE::hash_range(values2.begin(), values2.end())
+ BOOST_CHECK(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_TEST(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
+ BOOST_CHECK(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
 
- BOOST_TEST(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
+ BOOST_CHECK(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
         != HASH_NAMESPACE::hash_range(x.begin(), x.end()));
- BOOST_TEST(HASH_NAMESPACE::hash_range(values2.begin(), values2.end())
+ BOOST_CHECK(HASH_NAMESPACE::hash_range(values2.begin(), values2.end())
         != HASH_NAMESPACE::hash_range(x.begin(), x.end()));
- BOOST_TEST(HASH_NAMESPACE::hash_range(values3.begin(), values3.end())
+ BOOST_CHECK(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_TEST(seed == HASH_NAMESPACE::hash_range(values5.begin(), values5.end()));
+ BOOST_CHECK(seed == HASH_NAMESPACE::hash_range(values5.begin(), values5.end()));
 }
 
 #endif
 
-int main()
+int test_main(int, char**)
 {
     hash_range_tests();
 
- return boost::report_errors();
+ return 0;
 }
 

Modified: branches/unordered/trunk/libs/functional/hash/test/hash_sequence_test.hpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/hash_sequence_test.hpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/hash_sequence_test.hpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -41,17 +41,17 @@
         HASH_NAMESPACE::hash<T> hasher;
 
         for(int i2 = 0; i2 < number_of_containers; ++i2) {
- BOOST_TEST(hasher(containers[i2]) == hasher(containers[i2]));
+ BOOST_CHECK(hasher(containers[i2]) == hasher(containers[i2]));
 
- BOOST_TEST(hasher(containers[i2]) ==
+ BOOST_CHECK(hasher(containers[i2]) ==
                     HASH_NAMESPACE::hash_value(containers[i2]));
 
- BOOST_TEST(hasher(containers[i2])
+ BOOST_CHECK(hasher(containers[i2])
                     == HASH_NAMESPACE::hash_range(
                         containers[i2].begin(), containers[i2].end()));
 
             for(int j2 = i2 + 1; j2 < number_of_containers; ++j2) {
- BOOST_TEST(
+ BOOST_CHECK(
                         (containers[i2] == containers[j2]) ==
                         (hasher(containers[i2]) == hasher(containers[j2]))
                         );

Modified: branches/unordered/trunk/libs/functional/hash/test/hash_set_test.cpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/hash_set_test.cpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/hash_set_test.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -13,7 +13,7 @@
 # endif
 #endif
 
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/test/minimal.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -29,12 +29,12 @@
 
 #endif
 
-int main()
+int test_main(int, char**)
 {
 #ifdef TEST_EXTENSIONS
     set_tests::set_hash_integer_tests();
     multiset_tests::multiset_hash_integer_tests();
 #endif
 
- return boost::report_errors();
+ return 0;
 }

Modified: branches/unordered/trunk/libs/functional/hash/test/hash_set_test.hpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/hash_set_test.hpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/hash_set_test.hpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -44,17 +44,17 @@
         HASH_NAMESPACE::hash<T> hasher;
 
         for(int i2 = 0; i2 < number_of_containers; ++i2) {
- BOOST_TEST(hasher(containers[i2]) == hasher(containers[i2]));
+ BOOST_CHECK(hasher(containers[i2]) == hasher(containers[i2]));
 
- BOOST_TEST(hasher(containers[i2]) ==
+ BOOST_CHECK(hasher(containers[i2]) ==
                     HASH_NAMESPACE::hash_value(containers[i2]));
 
- BOOST_TEST(hasher(containers[i2])
+ BOOST_CHECK(hasher(containers[i2])
                     == HASH_NAMESPACE::hash_range(
                         containers[i2].begin(), containers[i2].end()));
 
             for(int j2 = i2 + 1; j2 < number_of_containers; ++j2) {
- BOOST_TEST(
+ BOOST_CHECK(
                         (containers[i2] == containers[j2]) ==
                         (hasher(containers[i2]) == hasher(containers[j2]))
                         );

Modified: branches/unordered/trunk/libs/functional/hash/test/hash_string_test.cpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/hash_string_test.cpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/hash_string_test.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -11,7 +11,7 @@
 # include <boost/functional/hash.hpp>
 #endif
 
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/test/minimal.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_TEST(x1("Hello") == x2(std::string("Hel") + "lo"));
- BOOST_TEST(x1("") == x2(std::string()));
+ BOOST_CHECK(x1("Hello") == x2(std::string("Hel") + "lo"));
+ BOOST_CHECK(x1("") == x2(std::string()));
 
 #if defined(TEST_EXTENSIONS)
     std::string value1;
     std::string value2("Hello");
 
- 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) ==
+ 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) ==
             HASH_NAMESPACE::hash_range(value1.begin(), value1.end()));
- BOOST_TEST(HASH_NAMESPACE::hash_value(value2) ==
+ BOOST_CHECK(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_TEST(x1(L"Hello") == x2(std::wstring(L"Hel") + L"lo"));
- BOOST_TEST(x1(L"") == x2(std::wstring()));
+ BOOST_CHECK(x1(L"Hello") == x2(std::wstring(L"Hel") + L"lo"));
+ BOOST_CHECK(x1(L"") == x2(std::wstring()));
 
 #if defined(TEST_EXTENSIONS)
     std::wstring value1;
     std::wstring value2(L"Hello");
 
- 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) ==
+ 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) ==
             HASH_NAMESPACE::hash_range(value1.begin(), value1.end()));
- BOOST_TEST(HASH_NAMESPACE::hash_value(value2) ==
+ BOOST_CHECK(HASH_NAMESPACE::hash_value(value2) ==
             HASH_NAMESPACE::hash_range(value2.begin(), value2.end()));
 #endif
 }
 #endif
 
-int main()
+int test_main(int, char**)
 {
     string_tests();
 #if !defined(BOOST_NO_STD_WSTRING)
     wstring_tests();
 #endif
- return boost::report_errors();
+ return 0;
 }

Modified: branches/unordered/trunk/libs/functional/hash/test/hash_value_array_test.cpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/hash_value_array_test.cpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/hash_value_array_test.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -16,7 +16,7 @@
 # endif
 #endif
 
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/test/minimal.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -37,9 +37,9 @@
     int array3[2] = {2, 3};
     HASH_NAMESPACE::hash<int[2]> hasher3;
 
- 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));
+ 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));
 }
 
 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_TEST(hasher(array) == HASH_NAMESPACE::hash_value(array));
+ BOOST_CHECK(hasher(array) == HASH_NAMESPACE::hash_value(array));
 }
 
 #endif
 
-int main()
+int test_main(int, char**)
 {
 #ifdef TEST_EXTENSIONS
     array_int_test();
     two_dimensional_array_test();
 #endif
 
- return boost::report_errors();
+ return 0;
 }
 

Modified: branches/unordered/trunk/libs/functional/hash/test/hash_vector_test.cpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/hash_vector_test.cpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/hash_vector_test.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -13,7 +13,7 @@
 # endif
 #endif
 
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/test/minimal.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -25,11 +25,11 @@
 
 #endif // TEST_EXTENSIONS
 
-int main()
+int test_main(int, char**)
 {
 #ifdef TEST_EXTENSIONS
     vector_tests::vector_hash_integer_tests();
 #endif
 
- return boost::report_errors();
+ return 0;
 }

Modified: branches/unordered/trunk/libs/functional/hash/test/link_ext_test.cpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/link_ext_test.cpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/link_ext_test.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -5,13 +5,13 @@
 
 #define HASH_NAMESPACE boost
 #include <boost/functional/hash.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/test/minimal.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_TEST(hash1 == ptr_hasher(x1));
+ BOOST_CHECK(hash1 == ptr_hasher(x1));
 
     // Check that std::vector<std::size_t> is avaiable in this file.
     std::vector<std::size_t> x;

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

Modified: branches/unordered/trunk/libs/functional/hash/test/link_test.cpp
==============================================================================
--- branches/unordered/trunk/libs/functional/hash/test/link_test.cpp (original)
+++ branches/unordered/trunk/libs/functional/hash/test/link_test.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -6,4 +6,4 @@
 #include <boost/functional/hash.hpp>
 
 extern int f();
-int main() { return f(); }
+int main(int, char**) { return f(); }

Modified: branches/unordered/trunk/libs/unordered/test/exception/erase_exception_tests.cpp
==============================================================================
--- branches/unordered/trunk/libs/unordered/test/exception/erase_exception_tests.cpp (original)
+++ branches/unordered/trunk/libs/unordered/test/exception/erase_exception_tests.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -25,7 +25,7 @@
     void check(T const& x) const {
         std::string scope(test::scope);
 
- UNORDERED_CHECK(scope.find("hash::") != std::string::npos ||
+ BOOST_CHECK(scope.find("hash::") != std::string::npos ||
                 scope.find("equal_to::") != std::string::npos ||
                 scope == "operator==(object, object)");
 

Modified: branches/unordered/trunk/libs/unordered/test/exception/insert_exception_tests.cpp
==============================================================================
--- branches/unordered/trunk/libs/unordered/test/exception/insert_exception_tests.cpp (original)
+++ branches/unordered/trunk/libs/unordered/test/exception/insert_exception_tests.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -109,10 +109,10 @@
         size_type bucket_count = x.bucket_count();
         size_type initial_elements = static_cast<size_type>(
             ceil(bucket_count * (double) x.max_load_factor()) - 1);
- UNORDERED_REQUIRE(initial_elements < this->values.size());
+ BOOST_REQUIRE(initial_elements < this->values.size());
         x.insert(this->values.begin(),
                 boost::next(this->values.begin(), initial_elements));
- UNORDERED_REQUIRE(bucket_count == x.bucket_count());
+ BOOST_REQUIRE(bucket_count == x.bucket_count());
         return x;
     }
 
@@ -131,7 +131,7 @@
 
         // This isn't actually a failure, but it means the test isn't doing its
         // job.
- UNORDERED_REQUIRE(x.bucket_count() != bucket_count);
+ BOOST_REQUIRE(x.bucket_count() != bucket_count);
     }
 };
 
@@ -154,7 +154,7 @@
 
         // This isn't actually a failure, but it means the test isn't doing its
         // job.
- UNORDERED_REQUIRE(x.bucket_count() != bucket_count);
+ BOOST_REQUIRE(x.bucket_count() != bucket_count);
     }
 };
 
@@ -178,10 +178,10 @@
 
         size_type initial_elements = rehash_bucket_count - 5;
 
- UNORDERED_REQUIRE(initial_elements < this->values.size());
+ BOOST_REQUIRE(initial_elements < this->values.size());
         x.insert(this->values.begin(),
                 boost::next(this->values.begin(), initial_elements));
- UNORDERED_REQUIRE(original_bucket_count == x.bucket_count());
+ BOOST_REQUIRE(original_bucket_count == x.bucket_count());
         return x;
     }
 
@@ -193,7 +193,7 @@
 
         // This isn't actually a failure, but it means the test isn't doing its
         // job.
- UNORDERED_REQUIRE(x.bucket_count() != bucket_count);
+ BOOST_REQUIRE(x.bucket_count() != bucket_count);
     }
 
     void check(T const& x) const {

Modified: branches/unordered/trunk/libs/unordered/test/exception/swap_exception_tests.cpp
==============================================================================
--- branches/unordered/trunk/libs/unordered/test/exception/swap_exception_tests.cpp (original)
+++ branches/unordered/trunk/libs/unordered/test/exception/swap_exception_tests.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -22,7 +22,7 @@
         std::string scope(test::scope);
 
 #if BOOST_UNORDERED_SWAP_METHOD != 2
- UNORDERED_CHECK(
+ BOOST_CHECK(
                 scope == "hash::operator(hash)" ||
                 scope == "hash::operator=(hash)" ||
                 scope == "equal_to::operator(equal_to)" ||
@@ -77,7 +77,7 @@
         std::string scope(test::scope);
 
 #if BOOST_UNORDERED_SWAP_METHOD != 2
- UNORDERED_CHECK(
+ BOOST_CHECK(
                 scope == "hash::operator(hash)" ||
                 scope == "hash::operator=(hash)" ||
                 scope == "equal_to::operator(equal_to)" ||

Modified: branches/unordered/trunk/libs/unordered/test/helpers/exception_test.hpp
==============================================================================
--- branches/unordered/trunk/libs/unordered/test/helpers/exception_test.hpp (original)
+++ branches/unordered/trunk/libs/unordered/test/helpers/exception_test.hpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -8,7 +8,7 @@
 
 #include "./test.hpp"
 
-#if defined(BOOST_UNORDERED_USE_TEST)
+#if defined(BOOST_UNORDERED_FULL_TEST)
 # define BOOST_TEST_MAIN
 # include <boost/test/exception_safety.hpp>
 # include <boost/test/unit_test.hpp>
@@ -18,7 +18,7 @@
 #include <boost/preprocessor/seq/elem.hpp>
 #include <boost/preprocessor/cat.hpp>
 
-#if defined(BOOST_UNORDERED_USE_TEST)
+#if defined(BOOST_UNORDERED_FULL_TEST)
 # define UNORDERED_EXCEPTION_TEST_CASE(name, test_func, type) \
         UNORDERED_AUTO_TEST(name) \
         { \
@@ -181,7 +181,7 @@
     
     
 
-#if defined(BOOST_UNORDERED_USE_TEST)
+#if defined(BOOST_UNORDERED_FULL_TEST)
     template <class Test>
     void exception_safety(Test const& f, char const* name) {
         test_runner<Test> runner(f);

Modified: branches/unordered/trunk/libs/unordered/test/helpers/test.hpp
==============================================================================
--- branches/unordered/trunk/libs/unordered/test/helpers/test.hpp (original)
+++ branches/unordered/trunk/libs/unordered/test/helpers/test.hpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -6,21 +6,17 @@
 #if !defined(BOOST_UNORDERED_TEST_TEST_HEADER)
 #define BOOST_UNORDERED_TEST_TEST_HEADER
 
-#if defined(BOOST_UNORDERED_USE_TEST)
+#if defined(BOOST_UNORDERED_FULL_TEST)
 
 #include <boost/test/test_tools.hpp>
-#define UNORDERED_CHECK(x) BOOST_CHECK(x)
-#define UNORDERED_REQUIRE(x) BOOST_REQUIRE(x)
 #define UNORDERED_AUTO_TEST(x) BOOST_AUTO_TEST_CASE(x)
 #define RUN_TESTS()
 
 #else
 
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/test/minimal.hpp>
 #include <boost/preprocessor/cat.hpp>
 
-#define UNORDERED_CHECK(x) BOOST_TEST(x)
-#define UNORDERED_REQUIRE(x) if(!(x)) { BOOST_ERROR(BOOST_STRINGIZE(x)); throw ::test::lightweight::test_failure(); }
 #define UNORDERED_AUTO_TEST(x) \
     struct BOOST_PP_CAT(x, _type) : public ::test::registered_test_base { \
         BOOST_PP_CAT(x, _type)() { \
@@ -30,7 +26,7 @@
     }; \
     BOOST_PP_CAT(x, _type) x; \
     void BOOST_PP_CAT(x, _type)::run()
-#define RUN_TESTS() int main() { ::test::test_list::run_tests(); return boost::report_errors(); }
+#define RUN_TESTS() int test_main(int, char**) { ::test::test_list::run_tests(); return 0; }
 
 namespace test {
     struct registered_test_base {

Modified: branches/unordered/trunk/libs/unordered/test/helpers/tracker.hpp
==============================================================================
--- branches/unordered/trunk/libs/unordered/test/helpers/tracker.hpp (original)
+++ branches/unordered/trunk/libs/unordered/test/helpers/tracker.hpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -51,7 +51,7 @@
         std::copy(x2.begin(), x2.end(), std::back_inserter(values2));
         std::sort(values1.begin(), values1.end());
         std::sort(values2.begin(), values2.end());
- BOOST_TEST(values1.size() == values2.size() &&
+ BOOST_CHECK(values1.size() == values2.size() &&
                 std::equal(values1.begin(), values1.end(), values2.begin(), test::equivalent));
     }
 
@@ -65,7 +65,7 @@
         std::copy(x2.first, x2.second, std::back_inserter(values2));
         std::sort(values1.begin(), values1.end());
         std::sort(values2.begin(), values2.end());
- BOOST_TEST(values1.size() == values2.size() &&
+ BOOST_CHECK(values1.size() == values2.size() &&
                 std::equal(values1.begin(), values1.end(), values2.begin(), test::equivalent));
     }
 

Modified: branches/unordered/trunk/libs/unordered/test/objects/memory.hpp
==============================================================================
--- branches/unordered/trunk/libs/unordered/test/objects/memory.hpp (original)
+++ branches/unordered/trunk/libs/unordered/test/objects/memory.hpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -103,7 +103,7 @@
 
             void allocator_unref()
             {
- UNORDERED_CHECK(count_allocators > 0);
+ BOOST_CHECK(count_allocators > 0);
                 if(count_allocators > 0) {
                     --count_allocators;
                     if(count_allocators == 0) {
@@ -116,9 +116,9 @@
                         count_constructions = 0;
                         allocated_memory.clear();
 
- UNORDERED_CHECK(no_allocations_left);
- UNORDERED_CHECK(no_constructions_left);
- UNORDERED_CHECK(allocated_memory_empty);
+ BOOST_CHECK(no_allocations_left);
+ BOOST_CHECK(no_constructions_left);
+ BOOST_CHECK(allocated_memory_empty);
                     }
                 }
             }
@@ -144,12 +144,12 @@
                 if(pos == allocated_memory.end()) {
                     BOOST_ERROR("Deallocating unknown pointer.");
                 } else {
- UNORDERED_CHECK(pos->first.start == ptr);
- UNORDERED_CHECK(pos->first.end == (char*) ptr + n * size);
- UNORDERED_CHECK(pos->second.tag_ == tag);
+ BOOST_CHECK(pos->first.start == ptr);
+ BOOST_CHECK(pos->first.end == (char*) ptr + n * size);
+ BOOST_CHECK(pos->second.tag_ == tag);
                     allocated_memory.erase(pos);
                 }
- UNORDERED_CHECK(count_allocations > 0);
+ BOOST_CHECK(count_allocations > 0);
                 if(count_allocations > 0) --count_allocations;
             }
 
@@ -160,7 +160,7 @@
 
             void track_destroy(void* ptr, std::size_t /*size*/, int tag)
             {
- UNORDERED_CHECK(count_constructions > 0);
+ BOOST_CHECK(count_constructions > 0);
                 if(count_constructions > 0) --count_constructions;
             }
         };

Modified: branches/unordered/trunk/libs/unordered/test/unordered/assign_tests.cpp
==============================================================================
--- branches/unordered/trunk/libs/unordered/test/unordered/assign_tests.cpp (original)
+++ branches/unordered/trunk/libs/unordered/test/unordered/assign_tests.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -27,9 +27,9 @@
     {
         T x;
         x = x;
- BOOST_TEST(x.empty());
- BOOST_TEST(test::equivalent(x.hash_function(), hf));
- BOOST_TEST(test::equivalent(x.key_eq(), eq));
+ BOOST_CHECK(x.empty());
+ BOOST_CHECK(test::equivalent(x.hash_function(), hf));
+ BOOST_CHECK(test::equivalent(x.key_eq(), eq));
     }
 
     std::cerr<<"assign_tests1.2\n";
@@ -47,7 +47,7 @@
         y.max_load_factor(x.max_load_factor() / 20);
         y = x;
         tracker.compare(y);
- BOOST_TEST(x.max_load_factor() == y.max_load_factor());
+ BOOST_CHECK(x.max_load_factor() == y.max_load_factor());
     }
 }
 
@@ -67,8 +67,8 @@
         T x1(v.begin(), v.end(), 0, hf1, eq1);
         T x2(0, hf2, eq2);
         x2 = x1;
- BOOST_TEST(test::equivalent(x2.hash_function(), hf1));
- BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
+ BOOST_CHECK(test::equivalent(x2.hash_function(), hf1));
+ BOOST_CHECK(test::equivalent(x2.key_eq(), eq1));
         test::check_container(x2, v);
     }
 
@@ -78,9 +78,9 @@
         T x1(v1.begin(), v1.end(), 0, hf1, eq1, al1);
         T x2(v2.begin(), v2.end(), 0, hf2, eq2, al2);
         x2 = x1;
- BOOST_TEST(test::equivalent(x2.hash_function(), hf1));
- BOOST_TEST(test::equivalent(x2.key_eq(), eq1));
- BOOST_TEST(test::equivalent(x2.get_allocator(), al2));
+ BOOST_CHECK(test::equivalent(x2.hash_function(), hf1));
+ BOOST_CHECK(test::equivalent(x2.key_eq(), eq1));
+ BOOST_CHECK(test::equivalent(x2.get_allocator(), al2));
         test::check_container(x2, v1);
     }
 }

Modified: branches/unordered/trunk/libs/unordered/test/unordered/at_tests.cpp
==============================================================================
--- branches/unordered/trunk/libs/unordered/test/unordered/at_tests.cpp (original)
+++ branches/unordered/trunk/libs/unordered/test/unordered/at_tests.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -16,8 +16,8 @@
     x["one"] = 1;
     x["two"] = 2;
 
- BOOST_TEST(x.at("one") == 1);
- BOOST_TEST(x.at("two") == 2);
+ BOOST_CHECK(x.at("one") == 1);
+ BOOST_CHECK(x.at("two") == 2);
 
     try {
         x.at("three");

Modified: branches/unordered/trunk/libs/unordered/test/unordered/bucket_tests.cpp
==============================================================================
--- branches/unordered/trunk/libs/unordered/test/unordered/bucket_tests.cpp (original)
+++ branches/unordered/trunk/libs/unordered/test/unordered/bucket_tests.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -24,7 +24,7 @@
 
     X x(v.begin(), v.end());
 
- BOOST_TEST(x.bucket_count() < x.max_bucket_count());
+ BOOST_CHECK(x.bucket_count() < x.max_bucket_count());
     std::cerr<<x.bucket_count()<<"<"<<x.max_bucket_count()<<"\n";
 
     for(BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator
@@ -32,21 +32,21 @@
     {
         size_type bucket = x.bucket(test::get_key<X>(*it));
 
- BOOST_TEST(bucket < x.bucket_count());
+ BOOST_CHECK(bucket < x.bucket_count());
         if(bucket < x.max_bucket_count()) {
             // lit? lend?? I need a new naming scheme.
             const_local_iterator lit = x.begin(bucket), lend = x.end(bucket);
             while(lit != lend && test::get_key<X>(*it) != test::get_key<X>(*lit)) ++lit;
- BOOST_TEST(lit != lend);
+ BOOST_CHECK(lit != lend);
         }
     }
 
     for(size_type i = 0; i < x.bucket_count(); ++i) {
- BOOST_TEST(x.bucket_size(i) == (size_type) std::distance(x.begin(i), x.end(i)));
- BOOST_TEST(x.bucket_size(i) == (size_type) std::distance(x.cbegin(i), x.cend(i)));
+ BOOST_CHECK(x.bucket_size(i) == (size_type) std::distance(x.begin(i), x.end(i)));
+ BOOST_CHECK(x.bucket_size(i) == (size_type) std::distance(x.cbegin(i), x.cend(i)));
         X const& x_ref = x;
- BOOST_TEST(x.bucket_size(i) == (size_type) std::distance(x_ref.begin(i), x_ref.end(i)));
- BOOST_TEST(x.bucket_size(i) == (size_type) std::distance(x_ref.cbegin(i), x_ref.cend(i)));
+ BOOST_CHECK(x.bucket_size(i) == (size_type) std::distance(x_ref.begin(i), x_ref.end(i)));
+ BOOST_CHECK(x.bucket_size(i) == (size_type) std::distance(x_ref.cbegin(i), x_ref.cend(i)));
     }
 }
 

Modified: branches/unordered/trunk/libs/unordered/test/unordered/compile_tests.hpp
==============================================================================
--- branches/unordered/trunk/libs/unordered/test/unordered/compile_tests.hpp (original)
+++ branches/unordered/trunk/libs/unordered/test/unordered/compile_tests.hpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -86,10 +86,10 @@
     // I'm not sure about either of these tests...
     size_type max_diff((std::numeric_limits<difference_type>::max)());
     difference_type converted_diff(max_diff);
- BOOST_TEST((std::numeric_limits<difference_type>::max)()
+ BOOST_CHECK((std::numeric_limits<difference_type>::max)()
             == converted_diff);
 
- BOOST_TEST(
+ BOOST_CHECK(
         static_cast<comparison_type>(
             (std::numeric_limits<size_type>::max)()) >
         static_cast<comparison_type>(
@@ -97,8 +97,8 @@
 
     // I don't test the runtime post-conditions here.
     X u;
- BOOST_TEST(u.size() == 0);
- BOOST_TEST(X().size() == 0);
+ BOOST_CHECK(u.size() == 0);
+ BOOST_CHECK(X().size() == 0);
 
     X a,b;
 
@@ -263,7 +263,7 @@
     a.insert(i, j);
     test::check_return_type<size_type>::equals(a.erase(k));
 
- BOOST_TEST(a.empty());
+ BOOST_CHECK(a.empty());
     if(a.empty()) {
         a.insert(t);
         q = a.cbegin();

Modified: branches/unordered/trunk/libs/unordered/test/unordered/constructor_tests.cpp
==============================================================================
--- branches/unordered/trunk/libs/unordered/test/unordered/constructor_tests.cpp (original)
+++ branches/unordered/trunk/libs/unordered/test/unordered/constructor_tests.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -29,42 +29,42 @@
     std::cerr<<"Construct 1\n";
     {
         T x(0, hf, eq);
- BOOST_TEST(x.empty());
- BOOST_TEST(test::equivalent(x.hash_function(), hf));
- BOOST_TEST(test::equivalent(x.key_eq(), eq));
- BOOST_TEST(test::equivalent(x.get_allocator(), al));
+ BOOST_CHECK(x.empty());
+ BOOST_CHECK(test::equivalent(x.hash_function(), hf));
+ BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+ BOOST_CHECK(test::equivalent(x.get_allocator(), al));
         test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 2\n";
     {
         T x(100, hf);
- BOOST_TEST(x.empty());
- BOOST_TEST(x.bucket_count() >= 100);
- BOOST_TEST(test::equivalent(x.hash_function(), hf));
- BOOST_TEST(test::equivalent(x.key_eq(), eq));
- BOOST_TEST(test::equivalent(x.get_allocator(), al));
+ BOOST_CHECK(x.empty());
+ BOOST_CHECK(x.bucket_count() >= 100);
+ BOOST_CHECK(test::equivalent(x.hash_function(), hf));
+ BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+ BOOST_CHECK(test::equivalent(x.get_allocator(), al));
         test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 3\n";
     {
         T x(2000);
- BOOST_TEST(x.empty());
- BOOST_TEST(x.bucket_count() >= 2000);
- BOOST_TEST(test::equivalent(x.hash_function(), hf));
- BOOST_TEST(test::equivalent(x.key_eq(), eq));
- BOOST_TEST(test::equivalent(x.get_allocator(), al));
+ BOOST_CHECK(x.empty());
+ BOOST_CHECK(x.bucket_count() >= 2000);
+ BOOST_CHECK(test::equivalent(x.hash_function(), hf));
+ BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+ BOOST_CHECK(test::equivalent(x.get_allocator(), al));
         test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 4\n";
     {
         T x;
- BOOST_TEST(x.empty());
- BOOST_TEST(test::equivalent(x.hash_function(), hf));
- BOOST_TEST(test::equivalent(x.key_eq(), eq));
- BOOST_TEST(test::equivalent(x.get_allocator(), al));
+ BOOST_CHECK(x.empty());
+ BOOST_CHECK(test::equivalent(x.hash_function(), hf));
+ BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+ BOOST_CHECK(test::equivalent(x.get_allocator(), al));
         test::check_equivalent_keys(x);
     }
 
@@ -72,10 +72,10 @@
     {
         test::random_values<T> v(1000, generator);
         T x(v.begin(), v.end(), 10000, hf, eq);
- BOOST_TEST(x.bucket_count() >= 10000);
- BOOST_TEST(test::equivalent(x.hash_function(), hf));
- BOOST_TEST(test::equivalent(x.key_eq(), eq));
- BOOST_TEST(test::equivalent(x.get_allocator(), al));
+ BOOST_CHECK(x.bucket_count() >= 10000);
+ BOOST_CHECK(test::equivalent(x.hash_function(), hf));
+ BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+ BOOST_CHECK(test::equivalent(x.get_allocator(), al));
         test::check_container(x, v);
         test::check_equivalent_keys(x);
     }
@@ -84,10 +84,10 @@
     {
         test::random_values<T> v(10, generator);
         T x(v.begin(), v.end(), 10000, hf);
- BOOST_TEST(x.bucket_count() >= 10000);
- BOOST_TEST(test::equivalent(x.hash_function(), hf));
- BOOST_TEST(test::equivalent(x.key_eq(), eq));
- BOOST_TEST(test::equivalent(x.get_allocator(), al));
+ BOOST_CHECK(x.bucket_count() >= 10000);
+ BOOST_CHECK(test::equivalent(x.hash_function(), hf));
+ BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+ BOOST_CHECK(test::equivalent(x.get_allocator(), al));
         test::check_container(x, v);
         test::check_equivalent_keys(x);
     }
@@ -96,10 +96,10 @@
     {
         test::random_values<T> v(100, generator);
         T x(v.begin(), v.end(), 100);
- BOOST_TEST(x.bucket_count() >= 100);
- BOOST_TEST(test::equivalent(x.hash_function(), hf));
- BOOST_TEST(test::equivalent(x.key_eq(), eq));
- BOOST_TEST(test::equivalent(x.get_allocator(), al));
+ BOOST_CHECK(x.bucket_count() >= 100);
+ BOOST_CHECK(test::equivalent(x.hash_function(), hf));
+ BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+ BOOST_CHECK(test::equivalent(x.get_allocator(), al));
         test::check_container(x, v);
         test::check_equivalent_keys(x);
     }
@@ -108,9 +108,9 @@
     {
         test::random_values<T> v(1, generator);
         T x(v.begin(), v.end());
- BOOST_TEST(test::equivalent(x.hash_function(), hf));
- BOOST_TEST(test::equivalent(x.key_eq(), eq));
- BOOST_TEST(test::equivalent(x.get_allocator(), al));
+ BOOST_CHECK(test::equivalent(x.hash_function(), hf));
+ BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+ BOOST_CHECK(test::equivalent(x.get_allocator(), al));
         test::check_container(x, v);
         test::check_equivalent_keys(x);
     }
@@ -118,10 +118,10 @@
     std::cerr<<"Construct 9\n";
     {
         T x(0, hf, eq, al);
- BOOST_TEST(x.empty());
- BOOST_TEST(test::equivalent(x.hash_function(), hf));
- BOOST_TEST(test::equivalent(x.key_eq(), eq));
- BOOST_TEST(test::equivalent(x.get_allocator(), al));
+ BOOST_CHECK(x.empty());
+ BOOST_CHECK(test::equivalent(x.hash_function(), hf));
+ BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+ BOOST_CHECK(test::equivalent(x.get_allocator(), al));
         test::check_equivalent_keys(x);
     }
 
@@ -129,10 +129,10 @@
     {
         test::random_values<T> v(1000, generator);
         T x(v.begin(), v.end(), 10000, hf, eq, al);
- BOOST_TEST(x.bucket_count() >= 10000);
- BOOST_TEST(test::equivalent(x.hash_function(), hf));
- BOOST_TEST(test::equivalent(x.key_eq(), eq));
- BOOST_TEST(test::equivalent(x.get_allocator(), al));
+ BOOST_CHECK(x.bucket_count() >= 10000);
+ BOOST_CHECK(test::equivalent(x.hash_function(), hf));
+ BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+ BOOST_CHECK(test::equivalent(x.get_allocator(), al));
         test::check_container(x, v);
         test::check_equivalent_keys(x);
     }
@@ -141,10 +141,10 @@
     {
         test::random_values<T> v(1000, generator);
         T x(al);
- BOOST_TEST(x.empty());
- BOOST_TEST(test::equivalent(x.hash_function(), hf));
- BOOST_TEST(test::equivalent(x.key_eq(), eq));
- BOOST_TEST(test::equivalent(x.get_allocator(), al));
+ BOOST_CHECK(x.empty());
+ BOOST_CHECK(test::equivalent(x.hash_function(), hf));
+ BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+ BOOST_CHECK(test::equivalent(x.get_allocator(), al));
         test::check_equivalent_keys(x);
     }
 }
@@ -165,21 +165,21 @@
     std::cerr<<"Construct 1\n";
     {
         T x(10000, hf1, eq1);
- BOOST_TEST(x.bucket_count() >= 10000);
- BOOST_TEST(test::equivalent(x.hash_function(), hf1));
- BOOST_TEST(test::equivalent(x.key_eq(), eq1));
- BOOST_TEST(test::equivalent(x.get_allocator(), al));
+ BOOST_CHECK(x.bucket_count() >= 10000);
+ BOOST_CHECK(test::equivalent(x.hash_function(), hf1));
+ BOOST_CHECK(test::equivalent(x.key_eq(), eq1));
+ BOOST_CHECK(test::equivalent(x.get_allocator(), al));
         test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 2\n";
     {
         T x(100, hf1);
- BOOST_TEST(x.empty());
- BOOST_TEST(x.bucket_count() >= 100);
- BOOST_TEST(test::equivalent(x.hash_function(), hf1));
- BOOST_TEST(test::equivalent(x.key_eq(), eq));
- BOOST_TEST(test::equivalent(x.get_allocator(), al));
+ BOOST_CHECK(x.empty());
+ BOOST_CHECK(x.bucket_count() >= 100);
+ BOOST_CHECK(test::equivalent(x.hash_function(), hf1));
+ BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+ BOOST_CHECK(test::equivalent(x.get_allocator(), al));
         test::check_equivalent_keys(x);
     }
 
@@ -187,9 +187,9 @@
     {
         test::random_values<T> v(100, generator);
         T x(v.begin(), v.end(), 0, hf1, eq1);
- BOOST_TEST(test::equivalent(x.hash_function(), hf1));
- BOOST_TEST(test::equivalent(x.key_eq(), eq1));
- BOOST_TEST(test::equivalent(x.get_allocator(), al));
+ BOOST_CHECK(test::equivalent(x.hash_function(), hf1));
+ BOOST_CHECK(test::equivalent(x.key_eq(), eq1));
+ BOOST_CHECK(test::equivalent(x.get_allocator(), al));
         test::check_container(x, v);
         test::check_equivalent_keys(x);
     }
@@ -198,10 +198,10 @@
     {
         test::random_values<T> v(5, generator);
         T x(v.begin(), v.end(), 1000, hf1);
- BOOST_TEST(x.bucket_count() >= 1000);
- BOOST_TEST(test::equivalent(x.hash_function(), hf1));
- BOOST_TEST(test::equivalent(x.key_eq(), eq));
- BOOST_TEST(test::equivalent(x.get_allocator(), al));
+ BOOST_CHECK(x.bucket_count() >= 1000);
+ BOOST_CHECK(test::equivalent(x.hash_function(), hf1));
+ BOOST_CHECK(test::equivalent(x.key_eq(), eq));
+ BOOST_CHECK(test::equivalent(x.get_allocator(), al));
         test::check_container(x, v);
         test::check_equivalent_keys(x);
     }

Modified: branches/unordered/trunk/libs/unordered/test/unordered/copy_tests.cpp
==============================================================================
--- branches/unordered/trunk/libs/unordered/test/unordered/copy_tests.cpp (original)
+++ branches/unordered/trunk/libs/unordered/test/unordered/copy_tests.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -27,11 +27,11 @@
     {
         T x;
         T y(x);
- BOOST_TEST(y.empty());
- BOOST_TEST(test::equivalent(y.hash_function(), hf));
- BOOST_TEST(test::equivalent(y.key_eq(), eq));
- BOOST_TEST(test::equivalent(y.get_allocator(), al));
- BOOST_TEST(x.max_load_factor() == y.max_load_factor());
+ BOOST_CHECK(y.empty());
+ BOOST_CHECK(test::equivalent(y.hash_function(), hf));
+ BOOST_CHECK(test::equivalent(y.key_eq(), eq));
+ BOOST_CHECK(test::equivalent(y.get_allocator(), al));
+ BOOST_CHECK(x.max_load_factor() == y.max_load_factor());
         test::check_equivalent_keys(y);
     }
 
@@ -57,7 +57,7 @@
         test::unordered_equivalence_tester<T> equivalent(x);
         equivalent(y);
         // This isn't guaranteed:
- BOOST_TEST(y.load_factor() < y.max_load_factor());
+ BOOST_CHECK(y.load_factor() < y.max_load_factor());
         test::check_equivalent_keys(y);
     }
 }
@@ -75,22 +75,22 @@
     {
         T x(10000, hf, eq, al);
         T y(x);
- BOOST_TEST(y.empty());
- BOOST_TEST(test::equivalent(y.hash_function(), hf));
- BOOST_TEST(test::equivalent(y.key_eq(), eq));
- BOOST_TEST(test::equivalent(y.get_allocator(), al));
- BOOST_TEST(x.max_load_factor() == y.max_load_factor());
+ BOOST_CHECK(y.empty());
+ BOOST_CHECK(test::equivalent(y.hash_function(), hf));
+ BOOST_CHECK(test::equivalent(y.key_eq(), eq));
+ BOOST_CHECK(test::equivalent(y.get_allocator(), al));
+ BOOST_CHECK(x.max_load_factor() == y.max_load_factor());
         test::check_equivalent_keys(y);
     }
 
     {
         T x(1000, hf, eq, al);
         T y(x, al2);
- BOOST_TEST(y.empty());
- BOOST_TEST(test::equivalent(y.hash_function(), hf));
- BOOST_TEST(test::equivalent(y.key_eq(), eq));
- BOOST_TEST(test::equivalent(y.get_allocator(), al2));
- BOOST_TEST(x.max_load_factor() == y.max_load_factor());
+ BOOST_CHECK(y.empty());
+ BOOST_CHECK(test::equivalent(y.hash_function(), hf));
+ BOOST_CHECK(test::equivalent(y.key_eq(), eq));
+ BOOST_CHECK(test::equivalent(y.get_allocator(), al2));
+ BOOST_CHECK(x.max_load_factor() == y.max_load_factor());
         test::check_equivalent_keys(y);
     }
 
@@ -102,7 +102,7 @@
         test::unordered_equivalence_tester<T> equivalent(x);
         equivalent(y);
         test::check_equivalent_keys(y);
- BOOST_TEST(test::equivalent(y.get_allocator(), al));
+ BOOST_CHECK(test::equivalent(y.get_allocator(), al));
     }
 
     {
@@ -113,7 +113,7 @@
         test::unordered_equivalence_tester<T> equivalent(x);
         equivalent(y);
         test::check_equivalent_keys(y);
- BOOST_TEST(test::equivalent(y.get_allocator(), al2));
+ BOOST_CHECK(test::equivalent(y.get_allocator(), al2));
     }
 }
 

Modified: branches/unordered/trunk/libs/unordered/test/unordered/erase_equiv_tests.cpp
==============================================================================
--- branches/unordered/trunk/libs/unordered/test/unordered/erase_equiv_tests.cpp (original)
+++ branches/unordered/trunk/libs/unordered/test/unordered/erase_equiv_tests.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -67,11 +67,11 @@
 
     collide_map x(init.begin(), init.end());
     x.erase(x.begin(), x.begin());
- BOOST_TEST(x.count(1) == 1 && x.size() == 1);
+ BOOST_CHECK(x.count(1) == 1 && x.size() == 1);
     x.erase(x.end(), x.end());
- BOOST_TEST(x.count(1) == 1 && x.size() == 1);
+ BOOST_CHECK(x.count(1) == 1 && x.size() == 1);
     x.erase(x.begin(), x.end());
- BOOST_TEST(x.count(1) == 0 && x.size() == 0);
+ BOOST_CHECK(x.count(1) == 0 && x.size() == 0);
 }
 
 UNORDERED_AUTO_TEST(two_equivalent_item_tests)
@@ -83,14 +83,14 @@
     {
         collide_map x(init.begin(), init.end());
         x.erase(x.begin(), x.end());
- BOOST_TEST(x.count(1) == 0 && x.size() == 0);
+ BOOST_CHECK(x.count(1) == 0 && x.size() == 0);
     }
 
     {
         collide_map x(init.begin(), init.end());
         int value = boost::next(x.begin())->second;
         x.erase(x.begin(), boost::next(x.begin()));
- BOOST_TEST(x.count(1) == 1 && x.size() == 1 &&
+ BOOST_CHECK(x.count(1) == 1 && x.size() == 1 &&
             x.begin()->first == 1 && x.begin()->second == value);
     }
 
@@ -98,7 +98,7 @@
         collide_map x(init.begin(), init.end());
         int value = x.begin()->second;
         x.erase(boost::next(x.begin()), x.end());
- BOOST_TEST(x.count(1) == 1 && x.size() == 1 &&
+ BOOST_CHECK(x.count(1) == 1 && x.size() == 1 &&
                 x.begin()->first == 1 && x.begin()->second == value);
     }
 }

Modified: branches/unordered/trunk/libs/unordered/test/unordered/erase_tests.cpp
==============================================================================
--- branches/unordered/trunk/libs/unordered/test/unordered/erase_tests.cpp (original)
+++ branches/unordered/trunk/libs/unordered/test/unordered/erase_tests.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -32,10 +32,10 @@
         {
             std::size_t count = x.count(test::get_key<Container>(*it));
             std::size_t old_size = x.size();
- BOOST_TEST(count == x.erase(test::get_key<Container>(*it)));
- BOOST_TEST(x.size() == old_size - count);
- BOOST_TEST(x.count(test::get_key<Container>(*it)) == 0);
- BOOST_TEST(x.find(test::get_key<Container>(*it)) == x.end());
+ BOOST_CHECK(count == x.erase(test::get_key<Container>(*it)));
+ BOOST_CHECK(x.size() == old_size - count);
+ BOOST_CHECK(x.count(test::get_key<Container>(*it)) == 0);
+ BOOST_CHECK(x.find(test::get_key<Container>(*it)) == x.end());
         }
     }
 
@@ -50,11 +50,11 @@
             std::size_t count = x.count(key);
             BOOST_DEDUCED_TYPENAME Container::iterator pos = x.erase(x.begin());
             --size;
- BOOST_TEST(pos == x.begin());
- BOOST_TEST(x.count(key) == count - 1);
- BOOST_TEST(x.size() == size);
+ BOOST_CHECK(pos == x.begin());
+ BOOST_CHECK(x.count(key) == count - 1);
+ BOOST_CHECK(x.size() == size);
         }
- BOOST_TEST(x.empty());
+ BOOST_CHECK(x.empty());
     }
 
     std::cerr<<"erase(random position).\n";
@@ -77,15 +77,15 @@
             next = boost::next(pos);
             BOOST_DEDUCED_TYPENAME Container::key_type key = test::get_key<Container>(*pos);
             std::size_t count = x.count(key);
- BOOST_TEST(next == x.erase(pos));
+ BOOST_CHECK(next == x.erase(pos));
             --size;
             if(size > 0)
- BOOST_TEST(index == 0 ? next == x.begin() :
+ BOOST_CHECK(index == 0 ? next == x.begin() :
                         next == boost::next(prev));
- BOOST_TEST(x.count(key) == count - 1);
- BOOST_TEST(x.size() == size);
+ BOOST_CHECK(x.count(key) == count - 1);
+ BOOST_CHECK(x.size() == size);
         }
- BOOST_TEST(x.empty());
+ BOOST_CHECK(x.empty());
     }
 
     std::cerr<<"erase(ranges).\n";
@@ -99,15 +99,15 @@
         // returns 'the iterator immediately following the erase elements'
         // and if nothing is erased, then there's nothing to follow. But I
         // think this is the only sensible option...
- BOOST_TEST(x.erase(x.end(), x.end()) == x.end());
- BOOST_TEST(x.erase(x.begin(), x.begin()) == x.begin());
- BOOST_TEST(x.size() == size);
-
- BOOST_TEST(x.erase(x.begin(), x.end()) == x.end());
- BOOST_TEST(x.empty());
- BOOST_TEST(x.begin() == x.end());
+ BOOST_CHECK(x.erase(x.end(), x.end()) == x.end());
+ BOOST_CHECK(x.erase(x.begin(), x.begin()) == x.begin());
+ BOOST_CHECK(x.size() == size);
+
+ BOOST_CHECK(x.erase(x.begin(), x.end()) == x.end());
+ BOOST_CHECK(x.empty());
+ BOOST_CHECK(x.begin() == x.end());
 
- BOOST_TEST(x.erase(x.begin(), x.end()) == x.begin());
+ BOOST_CHECK(x.erase(x.begin(), x.end()) == x.begin());
     }
 
     std::cerr<<"clear().\n";
@@ -115,8 +115,8 @@
         test::random_values<Container> v(500, generator);
         Container x(v.begin(), v.end());
         x.clear();
- BOOST_TEST(x.empty());
- BOOST_TEST(x.begin() == x.end());
+ BOOST_CHECK(x.empty());
+ BOOST_CHECK(x.begin() == x.end());
     }
 
     std::cerr<<"\n";

Modified: branches/unordered/trunk/libs/unordered/test/unordered/find_tests.cpp
==============================================================================
--- branches/unordered/trunk/libs/unordered/test/unordered/find_tests.cpp (original)
+++ branches/unordered/trunk/libs/unordered/test/unordered/find_tests.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -34,12 +34,12 @@
             BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it1);
             iterator pos = x.find(key);
             BOOST_DEDUCED_TYPENAME X::const_iterator const_pos = x_const.find(key);
- BOOST_TEST(pos != x.end() &&
+ BOOST_CHECK(pos != x.end() &&
                     x.key_eq()(key, test::get_key<X>(*pos)));
- BOOST_TEST(const_pos != x_const.end() &&
+ BOOST_CHECK(const_pos != x_const.end() &&
                     x_const.key_eq()(key, test::get_key<X>(*const_pos)));
 
- BOOST_TEST(x.count(key) == tracker.count(key));
+ BOOST_CHECK(x.count(key) == tracker.count(key));
 
             test::compare_pairs(x.equal_range(key),
                     tracker.equal_range(key),
@@ -56,11 +56,11 @@
             BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it2);
             if(tracker.find(test::get_key<X>(key)) == tracker.end())
             {
- BOOST_TEST(x.find(key) == x.end());
- BOOST_TEST(x_const.find(key) == x_const.end());
- BOOST_TEST(x.count(key) == 0);
+ BOOST_CHECK(x.find(key) == x.end());
+ BOOST_CHECK(x_const.find(key) == x_const.end());
+ BOOST_CHECK(x.count(key) == 0);
                 std::pair<iterator, iterator> range = x.equal_range(key);
- BOOST_TEST(range.first == range.second);
+ BOOST_CHECK(range.first == range.second);
             }
         }
     }
@@ -73,10 +73,10 @@
                 v2.begin(); it3 != v2.end(); ++it3)
         {
             BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it3);
- BOOST_TEST(x.find(key) == x.end());
- BOOST_TEST(x.count(key) == 0);
+ BOOST_CHECK(x.find(key) == x.end());
+ BOOST_CHECK(x.count(key) == 0);
             std::pair<iterator, iterator> range = x.equal_range(key);
- BOOST_TEST(range.first == range.second);
+ BOOST_CHECK(range.first == range.second);
         }
     }
 }

Modified: branches/unordered/trunk/libs/unordered/test/unordered/insert_stable_tests.cpp
==============================================================================
--- branches/unordered/trunk/libs/unordered/test/unordered/insert_stable_tests.cpp (original)
+++ branches/unordered/trunk/libs/unordered/test/unordered/insert_stable_tests.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -47,13 +47,13 @@
     x.insert(insert_stable::member(1,3));
 
     boost::unordered_multiset<insert_stable::member>::const_iterator it = x.begin(), end = x.end();
- BOOST_TEST(it != end);
- if(it != end) { BOOST_TEST(it->tag2_ == 1); ++it; }
- BOOST_TEST(it != end);
- if(it != end) { BOOST_TEST(it->tag2_ == 2); ++it; }
- BOOST_TEST(it != end);
- if(it != end) { BOOST_TEST(it->tag2_ == 3); ++it; }
- BOOST_TEST(it == end);
+ BOOST_CHECK(it != end);
+ if(it != end) { BOOST_CHECK(it->tag2_ == 1); ++it; }
+ BOOST_CHECK(it != end);
+ if(it != end) { BOOST_CHECK(it->tag2_ == 2); ++it; }
+ BOOST_CHECK(it != end);
+ if(it != end) { BOOST_CHECK(it->tag2_ == 3); ++it; }
+ BOOST_CHECK(it == end);
 }
 
 UNORDERED_AUTO_TEST(stable_insert_test2) {
@@ -66,13 +66,13 @@
 
     it = x.begin();
     iterator end = x.end();
- BOOST_TEST(it != end);
- if(it != end) { BOOST_TEST(it->first.tag2_ == 1 && it->second == 1); ++it; }
- BOOST_TEST(it != end);
- if(it != end) { BOOST_TEST(it->first.tag2_ == 2 && it->second == 2); ++it; }
- BOOST_TEST(it != end);
- if(it != end) { BOOST_TEST(it->first.tag2_ == 3 && it->second == 3); ++it; }
- BOOST_TEST(it == end);
+ BOOST_CHECK(it != end);
+ if(it != end) { BOOST_CHECK(it->first.tag2_ == 1 && it->second == 1); ++it; }
+ BOOST_CHECK(it != end);
+ if(it != end) { BOOST_CHECK(it->first.tag2_ == 2 && it->second == 2); ++it; }
+ BOOST_CHECK(it != end);
+ if(it != end) { BOOST_CHECK(it->first.tag2_ == 3 && it->second == 3); ++it; }
+ BOOST_CHECK(it == end);
 }
 
 RUN_TESTS()

Modified: branches/unordered/trunk/libs/unordered/test/unordered/insert_tests.cpp
==============================================================================
--- branches/unordered/trunk/libs/unordered/test/unordered/insert_tests.cpp (original)
+++ branches/unordered/trunk/libs/unordered/test/unordered/insert_tests.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -15,6 +15,8 @@
 #include "../helpers/input_iterator.hpp"
 
 #include <iostream>
+
+namespace insert_tests {
     
 test::seed_t seed(243432);
 
@@ -41,13 +43,13 @@
         std::pair<iterator, bool> r1 = x.insert(*it);
         std::pair<BOOST_DEDUCED_TYPENAME ordered::iterator, bool> r2 = tracker.insert(*it);
 
- BOOST_TEST(r1.second == r2.second);
- BOOST_TEST(*r1.first == *r2.first);
+ BOOST_CHECK(r1.second == r2.second);
+ BOOST_CHECK(*r1.first == *r2.first);
 
         tracker.compare_key(x, *it);
 
         if(x.size() < b * old_bucket_count)
- BOOST_TEST(x.bucket_count() == old_bucket_count);
+ BOOST_CHECK(x.bucket_count() == old_bucket_count);
     }
 
     test::check_equivalent_keys(x);
@@ -71,12 +73,12 @@
         BOOST_DEDUCED_TYPENAME X::iterator r1 = x.insert(*it);
         BOOST_DEDUCED_TYPENAME test::ordered<X>::iterator r2 = tracker.insert(*it);
 
- BOOST_TEST(*r1 == *r2);
+ BOOST_CHECK(*r1 == *r2);
 
         tracker.compare_key(x, *it);
 
         if(x.size() < b * old_bucket_count)
- BOOST_TEST(x.bucket_count() == old_bucket_count);
+ BOOST_CHECK(x.bucket_count() == old_bucket_count);
     }
 
     test::check_equivalent_keys(x);
@@ -105,11 +107,11 @@
 
             iterator r1 = x.insert(x.begin(), *it);
             tracker_iterator r2 = tracker.insert(tracker.begin(), *it);
- BOOST_TEST(*r1 == *r2);
+ BOOST_CHECK(*r1 == *r2);
             tracker.compare_key(x, *it);
 
             if(x.size() < b * old_bucket_count)
- BOOST_TEST(x.bucket_count() == old_bucket_count);
+ BOOST_CHECK(x.bucket_count() == old_bucket_count);
         }
 
         test::check_equivalent_keys(x);
@@ -131,11 +133,11 @@
 
             const_iterator r1 = x.insert(x_const.end(), *it);
             tracker_iterator r2 = tracker.insert(tracker.end(), *it);
- BOOST_TEST(*r1 == *r2);
+ BOOST_CHECK(*r1 == *r2);
             tracker.compare_key(x, *it);
 
             if(x.size() < b * old_bucket_count)
- BOOST_TEST(x.bucket_count() == old_bucket_count);
+ BOOST_CHECK(x.bucket_count() == old_bucket_count);
         }
 
         test::check_equivalent_keys(x);
@@ -157,11 +159,11 @@
 
             pos = x.insert(pos, *it);
             tracker_iterator r2 = tracker.insert(tracker.begin(), *it);
- BOOST_TEST(*pos == *r2);
+ BOOST_CHECK(*pos == *r2);
             tracker.compare_key(x, *it);
 
             if(x.size() < b * old_bucket_count)
- BOOST_TEST(x.bucket_count() == old_bucket_count);
+ BOOST_CHECK(x.bucket_count() == old_bucket_count);
         }
 
         test::check_equivalent_keys(x);
@@ -185,7 +187,7 @@
             tracker.compare_key(x, *it);
 
             if(x.size() < b * old_bucket_count)
- BOOST_TEST(x.bucket_count() == old_bucket_count);
+ BOOST_CHECK(x.bucket_count() == old_bucket_count);
         }
 
         test::check_equivalent_keys(x);
@@ -237,7 +239,7 @@
         tracker.compare_key(x, *it);
 
         if(x.size() < b * old_bucket_count)
- BOOST_TEST(x.bucket_count() == old_bucket_count);
+ BOOST_CHECK(x.bucket_count() == old_bucket_count);
     }
 
     test::check_equivalent_keys(x);
@@ -258,40 +260,39 @@
     test::check_equivalent_keys(x);
 }
 
-int main()
-{
- boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_set;
- boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multiset;
- boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_map;
- boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multimap;
-
- unique_insert_tests1(test_set);
- equivalent_insert_tests1(test_multiset);
- unique_insert_tests1(test_map);
- equivalent_insert_tests1(test_multimap);
-
- unique_insert_tests1(test_set, test::generate_collisions);
- equivalent_insert_tests1(test_multiset, test::generate_collisions);
- unique_insert_tests1(test_map, test::generate_collisions);
- equivalent_insert_tests1(test_multimap, test::generate_collisions);
-
- insert_tests2(test_set);
- insert_tests2(test_multiset);
- insert_tests2(test_map);
- insert_tests2(test_multimap);
-
- insert_tests2(test_set, test::generate_collisions);
- insert_tests2(test_multiset, test::generate_collisions);
- insert_tests2(test_map, test::generate_collisions);
- insert_tests2(test_multimap, test::generate_collisions);
-
- map_tests(test_map);
- map_tests(test_map, test::generate_collisions);
-
- associative_insert_range_test(test_map);
- associative_insert_range_test(test_map, test::generate_collisions);
- associative_insert_range_test(test_multimap);
- associative_insert_range_test(test_multimap, test::generate_collisions);
+boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_set;
+boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multiset;
+boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_map;
+boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multimap;
+
+using test::default_generator;
+using test::generate_collisions;
+
+UNORDERED_TEST(unique_insert_tests1,
+ ((test_set)(test_map))
+ ((default_generator)(generate_collisions))
+)
+
+UNORDERED_TEST(equivalent_insert_tests1,
+ ((test_multiset)(test_multimap))
+ ((default_generator)(generate_collisions))
+)
+
+UNORDERED_TEST(insert_tests2,
+ ((test_set)(test_multiset)(test_map)(test_multimap))
+ ((default_generator)(generate_collisions))
+)
+
+UNORDERED_TEST(map_tests,
+ ((test_map))
+ ((default_generator)(generate_collisions))
+)
+
+UNORDERED_TEST(associative_insert_range_test,
+ ((test_map)(test_multimap))
+ ((default_generator)(generate_collisions))
+)
 
- return boost::report_errors();
 }
+
+RUN_TESTS()

Modified: branches/unordered/trunk/libs/unordered/test/unordered/load_factor_tests.cpp
==============================================================================
--- branches/unordered/trunk/libs/unordered/test/unordered/load_factor_tests.cpp (original)
+++ branches/unordered/trunk/libs/unordered/test/unordered/load_factor_tests.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -24,13 +24,13 @@
 {
     X x;
 
- BOOST_TEST(x.max_load_factor() == 1.0);
- BOOST_TEST(x.load_factor() == 0);
+ BOOST_CHECK(x.max_load_factor() == 1.0);
+ BOOST_CHECK(x.load_factor() == 0);
 
     // A valid implementation could fail these tests, but I think they're
     // reasonable.
- x.max_load_factor(2.0); BOOST_TEST(x.max_load_factor() == 2.0);
- x.max_load_factor(0.5); BOOST_TEST(x.max_load_factor() == 0.5);
+ x.max_load_factor(2.0); BOOST_CHECK(x.max_load_factor() == 2.0);
+ x.max_load_factor(0.5); BOOST_CHECK(x.max_load_factor() == 0.5);
 }
 
 template <class X>
@@ -49,7 +49,7 @@
                  old_bucket_count = x.bucket_count();
         x.insert(*it);
         if(old_size + 1 < b * old_bucket_count)
- BOOST_TEST(x.bucket_count() == old_bucket_count);
+ BOOST_CHECK(x.bucket_count() == old_bucket_count);
     }
 }
 

Modified: branches/unordered/trunk/libs/unordered/test/unordered/move_tests.cpp
==============================================================================
--- branches/unordered/trunk/libs/unordered/test/unordered/move_tests.cpp (original)
+++ branches/unordered/trunk/libs/unordered/test/unordered/move_tests.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -52,11 +52,11 @@
 
         {
             T y(empty(ptr));
- BOOST_TEST(y.empty());
- BOOST_TEST(test::equivalent(y.hash_function(), hf));
- BOOST_TEST(test::equivalent(y.key_eq(), eq));
- BOOST_TEST(test::equivalent(y.get_allocator(), al));
- BOOST_TEST(y.max_load_factor() == 1.0);
+ BOOST_CHECK(y.empty());
+ BOOST_CHECK(test::equivalent(y.hash_function(), hf));
+ BOOST_CHECK(test::equivalent(y.key_eq(), eq));
+ BOOST_CHECK(test::equivalent(y.get_allocator(), al));
+ BOOST_CHECK(y.max_load_factor() == 1.0);
             test::check_equivalent_keys(y);
         }
 
@@ -64,7 +64,7 @@
             test::random_values<T> v(1000);
             BOOST_DEDUCED_TYPENAME T::value_type const* first = 0;
             T y(create(v, first));
- BOOST_TEST(first == &*y.begin());
+ BOOST_CHECK(first == &*y.begin());
             test::check_container(y, v);
             test::check_equivalent_keys(y);
         }
@@ -78,7 +78,7 @@
             BOOST_DEDUCED_TYPENAME T::value_type const* first = 0;
             T y;
             y = create(v, first);
- BOOST_TEST(first == &*y.begin());
+ BOOST_CHECK(first == &*y.begin());
             test::check_container(y, v);
             test::check_equivalent_keys(y);
         }
@@ -100,12 +100,12 @@
         {
             test::random_values<T> v(500);
             T y(create(v, first, hf, eq, al, 0.5));
- BOOST_TEST(first == &*y.begin());
+ BOOST_CHECK(first == &*y.begin());
             test::check_container(y, v);
- BOOST_TEST(test::equivalent(y.hash_function(), hf));
- BOOST_TEST(test::equivalent(y.key_eq(), eq));
- BOOST_TEST(test::equivalent(y.get_allocator(), al));
- BOOST_TEST(y.max_load_factor() == 0.5); // Not necessarily required.
+ BOOST_CHECK(test::equivalent(y.hash_function(), hf));
+ BOOST_CHECK(test::equivalent(y.key_eq(), eq));
+ BOOST_CHECK(test::equivalent(y.get_allocator(), al));
+ BOOST_CHECK(y.max_load_factor() == 0.5); // Not necessarily required.
             test::check_equivalent_keys(y);
         }
 
@@ -113,24 +113,24 @@
             // TODO: To do this correctly requires the fancy new allocator stuff.
             test::random_values<T> v(500);
             T y(create(v, first, hf, eq, al, 2.0), al2);
- BOOST_TEST(first != &*y.begin());
+ BOOST_CHECK(first != &*y.begin());
             test::check_container(y, v);
- BOOST_TEST(test::equivalent(y.hash_function(), hf));
- BOOST_TEST(test::equivalent(y.key_eq(), eq));
- BOOST_TEST(test::equivalent(y.get_allocator(), al2));
- BOOST_TEST(y.max_load_factor() == 2.0); // Not necessarily required.
+ BOOST_CHECK(test::equivalent(y.hash_function(), hf));
+ BOOST_CHECK(test::equivalent(y.key_eq(), eq));
+ BOOST_CHECK(test::equivalent(y.get_allocator(), al2));
+ BOOST_CHECK(y.max_load_factor() == 2.0); // Not necessarily required.
             test::check_equivalent_keys(y);
         }
 
         {
             test::random_values<T> v(25);
             T y(create(v, first, hf, eq, al, 1.0), al);
- BOOST_TEST(first == &*y.begin());
+ BOOST_CHECK(first == &*y.begin());
             test::check_container(y, v);
- BOOST_TEST(test::equivalent(y.hash_function(), hf));
- BOOST_TEST(test::equivalent(y.key_eq(), eq));
- BOOST_TEST(test::equivalent(y.get_allocator(), al));
- BOOST_TEST(y.max_load_factor() == 1.0); // Not necessarily required.
+ BOOST_CHECK(test::equivalent(y.hash_function(), hf));
+ BOOST_CHECK(test::equivalent(y.key_eq(), eq));
+ BOOST_CHECK(test::equivalent(y.get_allocator(), al));
+ BOOST_CHECK(y.max_load_factor() == 1.0); // Not necessarily required.
             test::check_equivalent_keys(y);
         }
     }

Modified: branches/unordered/trunk/libs/unordered/test/unordered/rehash_tests.cpp
==============================================================================
--- branches/unordered/trunk/libs/unordered/test/unordered/rehash_tests.cpp (original)
+++ branches/unordered/trunk/libs/unordered/test/unordered/rehash_tests.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -26,10 +26,10 @@
     X x;
 
     x.rehash(10000);
- BOOST_TEST(postcondition(x, 10000));
+ BOOST_CHECK(postcondition(x, 10000));
 
     x.rehash(0);
- BOOST_TEST(postcondition(x, 0));
+ BOOST_CHECK(postcondition(x, 0));
 }
 
 template <class X>
@@ -40,18 +40,18 @@
     tracker.insert_range(v.begin(), v.end());
     X x(v.begin(), v.end());
 
- x.rehash(0); BOOST_TEST(postcondition(x, 0));
+ x.rehash(0); BOOST_CHECK(postcondition(x, 0));
     tracker.compare(x);
 
     x.max_load_factor(0.25);
- x.rehash(0); BOOST_TEST(postcondition(x, 0));
+ x.rehash(0); BOOST_CHECK(postcondition(x, 0));
     tracker.compare(x);
 
     x.max_load_factor(50.0);
- x.rehash(0); BOOST_TEST(postcondition(x, 0));
+ x.rehash(0); BOOST_CHECK(postcondition(x, 0));
     tracker.compare(x);
 
- x.rehash(1000); BOOST_TEST(postcondition(x, 1000));
+ x.rehash(1000); BOOST_CHECK(postcondition(x, 1000));
     tracker.compare(x);
 }
 

Modified: branches/unordered/trunk/libs/unordered/test/unordered/simple_tests.cpp
==============================================================================
--- branches/unordered/trunk/libs/unordered/test/unordered/simple_tests.cpp (original)
+++ branches/unordered/trunk/libs/unordered/test/unordered/simple_tests.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -19,67 +19,67 @@
 
     {
         X u;
- BOOST_TEST(u.size() == 0);
- BOOST_TEST(X().size() == 0);
+ BOOST_CHECK(u.size() == 0);
+ BOOST_CHECK(X().size() == 0);
     }
 
     {
- BOOST_TEST(equivalent(X(a)));
+ BOOST_CHECK(equivalent(X(a)));
     }
 
     {
         X u(a);
- BOOST_TEST(equivalent(u));
+ BOOST_CHECK(equivalent(u));
     }
 
     {
         X u = a;
- BOOST_TEST(equivalent(u));
+ BOOST_CHECK(equivalent(u));
     }
 
     {
         X b(a);
- BOOST_TEST(b.begin() == const_cast<X const&>(b).cbegin());
- BOOST_TEST(b.end() == const_cast<X const&>(b).cend());
+ BOOST_CHECK(b.begin() == const_cast<X const&>(b).cbegin());
+ BOOST_CHECK(b.end() == const_cast<X const&>(b).cend());
     }
 
     {
         X b(a);
         X c;
- BOOST_TEST(equivalent(b));
- BOOST_TEST(c.empty());
+ BOOST_CHECK(equivalent(b));
+ BOOST_CHECK(c.empty());
         b.swap(c);
- BOOST_TEST(b.empty());
- BOOST_TEST(equivalent(c));
+ BOOST_CHECK(b.empty());
+ BOOST_CHECK(equivalent(c));
         b.swap(c);
- BOOST_TEST(c.empty());
- BOOST_TEST(equivalent(b));
+ BOOST_CHECK(c.empty());
+ BOOST_CHECK(equivalent(b));
     }
 
     {
         X u;
         X& r = u;
- BOOST_TEST(&(r = r) == &r);
- BOOST_TEST(r.empty());
- BOOST_TEST(&(r = a) == &r);
- BOOST_TEST(equivalent(r));
- BOOST_TEST(&(r = r) == &r);
- BOOST_TEST(equivalent(r));
+ BOOST_CHECK(&(r = r) == &r);
+ BOOST_CHECK(r.empty());
+ BOOST_CHECK(&(r = a) == &r);
+ BOOST_CHECK(equivalent(r));
+ BOOST_CHECK(&(r = r) == &r);
+ BOOST_CHECK(equivalent(r));
     }
 
     {
- BOOST_TEST(a.size() ==
+ BOOST_CHECK(a.size() ==
                 (BOOST_DEDUCED_TYPENAME X::size_type) std::distance(a.begin(), a.end()));
     }
 
     {
- BOOST_TEST(a.empty() == (a.size() == 0));
+ BOOST_CHECK(a.empty() == (a.size() == 0));
     }
 
     {
- BOOST_TEST(a.empty() == (a.begin() == a.end()));
+ BOOST_CHECK(a.empty() == (a.begin() == a.end()));
         X u;
- BOOST_TEST(u.begin() == u.end());
+ BOOST_CHECK(u.begin() == u.end());
     }
 }
 

Modified: branches/unordered/trunk/libs/unordered/test/unordered/unnecessary_copy_tests.cpp
==============================================================================
--- branches/unordered/trunk/libs/unordered/test/unordered/unnecessary_copy_tests.cpp (original)
+++ branches/unordered/trunk/libs/unordered/test/unordered/unnecessary_copy_tests.cpp 2008-04-14 14:02:03 EDT (Mon, 14 Apr 2008)
@@ -44,9 +44,9 @@
         count_copies::count = 0;
         T x;
         BOOST_DEDUCED_TYPENAME T::value_type a;
- BOOST_TEST(count_copies::count == 1);
+ BOOST_CHECK(count_copies::count == 1);
         x.insert(a);
- BOOST_TEST(count_copies::count == 2);
+ BOOST_CHECK(count_copies::count == 2);
     }
 
     boost::unordered_set<count_copies>* set;


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk