diff --git a/test/Jamfile b/test/Jamfile
index f87d49e..d1a2550 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -14,7 +14,6 @@ rule hash-test ( names + : extras * )
 {
     return [
         run $(names).cpp
-        <lib>../../../test/build/boost_unit_test_framework
         : : : <include>$(BOOST_ROOT) $(extras)
         : $(names[1])
         ] ;
diff --git a/test/Jamfile.v2 b/test/Jamfile.v2
index b1c714b..dbc878b 100644
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -6,8 +6,6 @@
 
 import testing ;
 
-alias framework : /boost/test//boost_unit_test_framework ;
-
 project hash-tests
     : requirements
         <toolset>gcc:<define>_GLIBCXX_DEBUG
@@ -15,24 +13,24 @@ project hash-tests
 
 test-suite functional/hash
     :
-        [ run hash_fwd_test_1.cpp framework ]
-        [ run hash_fwd_test_2.cpp framework ]
-        [ run hash_number_test.cpp framework ]
-        [ run hash_pointer_test.cpp framework ]
-        [ run hash_function_pointer_test.cpp framework ]
-        [ run hash_float_test.cpp framework : : : <test-info>always_show_run_output ]
-        [ run hash_string_test.cpp framework ]
-        [ run hash_range_test.cpp framework ]
-        [ run hash_custom_test.cpp framework ]
-        [ run hash_global_namespace_test.cpp framework ]
-        [ run hash_friend_test.cpp framework ]
-        [ run hash_built_in_array_test.cpp framework ]
-        [ run hash_value_array_test.cpp framework ]
-        [ run hash_vector_test.cpp framework ]
-        [ run hash_list_test.cpp framework ]
-        [ run hash_deque_test.cpp framework ]
-        [ run hash_set_test.cpp framework ]
-        [ run hash_map_test.cpp framework ]
+        [ run hash_fwd_test_1.cpp ]
+        [ run hash_fwd_test_2.cpp ]
+        [ run hash_number_test.cpp ]
+        [ run hash_pointer_test.cpp ]
+        [ run hash_function_pointer_test.cpp ]
+        [ run hash_float_test.cpp : : : <test-info>always_show_run_output ]
+        [ run hash_string_test.cpp ]
+        [ run hash_range_test.cpp ]
+        [ run hash_custom_test.cpp ]
+        [ run hash_global_namespace_test.cpp ]
+        [ run hash_friend_test.cpp ]
+        [ run hash_built_in_array_test.cpp ]
+        [ run hash_value_array_test.cpp ]
+        [ run hash_vector_test.cpp ]
+        [ run hash_list_test.cpp ]
+        [ run hash_deque_test.cpp ]
+        [ run hash_set_test.cpp ]
+        [ run hash_map_test.cpp ]
         [ run link_test.cpp link_test_2.cpp ]
         [ run container_fwd_test.cpp ]
     ;
diff --git a/test/hash_built_in_array_test.cpp b/test/hash_built_in_array_test.cpp
index a9b1aa4..6d2f943 100644
--- a/test/hash_built_in_array_test.cpp
+++ b/test/hash_built_in_array_test.cpp
@@ -14,12 +14,11 @@
 #  endif
 #endif
 
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef TEST_EXTENSIONS
 
-BOOST_AUTO_TEST_CASE(array_int_test)
+void array_int_test()
 {
     const int length1 = 25;
     int array1[25] = {
@@ -39,15 +38,15 @@ BOOST_AUTO_TEST_CASE(array_int_test)
     int array3[2] = {2, 3};
     HASH_NAMESPACE::hash<int[2]> hasher3;
 
-    BOOST_CHECK(hasher1(array1)
+    BOOST_TEST(hasher1(array1)
             == HASH_NAMESPACE::hash_range(array1, array1 + length1));
-    BOOST_CHECK(hasher2(array2)
+    BOOST_TEST(hasher2(array2)
             == HASH_NAMESPACE::hash_range(array2, array2 + length2));
-    BOOST_CHECK(hasher3(array3)
+    BOOST_TEST(hasher3(array3)
             == HASH_NAMESPACE::hash_range(array3, array3 + length3));
 }
 
-BOOST_AUTO_TEST_CASE(two_dimensional_array_test)
+void two_dimensional_array_test()
 {
     int array[3][2] = {{-5, 6}, {7, -3}, {26, 1}};
     HASH_NAMESPACE::hash<int[3][2]> hasher;
@@ -61,9 +60,17 @@ BOOST_AUTO_TEST_CASE(two_dimensional_array_test)
         HASH_NAMESPACE::hash_combine(seed1, seed2);
     }
 
-    BOOST_CHECK(hasher(array) == seed1);
-    BOOST_CHECK(hasher(array) == HASH_NAMESPACE::hash_range(array, array + 3));
+    BOOST_TEST(hasher(array) == seed1);
+    BOOST_TEST(hasher(array) == HASH_NAMESPACE::hash_range(array, array + 3));
 }
 
 #endif // TEST_EXTENSIONS
 
+int main()
+{
+#ifdef TEST_EXTENSIONS
+    array_int_test();
+    two_dimensional_array_test();
+#endif
+    return boost::report_errors();
+}
diff --git a/test/hash_custom_test.cpp b/test/hash_custom_test.cpp
index 735d166..613f128 100644
--- a/test/hash_custom_test.cpp
+++ b/test/hash_custom_test.cpp
@@ -49,8 +49,7 @@ namespace boost
 #  endif
 #endif
 
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -58,16 +57,16 @@ namespace boost
 #include <string>
 #include <cctype>
 
-BOOST_AUTO_TEST_CASE(custom_tests)
+void custom_tests()
 {
     HASH_NAMESPACE::hash<test::custom> custom_hasher;
-    BOOST_CHECK(custom_hasher(10) == 100u);
+    BOOST_TEST(custom_hasher(10) == 100u);
     test::custom x(55);
-    BOOST_CHECK(custom_hasher(x) == 550u);
+    BOOST_TEST(custom_hasher(x) == 550u);
 
     {
         using namespace HASH_NAMESPACE;
-        BOOST_CHECK(custom_hasher(x) == hash_value(x));
+        BOOST_TEST(custom_hasher(x) == hash_value(x));
     }
 
     std::vector<test::custom> custom_vector;
@@ -85,9 +84,17 @@ BOOST_AUTO_TEST_CASE(custom_tests)
     HASH_NAMESPACE::hash_combine(seed2, 250u);
     HASH_NAMESPACE::hash_combine(seed2, 350u);
 
-    BOOST_CHECK(seed ==
+    BOOST_TEST(seed ==
             HASH_NAMESPACE::hash_range(custom_vector.begin(), custom_vector.end()));
-    BOOST_CHECK(seed == seed2);
+    BOOST_TEST(seed == seed2);
 }
 
 #endif // TEST_EXTENSIONS
+
+int main()
+{
+#ifdef TEST_EXTENSIONS
+    custom_tests();
+#endif
+    return boost::report_errors();
+}
diff --git a/test/hash_deque_test.cpp b/test/hash_deque_test.cpp
index 2fa8c9d..901dd17 100644
--- a/test/hash_deque_test.cpp
+++ b/test/hash_deque_test.cpp
@@ -14,8 +14,7 @@
 #  endif
 #endif
 
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -26,3 +25,12 @@ using std::deque;
 #include "./hash_sequence_test.hpp"
 
 #endif // TEST_EXTENSIONS
+
+int main()
+{
+#ifdef TEST_EXTENSIONS
+    deque_tests::deque_hash_integer_tests();
+#endif
+
+    return boost::report_errors();
+}
diff --git a/test/hash_float_test.cpp b/test/hash_float_test.cpp
index 6c247ac..9bca421 100644
--- a/test/hash_float_test.cpp
+++ b/test/hash_float_test.cpp
@@ -11,8 +11,7 @@
 #  include <boost/functional/hash/hash.hpp>
 #endif
 
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #include <cmath>
 #include <boost/limits.hpp>
@@ -22,7 +21,7 @@
 template <class T>
 void float_tests(char const* name, T* = 0)
 {
-    std::cout<<"\n"
+    std::cerr<<"\n"
         <<"Testing " BOOST_STRINGIZE(HASH_NAMESPACE) "::hash<"<<name<<">\n"
         <<"\n"
         <<"std::numeric_limits<T>::digits = "
@@ -39,17 +38,17 @@ void float_tests(char const* name, T* = 0)
     T zero = 0;
     T minus_zero = (T) -1 * zero;
 
-    BOOST_CHECK(zero == minus_zero);
-    BOOST_CHECK(x1(zero) == x1(minus_zero));
+    BOOST_TEST(zero == minus_zero);
+    BOOST_TEST(x1(zero) == x1(minus_zero));
 
-    BOOST_CHECK(x1(zero) == HASH_NAMESPACE::hash_value(zero));
-    BOOST_CHECK(x1(minus_zero) == HASH_NAMESPACE::hash_value(minus_zero));
+    BOOST_TEST(x1(zero) == HASH_NAMESPACE::hash_value(zero));
+    BOOST_TEST(x1(minus_zero) == HASH_NAMESPACE::hash_value(minus_zero));
 
     using namespace std;
 
 // Doing anything with infinity causes borland to crash.
 #if defined(__BORLANDC__)
-    std::cout<<"Not running infinity checks on Borland, as it causes it to crash.\n";
+    std::cerr<<"Not running infinity checks on Borland, as it causes it to crash.\n";
 #else
     if(std::numeric_limits<T>::has_infinity) {
         T infinity = -log(zero);
@@ -61,45 +60,45 @@ void float_tests(char const* name, T* = 0)
         T minus_infinity2 = (T) -1. / zero;
         T minus_infinity3 = (T) 1. / minus_zero;
 
-        BOOST_CHECK(x1(infinity) == HASH_NAMESPACE::hash_value(infinity));
-        BOOST_CHECK(x1(minus_infinity)
+        BOOST_TEST(x1(infinity) == HASH_NAMESPACE::hash_value(infinity));
+        BOOST_TEST(x1(minus_infinity)
                 == HASH_NAMESPACE::hash_value(minus_infinity));
 
-        BOOST_CHECK(infinity == infinity2);
-        BOOST_CHECK(infinity == infinity3);
-        BOOST_CHECK(infinity == infinity4);
-        BOOST_CHECK(x1(infinity) == x1(infinity2));
-        BOOST_CHECK(x1(infinity) == x1(infinity3));
-        BOOST_CHECK(x1(infinity) == x1(infinity4));
+        BOOST_TEST(infinity == infinity2);
+        BOOST_TEST(infinity == infinity3);
+        BOOST_TEST(infinity == infinity4);
+        BOOST_TEST(x1(infinity) == x1(infinity2));
+        BOOST_TEST(x1(infinity) == x1(infinity3));
+        BOOST_TEST(x1(infinity) == x1(infinity4));
 
-        BOOST_CHECK(minus_infinity == minus_infinity2);
-        BOOST_CHECK(x1(minus_infinity) == x1(minus_infinity2));
-        BOOST_CHECK(minus_infinity == minus_infinity3);
-        BOOST_CHECK(x1(minus_infinity) == x1(minus_infinity3));
+        BOOST_TEST(minus_infinity == minus_infinity2);
+        BOOST_TEST(x1(minus_infinity) == x1(minus_infinity2));
+        BOOST_TEST(minus_infinity == minus_infinity3);
+        BOOST_TEST(x1(minus_infinity) == x1(minus_infinity3));
 
-        BOOST_CHECK(infinity != minus_infinity);
+        BOOST_TEST(infinity != minus_infinity);
 
         // My hash fails this one, I guess it's not that bad.
         if(x1(infinity) == x1(minus_infinity)) {
-            std::cout<<"x1(infinity) == x1(-infinity) == "<<x1(infinity)<<"\n";
+            std::cerr<<"x1(infinity) == x1(-infinity) == "<<x1(infinity)<<"\n";
         }
 
         // This should really be 'has_denorm == denorm_present' but some
         // compilers don't have 'denorm_present'. See also a later use.
         if(std::numeric_limits<T>::has_denorm) {
             if(x1(std::numeric_limits<T>::denorm_min()) == x1(infinity)) {
-                std::cout<<"x1(denorm_min) == x1(infinity) == "<<x1(infinity)<<"\n";
+                std::cerr<<"x1(denorm_min) == x1(infinity) == "<<x1(infinity)<<"\n";
             }
             if(x1(std::numeric_limits<T>::denorm_min()) == x1(minus_infinity)) {
-                std::cout<<"x1(denorm_min) == x1(-infinity) == "<<x1(minus_infinity)<<"\n";
+                std::cerr<<"x1(denorm_min) == x1(-infinity) == "<<x1(minus_infinity)<<"\n";
             }
         }
         if(std::numeric_limits<T>::has_quiet_NaN) {
             if(x1(std::numeric_limits<T>::quiet_NaN()) == x1(infinity)) {
-                std::cout<<"x1(quiet_NaN) == x1(infinity) == "<<x1(infinity)<<"\n";
+                std::cerr<<"x1(quiet_NaN) == x1(infinity) == "<<x1(infinity)<<"\n";
             }
             if(x1(std::numeric_limits<T>::quiet_NaN()) == x1(minus_infinity)) {
-                std::cout<<"x1(quiet_NaN) == x1(-infinity) == "<<x1(minus_infinity)<<"\n";
+                std::cerr<<"x1(quiet_NaN) == x1(-infinity) == "<<x1(minus_infinity)<<"\n";
             }
         }
     }
@@ -110,74 +109,76 @@ void float_tests(char const* name, T* = 0)
     T quarter_max = max / 4;
     T three_quarter_max = max - quarter_max;
 
-    BOOST_CHECK(x1(max) == HASH_NAMESPACE::hash_value(max));
-    BOOST_CHECK(x1(half_max) == HASH_NAMESPACE::hash_value(half_max));
-    BOOST_CHECK(x1(quarter_max) == HASH_NAMESPACE::hash_value(quarter_max));
-    BOOST_CHECK(x1(three_quarter_max) == HASH_NAMESPACE::hash_value(three_quarter_max));
+    BOOST_TEST(x1(max) == HASH_NAMESPACE::hash_value(max));
+    BOOST_TEST(x1(half_max) == HASH_NAMESPACE::hash_value(half_max));
+    BOOST_TEST(x1(quarter_max) == HASH_NAMESPACE::hash_value(quarter_max));
+    BOOST_TEST(x1(three_quarter_max) == HASH_NAMESPACE::hash_value(three_quarter_max));
 
     // The '!=' tests could legitimately fail, but with my hash it indicates a bug.
-    BOOST_CHECK(x1(max) == x1(max));
-    BOOST_CHECK(x1(max) != x1(quarter_max));
-    BOOST_CHECK(x1(max) != x1(half_max));
-    BOOST_CHECK(x1(max) != x1(three_quarter_max));
-    BOOST_CHECK(x1(quarter_max) == x1(quarter_max));
-    BOOST_CHECK(x1(quarter_max) != x1(half_max));
-    BOOST_CHECK(x1(quarter_max) != x1(three_quarter_max));
-    BOOST_CHECK(x1(half_max) == x1(half_max));
-    BOOST_CHECK(x1(half_max) != x1(three_quarter_max));
-    BOOST_CHECK(x1(three_quarter_max) == x1(three_quarter_max));
+    BOOST_TEST(x1(max) == x1(max));
+    BOOST_TEST(x1(max) != x1(quarter_max));
+    BOOST_TEST(x1(max) != x1(half_max));
+    BOOST_TEST(x1(max) != x1(three_quarter_max));
+    BOOST_TEST(x1(quarter_max) == x1(quarter_max));
+    BOOST_TEST(x1(quarter_max) != x1(half_max));
+    BOOST_TEST(x1(quarter_max) != x1(three_quarter_max));
+    BOOST_TEST(x1(half_max) == x1(half_max));
+    BOOST_TEST(x1(half_max) != x1(three_quarter_max));
+    BOOST_TEST(x1(three_quarter_max) == x1(three_quarter_max));
 
     T v1 = asin((T) 1);
     T v2 = acos((T) 0);
     if(v1 == v2)
-        BOOST_CHECK(x1(v1) == x1(v2));
-    BOOST_CHECK(x1(v1) == HASH_NAMESPACE::hash_value(v1));
-    BOOST_CHECK(x1(v2) == HASH_NAMESPACE::hash_value(v2));
+        BOOST_TEST(x1(v1) == x1(v2));
+    BOOST_TEST(x1(v1) == HASH_NAMESPACE::hash_value(v1));
+    BOOST_TEST(x1(v2) == HASH_NAMESPACE::hash_value(v2));
 
-    BOOST_CHECK(x1(std::numeric_limits<T>::epsilon()) ==
+    BOOST_TEST(x1(std::numeric_limits<T>::epsilon()) ==
             HASH_NAMESPACE::hash_value(std::numeric_limits<T>::epsilon()));
 
-    BOOST_CHECK(std::numeric_limits<T>::epsilon() != (T) 0);
+    BOOST_TEST(std::numeric_limits<T>::epsilon() != (T) 0);
     if(x1(std::numeric_limits<T>::epsilon()) == x1((T) 0))
-        std::cout<<"x1(epsilon) == x1(0) == "<<x1((T) 0)<<"\n";
+        std::cerr<<"x1(epsilon) == x1(0) == "<<x1((T) 0)<<"\n";
 
-    BOOST_CHECK(-std::numeric_limits<T>::epsilon() != (T) 0);
+    BOOST_TEST(-std::numeric_limits<T>::epsilon() != (T) 0);
     if(x1(-std::numeric_limits<T>::epsilon()) == x1((T) 0))
-        std::cout<<"x1(-epsilon) == x1(0) == "<<x1((T) 0)<<"\n";
+        std::cerr<<"x1(-epsilon) == x1(0) == "<<x1((T) 0)<<"\n";
 
-    BOOST_CHECK((T) 1 + std::numeric_limits<T>::epsilon() != (T) 1);
+    BOOST_TEST((T) 1 + std::numeric_limits<T>::epsilon() != (T) 1);
     if(x1((T) 1 + std::numeric_limits<T>::epsilon()) == x1((T) 1))
-        std::cout<<"x1(1 + epsilon) == x1(1) == "<<x1((T) 1)<<"\n";
+        std::cerr<<"x1(1 + epsilon) == x1(1) == "<<x1((T) 1)<<"\n";
 
-    BOOST_CHECK((T) 1 - std::numeric_limits<T>::epsilon() != (T) 1);
+    BOOST_TEST((T) 1 - std::numeric_limits<T>::epsilon() != (T) 1);
     if(x1((T) 1 - std::numeric_limits<T>::epsilon()) == x1((T) 1))
-        std::cout<<"x1(1 - epsilon) == x1(1) == "<<x1((T) 1)<<"\n";
+        std::cerr<<"x1(1 - epsilon) == x1(1) == "<<x1((T) 1)<<"\n";
 
-    BOOST_CHECK((T) -1 + std::numeric_limits<T>::epsilon() != (T) -1);
+    BOOST_TEST((T) -1 + std::numeric_limits<T>::epsilon() != (T) -1);
     if(x1((T) -1 + std::numeric_limits<T>::epsilon()) == x1((T) -1))
-        std::cout<<"x1(-1 + epsilon) == x1(-1) == "<<x1((T) -1)<<"\n";
+        std::cerr<<"x1(-1 + epsilon) == x1(-1) == "<<x1((T) -1)<<"\n";
 
-    BOOST_CHECK((T) -1 - std::numeric_limits<T>::epsilon() != (T) -1);
+    BOOST_TEST((T) -1 - std::numeric_limits<T>::epsilon() != (T) -1);
     if(x1((T) -1 - std::numeric_limits<T>::epsilon()) == x1((T) -1))
-        std::cout<<"x1(-1 - epsilon) == x1(-1) == "<<x1((T) -1)<<"\n";
+        std::cerr<<"x1(-1 - epsilon) == x1(-1) == "<<x1((T) -1)<<"\n";
 
     // As before.
     if(std::numeric_limits<T>::has_denorm) {
         if(x1(std::numeric_limits<T>::denorm_min()) == x1(zero)) {
-            std::cout<<"x1(denorm_min) == x1(zero) == "<<x1(zero)<<"\n";
+            std::cerr<<"x1(denorm_min) == x1(zero) == "<<x1(zero)<<"\n";
         }
 #if !BOOST_WORKAROUND(__DECCXX_VER,<70190006)
         // The Tru64/CXX standard library prior to 7.1 contains a bug in the
         // specialization of std::numeric_limits::denorm_min() for long
         // doubles which causes this test to fail.
-        BOOST_CHECK_MESSAGE(x1(std::numeric_limits<T>::denorm_min()) ==
-            HASH_NAMESPACE::hash_value(std::numeric_limits<T>::denorm_min()),
-            "x1(std::numeric_limits<T>::denorm_min()) = "
+        if(x1(std::numeric_limits<T>::denorm_min()) !=
+            HASH_NAMESPACE::hash_value(std::numeric_limits<T>::denorm_min()))
+        {
+            std::cerr<<"x1(std::numeric_limits<T>::denorm_min()) = "
                 << x1(std::numeric_limits<T>::denorm_min())
                 << "\nhash_value(std::numeric_limits<T>::denorm_min()) = "
                 << HASH_NAMESPACE::hash_value(
-                    std::numeric_limits<T>::denorm_min())
-                << "\nx1(0) = "<<x1(0)<<"\n");
+                        std::numeric_limits<T>::denorm_min())
+                << "\nx1(0) = "<<x1(0)<<"\n";
+        }
 #endif
     }
 
@@ -185,29 +186,39 @@ void float_tests(char const* name, T* = 0)
 #if !defined(__BORLANDC__)
     if(std::numeric_limits<T>::has_quiet_NaN) {
         if(x1(std::numeric_limits<T>::quiet_NaN()) == x1(1.0)) {
-            std::cout<<"x1(quiet_NaN) == x1(1.0) == "<<x1(1.0)<<"\n";
+            std::cerr<<"x1(quiet_NaN) == x1(1.0) == "<<x1(1.0)<<"\n";
         }
-        BOOST_CHECK(x1(std::numeric_limits<T>::quiet_NaN()) ==
+        BOOST_TEST(x1(std::numeric_limits<T>::quiet_NaN()) ==
             HASH_NAMESPACE::hash_value(std::numeric_limits<T>::quiet_NaN()));
     }
 #endif
 }
 
-BOOST_AUTO_TEST_CASE(hash_float_tests)
+void hash_float_tests()
 {
-    std::cout<<"Compiler: "<<BOOST_COMPILER<<"\n";
-    std::cout<<"Platform: "<<BOOST_PLATFORM<<"\n";
-    std::cout<<"Library: "<<BOOST_STDLIB<<"\n\n";
+    std::cerr<<"Compiler: "<<BOOST_COMPILER<<"\n";
+    std::cerr<<"Platform: "<<BOOST_PLATFORM<<"\n";
+    std::cerr<<"Library: "<<BOOST_STDLIB<<"\n\n";
 
     float_tests("float", (float*) 0);
 }
 
-BOOST_AUTO_TEST_CASE(hash_double_tests)
+void hash_double_tests()
 {
     float_tests("double", (double*) 0);
 }
 
-BOOST_AUTO_TEST_CASE(hash_long_double_tests)
+void hash_long_double_tests()
 {
     float_tests("long double", (long double*) 0);
 }
+
+int main()
+{
+    hash_float_tests();
+    hash_double_tests();
+    hash_long_double_tests();
+
+    return boost::report_errors();
+}
+
diff --git a/test/hash_friend_test.cpp b/test/hash_friend_test.cpp
index a064ba6..e6fe156 100644
--- a/test/hash_friend_test.cpp
+++ b/test/hash_friend_test.cpp
@@ -51,8 +51,7 @@ namespace boost
 #  endif
 #endif
 
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -60,16 +59,16 @@ namespace boost
 #include <string>
 #include <cctype>
 
-BOOST_AUTO_TEST_CASE(custom_tests)
+void custom_tests()
 {
     HASH_NAMESPACE::hash<test::custom<int> > custom_hasher;
-    BOOST_CHECK(custom_hasher(10) == 100u);
+    BOOST_TEST(custom_hasher(10) == 100u);
     test::custom<int> x(55);
-    BOOST_CHECK(custom_hasher(x) == 550u);
+    BOOST_TEST(custom_hasher(x) == 550u);
 
     {
         using namespace HASH_NAMESPACE;
-        BOOST_CHECK(custom_hasher(x) == hash_value(x));
+        BOOST_TEST(custom_hasher(x) == hash_value(x));
     }
 
     std::vector<test::custom<int> > custom_vector;
@@ -87,10 +86,17 @@ BOOST_AUTO_TEST_CASE(custom_tests)
     HASH_NAMESPACE::hash_combine(seed2, 250u);
     HASH_NAMESPACE::hash_combine(seed2, 350u);
 
-    BOOST_CHECK(seed ==
+    BOOST_TEST(seed ==
             HASH_NAMESPACE::hash_range(custom_vector.begin(), custom_vector.end()));
-    BOOST_CHECK(seed == seed2);
+    BOOST_TEST(seed == seed2);
 }
 
 #endif // TEST_EXTENSIONS
 
+int main()
+{
+#ifdef TEST_EXTENSIONS
+    custom_tests();
+#endif
+    return boost::report_errors();
+}
diff --git a/test/hash_function_pointer_test.cpp b/test/hash_function_pointer_test.cpp
index ba63d36..5790a38 100644
--- a/test/hash_function_pointer_test.cpp
+++ b/test/hash_function_pointer_test.cpp
@@ -12,8 +12,7 @@
 #  include <boost/functional/hash/hash.hpp>
 #endif
 
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #include <boost/limits.hpp>
 #include <boost/mpl/assert.hpp>
@@ -26,7 +25,7 @@ void void_func2() { static int x = 2; --x; }
 int int_func1(int) { return 0; }
 int int_func2(int) { return 1; }
 
-BOOST_AUTO_TEST_CASE(function_pointer_tests)
+void function_pointer_tests()
 {
     compile_time_tests((void(**)()) 0);
     compile_time_tests((int(**)(int)) 0);
@@ -34,24 +33,31 @@ BOOST_AUTO_TEST_CASE(function_pointer_tests)
     HASH_NAMESPACE::hash<void(*)()> hasher_void;
     HASH_NAMESPACE::hash<int(*)(int)> hasher_int;
 
-    BOOST_CHECK(&void_func1 != &void_func2);
-    BOOST_CHECK(&int_func1 != &int_func2);
+    BOOST_TEST(&void_func1 != &void_func2);
+    BOOST_TEST(&int_func1 != &int_func2);
 
-    BOOST_CHECK(hasher_void(0) == hasher_void(0));
-    BOOST_CHECK(hasher_void(&void_func1) == hasher_void(&void_func1));
-    BOOST_CHECK(hasher_void(&void_func1) != hasher_void(&void_func2));
-    BOOST_CHECK(hasher_void(&void_func1) != hasher_void(0));
-    BOOST_CHECK(hasher_int(0) == hasher_int(0));
-    BOOST_CHECK(hasher_int(&int_func1) == hasher_int(&int_func1));
-    BOOST_CHECK(hasher_int(&int_func1) != hasher_int(&int_func2));
-    BOOST_CHECK(hasher_int(&int_func1) != hasher_int(0));
+    BOOST_TEST(hasher_void(0) == hasher_void(0));
+    BOOST_TEST(hasher_void(&void_func1) == hasher_void(&void_func1));
+    BOOST_TEST(hasher_void(&void_func1) != hasher_void(&void_func2));
+    BOOST_TEST(hasher_void(&void_func1) != hasher_void(0));
+    BOOST_TEST(hasher_int(0) == hasher_int(0));
+    BOOST_TEST(hasher_int(&int_func1) == hasher_int(&int_func1));
+    BOOST_TEST(hasher_int(&int_func1) != hasher_int(&int_func2));
+    BOOST_TEST(hasher_int(&int_func1) != hasher_int(0));
 #if defined(TEST_EXTENSIONS)
-    BOOST_CHECK(hasher_void(&void_func1)
+    BOOST_TEST(hasher_void(&void_func1)
             == HASH_NAMESPACE::hash_value(&void_func1));
-    BOOST_CHECK(hasher_int(&int_func1)
+    BOOST_TEST(hasher_int(&int_func1)
             == HASH_NAMESPACE::hash_value(&int_func1));
 
     // This isn't specified in Peter's proposal:
-    BOOST_CHECK(hasher_void(0) == 0);
+    BOOST_TEST(hasher_void(0) == 0);
 #endif
 }
+
+int main()
+{
+    function_pointer_tests();
+
+    return boost::report_errors();
+}
diff --git a/test/hash_fwd_test_1.cpp b/test/hash_fwd_test_1.cpp
index 94a90cc..55f72a1 100644
--- a/test/hash_fwd_test_1.cpp
+++ b/test/hash_fwd_test_1.cpp
@@ -7,29 +7,28 @@
 
 #include "./hash_fwd_test.hpp"
 
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #if defined(TEST_EXTENSIONS) && !defined(TEST_STD_INCLUDES)
 
 #include <boost/functional/hash/hash.hpp>
 #include <string>
 
-BOOST_AUTO_TEST_CASE(fwd_test1)
+void fwd_test1()
 {
     test::test_type1<int> x(5);
     test::test_type1<std::string> y("Test");
 
-    BOOST_CHECK_EQUAL(
-            HASH_NAMESPACE::hash<int>()(5),
+    BOOST_TEST(
+            HASH_NAMESPACE::hash<int>()(5) ==
             HASH_NAMESPACE::hash<test::test_type1<int> >()(x));
 
-    BOOST_CHECK_EQUAL(
-            HASH_NAMESPACE::hash<std::string>()("Test"),
+    BOOST_TEST(
+            HASH_NAMESPACE::hash<std::string>()("Test") ==
             HASH_NAMESPACE::hash<test::test_type1<std::string> >()(y));
 }
 
-BOOST_AUTO_TEST_CASE(fwd_test2)
+void fwd_test2()
 {
     test::test_type2<int> x(5, 10);
     test::test_type2<std::string> y("Test1", "Test2");
@@ -42,13 +41,13 @@ BOOST_AUTO_TEST_CASE(fwd_test2)
     HASH_NAMESPACE::hash_combine(seed2, std::string("Test1"));
     HASH_NAMESPACE::hash_combine(seed2, std::string("Test2"));
 
-    BOOST_CHECK_EQUAL(seed1,
+    BOOST_TEST(seed1 ==
             HASH_NAMESPACE::hash<test::test_type2<int> >()(x));
-    BOOST_CHECK_EQUAL(seed2,
+    BOOST_TEST(seed2 ==
             HASH_NAMESPACE::hash<test::test_type2<std::string> >()(y));
 }
 
-BOOST_AUTO_TEST_CASE(fwd_test3)
+void fwd_test3()
 {
     std::vector<int> values1;
     values1.push_back(10);
@@ -72,10 +71,21 @@ BOOST_AUTO_TEST_CASE(fwd_test3)
     std::size_t seed2 = HASH_NAMESPACE::hash_range(values2.begin(), values2.end());
     HASH_NAMESPACE::hash_range(seed2, values2.begin(), values2.end());
 
-    BOOST_CHECK_EQUAL(seed1,
+    BOOST_TEST(seed1 ==
             HASH_NAMESPACE::hash<test::test_type3<int> >()(x));
-    BOOST_CHECK_EQUAL(seed2,
+    BOOST_TEST(seed2 ==
             HASH_NAMESPACE::hash<test::test_type3<std::string> >()(y));
 }
 
 #endif
+
+int main()
+{
+#ifdef TEST_EXTENSIONS
+    fwd_test1();
+    fwd_test2();
+    fwd_test3();
+#endif
+    return boost::report_errors();
+}
+
diff --git a/test/hash_fwd_test_2.cpp b/test/hash_fwd_test_2.cpp
index 1d714e5..da8e8c2 100644
--- a/test/hash_fwd_test_2.cpp
+++ b/test/hash_fwd_test_2.cpp
@@ -8,12 +8,11 @@
 
 #include "./hash_fwd_test.hpp"
 
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 template <class T> void unused(T const&) {}
 
-BOOST_AUTO_TEST_CASE(fwd_test)
+void fwd_test()
 {
     test::test_type1<int> x1(3);
     test::test_type1<std::string> y1("Black");
@@ -30,3 +29,11 @@ BOOST_AUTO_TEST_CASE(fwd_test)
     unused(x1); unused(x2); unused(x3);
     unused(y1); unused(y2); unused(y3);
 }
+
+
+int main()
+{
+    fwd_test();
+    return boost::report_errors();
+}
+
diff --git a/test/hash_global_namespace_test.cpp b/test/hash_global_namespace_test.cpp
index 1aa44fd..4b4a0c5 100644
--- a/test/hash_global_namespace_test.cpp
+++ b/test/hash_global_namespace_test.cpp
@@ -49,8 +49,7 @@ namespace boost
 #  endif
 #endif
 
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -58,16 +57,16 @@ namespace boost
 #include <string>
 #include <cctype>
 
-BOOST_AUTO_TEST_CASE(custom_tests)
+void custom_tests()
 {
     HASH_NAMESPACE::hash<custom> custom_hasher;
-    BOOST_CHECK(custom_hasher(10) == 100u);
+    BOOST_TEST(custom_hasher(10) == 100u);
     custom x(55);
-    BOOST_CHECK(custom_hasher(x) == 550u);
+    BOOST_TEST(custom_hasher(x) == 550u);
 
     {
         using namespace HASH_NAMESPACE;
-        BOOST_CHECK(custom_hasher(x) == hash_value(x));
+        BOOST_TEST(custom_hasher(x) == hash_value(x));
     }
 
     std::vector<custom> custom_vector;
@@ -85,9 +84,19 @@ BOOST_AUTO_TEST_CASE(custom_tests)
     HASH_NAMESPACE::hash_combine(seed2, 250u);
     HASH_NAMESPACE::hash_combine(seed2, 350u);
 
-    BOOST_CHECK(seed ==
+    BOOST_TEST(seed ==
             HASH_NAMESPACE::hash_range(custom_vector.begin(), custom_vector.end()));
-    BOOST_CHECK(seed == seed2);
+    BOOST_TEST(seed == seed2);
 }
 
 #endif // TEST_EXTENSIONS
+
+
+int main()
+{
+#ifdef TEST_EXTENSIONS
+    custom_tests();
+#endif
+    return boost::report_errors();
+}
+
diff --git a/test/hash_list_test.cpp b/test/hash_list_test.cpp
index 1e510f3..f8301df 100644
--- a/test/hash_list_test.cpp
+++ b/test/hash_list_test.cpp
@@ -14,8 +14,7 @@
 #  endif
 #endif
 
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -26,3 +25,12 @@ using std::list;
 #include "./hash_sequence_test.hpp"
 
 #endif // TEST_EXTENSIONS
+
+int main()
+{
+#ifdef TEST_EXTENSIONS
+    list_tests::list_hash_integer_tests();
+#endif
+
+    return boost::report_errors();
+}
diff --git a/test/hash_map_test.cpp b/test/hash_map_test.cpp
index be29a89..cf049cc 100644
--- a/test/hash_map_test.cpp
+++ b/test/hash_map_test.cpp
@@ -14,8 +14,7 @@
 #  endif
 #endif
 
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #include <map>
 
@@ -30,3 +29,13 @@ using std::multimap;
 #include "./hash_map_test.hpp"
 
 #endif // TEST_EXTENSTIONS
+
+int main()
+{
+#ifdef TEST_EXTENSIONS
+    map_tests::map_hash_integer_tests();
+    multimap_tests::multimap_hash_integer_tests();
+#endif
+
+    return boost::report_errors();
+}
diff --git a/test/hash_map_test.hpp b/test/hash_map_test.hpp
index 59fc221..f361fcf 100644
--- a/test/hash_map_test.hpp
+++ b/test/hash_map_test.hpp
@@ -34,17 +34,17 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
         HASH_NAMESPACE::hash<T> hasher;
 
         for(int i2 = 0; i2 < number_of_containers; ++i2) {
-            BOOST_CHECK(hasher(containers[i2]) == hasher(containers[i2]));
+            BOOST_TEST(hasher(containers[i2]) == hasher(containers[i2]));
 
-            BOOST_CHECK(hasher(containers[i2]) ==
+            BOOST_TEST(hasher(containers[i2]) ==
                     HASH_NAMESPACE::hash_value(containers[i2]));
 
-            BOOST_CHECK(hasher(containers[i2])
+            BOOST_TEST(hasher(containers[i2])
                     == HASH_NAMESPACE::hash_range(
                         containers[i2].begin(), containers[i2].end()));
 
             for(int j2 = i2 + 1; j2 < number_of_containers; ++j2) {
-                BOOST_CHECK(
+                BOOST_TEST(
                         (containers[i2] == containers[j2]) ==
                         (hasher(containers[i2]) == hasher(containers[j2]))
                         );
@@ -52,7 +52,7 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
         }
     }
 
-    BOOST_AUTO_TEST_CASE(BOOST_PP_CAT(CONTAINER_TYPE, _hash_integer_tests))
+    void BOOST_PP_CAT(CONTAINER_TYPE, _hash_integer_tests())
     {
         integer_tests((CONTAINER_TYPE<char, unsigned char>*) 0);
         integer_tests((CONTAINER_TYPE<int, float>*) 0);
diff --git a/test/hash_number_test.cpp b/test/hash_number_test.cpp
index 4266adf..4859a9e 100644
--- a/test/hash_number_test.cpp
+++ b/test/hash_number_test.cpp
@@ -11,8 +11,8 @@
 #  include <boost/functional/hash/hash.hpp>
 #endif
 
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
+#include <iostream>
+#include <boost/detail/lightweight_test.hpp>
 
 #include <boost/preprocessor/cat.hpp>
 #include <boost/limits.hpp>
@@ -32,26 +32,26 @@ void numeric_test(T*)
     HASH_NAMESPACE::hash<T> x2;
 
     T v1 = -5;
-    BOOST_CHECK(x1(v1) == x2(v1));
-    BOOST_CHECK(x1(T(-5)) == x2(T(-5)));
-    BOOST_CHECK(x1(T(0)) == x2(T(0)));
-    BOOST_CHECK(x1(T(10)) == x2(T(10)));
-    BOOST_CHECK(x1(T(25)) == x2(T(25)));
-    BOOST_CHECK(x1(T(5) - T(5)) == x2(T(0)));
-    BOOST_CHECK(x1(T(6) + T(4)) == x2(T(10)));
+    BOOST_TEST(x1(v1) == x2(v1));
+    BOOST_TEST(x1(T(-5)) == x2(T(-5)));
+    BOOST_TEST(x1(T(0)) == x2(T(0)));
+    BOOST_TEST(x1(T(10)) == x2(T(10)));
+    BOOST_TEST(x1(T(25)) == x2(T(25)));
+    BOOST_TEST(x1(T(5) - T(5)) == x2(T(0)));
+    BOOST_TEST(x1(T(6) + T(4)) == x2(T(10)));
 
 #if defined(TEST_EXTENSIONS)
-    BOOST_CHECK(x1(T(-5)) == HASH_NAMESPACE::hash_value(T(-5)));
-    BOOST_CHECK(x1(T(0)) == HASH_NAMESPACE::hash_value(T(0)));
-    BOOST_CHECK(x1(T(10)) == HASH_NAMESPACE::hash_value(T(10)));
-    BOOST_CHECK(x1(T(25)) == HASH_NAMESPACE::hash_value(T(25)));
+    BOOST_TEST(x1(T(-5)) == HASH_NAMESPACE::hash_value(T(-5)));
+    BOOST_TEST(x1(T(0)) == HASH_NAMESPACE::hash_value(T(0)));
+    BOOST_TEST(x1(T(10)) == HASH_NAMESPACE::hash_value(T(10)));
+    BOOST_TEST(x1(T(25)) == HASH_NAMESPACE::hash_value(T(25)));
 
     if (limits::is_integer)
     {
-        BOOST_CHECK(HASH_NAMESPACE::hash_value(T(-5)) == (std::size_t)T(-5));
-        BOOST_CHECK(HASH_NAMESPACE::hash_value(T(0)) == (std::size_t)T(0u));
-        BOOST_CHECK(HASH_NAMESPACE::hash_value(T(10)) == (std::size_t)T(10u));
-        BOOST_CHECK(HASH_NAMESPACE::hash_value(T(25)) == (std::size_t)T(25u));
+        BOOST_TEST(HASH_NAMESPACE::hash_value(T(-5)) == (std::size_t)T(-5));
+        BOOST_TEST(HASH_NAMESPACE::hash_value(T(0)) == (std::size_t)T(0u));
+        BOOST_TEST(HASH_NAMESPACE::hash_value(T(10)) == (std::size_t)T(10u));
+        BOOST_TEST(HASH_NAMESPACE::hash_value(T(25)) == (std::size_t)T(25u));
     }
 #endif
 }
@@ -69,18 +69,18 @@ void limits_test(T*)
         T min_value = (limits::min)();
         T max_value = (limits::max)();
 
-        BOOST_CHECK(x1(min_value) == x2((limits::min)()));
-        BOOST_CHECK(x1(max_value) == x2((limits::max)()));
+        BOOST_TEST(x1(min_value) == x2((limits::min)()));
+        BOOST_TEST(x1(max_value) == x2((limits::max)()));
 
 #if defined(TEST_EXTENSIONS)
-        BOOST_CHECK(x1(min_value) == HASH_NAMESPACE::hash_value(min_value));
-        BOOST_CHECK(x1(max_value) == HASH_NAMESPACE::hash_value(max_value));
+        BOOST_TEST(x1(min_value) == HASH_NAMESPACE::hash_value(min_value));
+        BOOST_TEST(x1(max_value) == HASH_NAMESPACE::hash_value(max_value));
 
         if (limits::is_integer)
         {
-            BOOST_CHECK(HASH_NAMESPACE::hash_value(min_value)
+            BOOST_TEST(HASH_NAMESPACE::hash_value(min_value)
                     == std::size_t(min_value));
-            BOOST_CHECK(HASH_NAMESPACE::hash_value(max_value)
+            BOOST_TEST(HASH_NAMESPACE::hash_value(max_value)
                     == std::size_t(max_value));
         }
 #endif
@@ -98,34 +98,41 @@ void poor_quality_tests(T*)
     // A hash function can legally fail these tests, but it'll not be a good
     // sign.
     if(T(1) != T(-1))
-        BOOST_CHECK(x1(T(1)) !=  x2(T(-1)));
+        BOOST_TEST(x1(T(1)) !=  x2(T(-1)));
     if(T(1) != T(2))
-        BOOST_CHECK(x1(T(1)) !=  x2(T(2)));
+        BOOST_TEST(x1(T(1)) !=  x2(T(2)));
     if((limits::max)() != (limits::max)() - 1)
-        BOOST_CHECK(x1((limits::max)()) != x2((limits::max)() - 1));
+        BOOST_TEST(x1((limits::max)()) != x2((limits::max)() - 1));
 }
 
+
 #define NUMERIC_TEST(type, name) \
-    BOOST_AUTO_TEST_CASE(BOOST_PP_CAT(test_, name)) { \
-        numeric_test((type*) 0); \
-        limits_test((type*) 0); \
-        poor_quality_tests((type*) 0); \
-    }
+    std::cerr<<"Testing: " BOOST_STRINGIZE(name) "\n"; \
+    numeric_test((type*) 0); \
+    limits_test((type*) 0); \
+    poor_quality_tests((type*) 0);
 
-NUMERIC_TEST(bool, bool)
-NUMERIC_TEST(char, char)
-NUMERIC_TEST(signed char, schar)
-NUMERIC_TEST(unsigned char, uchar)
+int main()
+{
+    NUMERIC_TEST(bool, bool)
+    NUMERIC_TEST(char, char)
+    NUMERIC_TEST(signed char, schar)
+    NUMERIC_TEST(unsigned char, uchar)
 #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-NUMERIC_TEST(wchar_t, wchar)
+    NUMERIC_TEST(wchar_t, wchar)
 #endif
-NUMERIC_TEST(short, short)
-NUMERIC_TEST(unsigned short, ushort)
-NUMERIC_TEST(int, int)
-NUMERIC_TEST(unsigned int, uint)
-NUMERIC_TEST(long, hash_long)
-NUMERIC_TEST(unsigned long, ulong)
+    NUMERIC_TEST(short, short)
+    NUMERIC_TEST(unsigned short, ushort)
+    NUMERIC_TEST(int, int)
+    NUMERIC_TEST(unsigned int, uint)
+    NUMERIC_TEST(long, hash_long)
+    NUMERIC_TEST(unsigned long, ulong)
+
+    NUMERIC_TEST(float, float)
+    NUMERIC_TEST(double, double)
+    NUMERIC_TEST(long double, ldouble)
+
+    return boost::report_errors();
+}
+
 
-NUMERIC_TEST(float, float)
-NUMERIC_TEST(double, double)
-NUMERIC_TEST(long double, ldouble)
diff --git a/test/hash_pointer_test.cpp b/test/hash_pointer_test.cpp
index 9b4ae3c..66053c6 100644
--- a/test/hash_pointer_test.cpp
+++ b/test/hash_pointer_test.cpp
@@ -12,8 +12,7 @@
 #  include <boost/functional/hash/hash.hpp>
 #endif
 
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #include <boost/limits.hpp>
 #include <boost/mpl/assert.hpp>
@@ -21,7 +20,7 @@
 
 #include "./compile_time.hpp"
 
-BOOST_AUTO_TEST_CASE(pointer_tests)
+void pointer_tests()
 {
     compile_time_tests((int**) 0);
     compile_time_tests((void**) 0);
@@ -32,14 +31,20 @@ BOOST_AUTO_TEST_CASE(pointer_tests)
     int int1;
     int int2;
 
-    BOOST_CHECK(x1(0) == x2(0));
-    BOOST_CHECK(x1(&int1) == x2(&int1));
-    BOOST_CHECK(x1(&int2) == x2(&int2));
+    BOOST_TEST(x1(0) == x2(0));
+    BOOST_TEST(x1(&int1) == x2(&int1));
+    BOOST_TEST(x1(&int2) == x2(&int2));
 #if defined(TEST_EXTENSIONS)
-    BOOST_CHECK(x1(&int1) == HASH_NAMESPACE::hash_value(&int1));
-    BOOST_CHECK(x1(&int2) == HASH_NAMESPACE::hash_value(&int2));
+    BOOST_TEST(x1(&int1) == HASH_NAMESPACE::hash_value(&int1));
+    BOOST_TEST(x1(&int2) == HASH_NAMESPACE::hash_value(&int2));
 
     // This isn't specified in Peter's proposal:
-    BOOST_CHECK(x1(0) == 0);
+    BOOST_TEST(x1(0) == 0);
 #endif
 }
+
+int main()
+{
+    pointer_tests();
+    return boost::report_errors();
+}
diff --git a/test/hash_range_test.cpp b/test/hash_range_test.cpp
index b7853cd..9e2f1bb 100644
--- a/test/hash_range_test.cpp
+++ b/test/hash_range_test.cpp
@@ -13,8 +13,7 @@
 #  endif
 #endif
 
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -22,7 +21,7 @@
 #include <boost/mpl/assert.hpp>
 #include <boost/type_traits/is_base_and_derived.hpp>
 
-BOOST_AUTO_TEST_CASE(hash_range_tests)
+void hash_range_tests()
 {
     std::vector<int> empty, values1, values2, values3, values4, values5;
     values1.push_back(0);
@@ -41,37 +40,45 @@ BOOST_AUTO_TEST_CASE(hash_range_tests)
     std::vector<int> x;
 
     std::size_t x_seed = 0;
-    BOOST_CHECK(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
+    BOOST_TEST(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
 
-    BOOST_CHECK(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
+    BOOST_TEST(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
         == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
-    BOOST_CHECK(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
+    BOOST_TEST(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
         != HASH_NAMESPACE::hash_range(values1.begin(), values1.end()));
 
     x.push_back(10);
     HASH_NAMESPACE::hash_combine(x_seed, 10);
-    BOOST_CHECK(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
+    BOOST_TEST(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
 
-    BOOST_CHECK(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
+    BOOST_TEST(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
         != HASH_NAMESPACE::hash_range(x.begin(), x.end()));
-    BOOST_CHECK(HASH_NAMESPACE::hash_range(values2.begin(), values2.end())
+    BOOST_TEST(HASH_NAMESPACE::hash_range(values2.begin(), values2.end())
         == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
 
     x.push_back(20);
     HASH_NAMESPACE::hash_combine(x_seed, 20);
-    BOOST_CHECK(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
+    BOOST_TEST(x_seed == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
 
-    BOOST_CHECK(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
+    BOOST_TEST(HASH_NAMESPACE::hash_range(empty.begin(), empty.end())
         != HASH_NAMESPACE::hash_range(x.begin(), x.end()));
-    BOOST_CHECK(HASH_NAMESPACE::hash_range(values2.begin(), values2.end())
+    BOOST_TEST(HASH_NAMESPACE::hash_range(values2.begin(), values2.end())
         != HASH_NAMESPACE::hash_range(x.begin(), x.end()));
-    BOOST_CHECK(HASH_NAMESPACE::hash_range(values3.begin(), values3.end())
+    BOOST_TEST(HASH_NAMESPACE::hash_range(values3.begin(), values3.end())
         == HASH_NAMESPACE::hash_range(x.begin(), x.end()));
 
     std::size_t seed = HASH_NAMESPACE::hash_range(values3.begin(), values3.end());
     HASH_NAMESPACE::hash_range(seed, values4.begin(), values4.end());
     HASH_NAMESPACE::hash_range(seed, x.begin(), x.end());
-    BOOST_CHECK(seed == HASH_NAMESPACE::hash_range(values5.begin(), values5.end()));
+    BOOST_TEST(seed == HASH_NAMESPACE::hash_range(values5.begin(), values5.end()));
 }
 
 #endif
+
+int main()
+{
+    hash_range_tests();
+
+    return boost::report_errors();
+}
+
diff --git a/test/hash_sequence_test.hpp b/test/hash_sequence_test.hpp
index d957091..1346394 100644
--- a/test/hash_sequence_test.hpp
+++ b/test/hash_sequence_test.hpp
@@ -37,17 +37,17 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
         HASH_NAMESPACE::hash<T> hasher;
 
         for(int i2 = 0; i2 < number_of_containers; ++i2) {
-            BOOST_CHECK(hasher(containers[i2]) == hasher(containers[i2]));
+            BOOST_TEST(hasher(containers[i2]) == hasher(containers[i2]));
 
-            BOOST_CHECK(hasher(containers[i2]) ==
+            BOOST_TEST(hasher(containers[i2]) ==
                     HASH_NAMESPACE::hash_value(containers[i2]));
 
-            BOOST_CHECK(hasher(containers[i2])
+            BOOST_TEST(hasher(containers[i2])
                     == HASH_NAMESPACE::hash_range(
                         containers[i2].begin(), containers[i2].end()));
 
             for(int j2 = i2 + 1; j2 < number_of_containers; ++j2) {
-                BOOST_CHECK(
+                BOOST_TEST(
                         (containers[i2] == containers[j2]) ==
                         (hasher(containers[i2]) == hasher(containers[j2]))
                         );
@@ -55,7 +55,7 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
         }
     }
 
-    BOOST_AUTO_TEST_CASE(BOOST_PP_CAT(CONTAINER_TYPE, _hash_integer_tests))
+    void BOOST_PP_CAT(CONTAINER_TYPE, _hash_integer_tests())
     {
         integer_tests((CONTAINER_TYPE<char>*) 0);
         integer_tests((CONTAINER_TYPE<int>*) 0);
diff --git a/test/hash_set_test.cpp b/test/hash_set_test.cpp
index 88505c6..3d4f5e7 100644
--- a/test/hash_set_test.cpp
+++ b/test/hash_set_test.cpp
@@ -14,8 +14,7 @@
 #  endif
 #endif
 
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -30,3 +29,13 @@ using std::multiset;
 #include "./hash_set_test.hpp"
 
 #endif
+
+int main()
+{
+#ifdef TEST_EXTENSIONS
+    set_tests::set_hash_integer_tests();
+    multiset_tests::multiset_hash_integer_tests();
+#endif
+
+    return boost::report_errors();
+}
diff --git a/test/hash_set_test.hpp b/test/hash_set_test.hpp
index b43f4aa..5074e55 100644
--- a/test/hash_set_test.hpp
+++ b/test/hash_set_test.hpp
@@ -35,17 +35,17 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
         HASH_NAMESPACE::hash<T> hasher;
 
         for(int i2 = 0; i2 < number_of_containers; ++i2) {
-            BOOST_CHECK(hasher(containers[i2]) == hasher(containers[i2]));
+            BOOST_TEST(hasher(containers[i2]) == hasher(containers[i2]));
 
-            BOOST_CHECK(hasher(containers[i2]) ==
+            BOOST_TEST(hasher(containers[i2]) ==
                     HASH_NAMESPACE::hash_value(containers[i2]));
 
-            BOOST_CHECK(hasher(containers[i2])
+            BOOST_TEST(hasher(containers[i2])
                     == HASH_NAMESPACE::hash_range(
                         containers[i2].begin(), containers[i2].end()));
 
             for(int j2 = i2 + 1; j2 < number_of_containers; ++j2) {
-                BOOST_CHECK(
+                BOOST_TEST(
                         (containers[i2] == containers[j2]) ==
                         (hasher(containers[i2]) == hasher(containers[j2]))
                         );
@@ -53,7 +53,7 @@ namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
         }
     }
 
-    BOOST_AUTO_TEST_CASE(BOOST_PP_CAT(CONTAINER_TYPE, _hash_integer_tests))
+    void BOOST_PP_CAT(CONTAINER_TYPE, _hash_integer_tests())
     {
         integer_tests((CONTAINER_TYPE<char>*) 0);
         integer_tests((CONTAINER_TYPE<int>*) 0);
diff --git a/test/hash_string_test.cpp b/test/hash_string_test.cpp
index 93df72d..9a6d0a3 100644
--- a/test/hash_string_test.cpp
+++ b/test/hash_string_test.cpp
@@ -11,8 +11,7 @@
 #  include <boost/functional/hash/hash.hpp>
 #endif
 
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #include <boost/limits.hpp>
 #include <boost/mpl/assert.hpp>
@@ -20,50 +19,59 @@
 
 #include "./compile_time.hpp"
 
-BOOST_AUTO_TEST_CASE(string_tests)
+void string_tests()
 {
     compile_time_tests((std::string*) 0);
 
     HASH_NAMESPACE::hash<std::string> x1;
     HASH_NAMESPACE::hash<std::string> x2;
 
-    BOOST_CHECK(x1("Hello") == x2(std::string("Hel") + "lo"));
-    BOOST_CHECK(x1("") == x2(std::string()));
+    BOOST_TEST(x1("Hello") == x2(std::string("Hel") + "lo"));
+    BOOST_TEST(x1("") == x2(std::string()));
 
 #if defined(TEST_EXTENSIONS)
     std::string value1;
     std::string value2("Hello");
 
-    BOOST_CHECK(x1(value1) == HASH_NAMESPACE::hash_value(value1));
-    BOOST_CHECK(x1(value2) == HASH_NAMESPACE::hash_value(value2));
-    BOOST_CHECK(HASH_NAMESPACE::hash_value(value1) ==
+    BOOST_TEST(x1(value1) == HASH_NAMESPACE::hash_value(value1));
+    BOOST_TEST(x1(value2) == HASH_NAMESPACE::hash_value(value2));
+    BOOST_TEST(HASH_NAMESPACE::hash_value(value1) ==
             HASH_NAMESPACE::hash_range(value1.begin(), value1.end()));
-    BOOST_CHECK(HASH_NAMESPACE::hash_value(value2) ==
+    BOOST_TEST(HASH_NAMESPACE::hash_value(value2) ==
             HASH_NAMESPACE::hash_range(value2.begin(), value2.end()));
 #endif
 }
 
 #if !defined(BOOST_NO_STD_WSTRING)
-BOOST_AUTO_TEST_CASE(wstring_tests)
+void wstring_tests()
 {
     compile_time_tests((std::wstring*) 0);
 
     HASH_NAMESPACE::hash<std::wstring> x1;
     HASH_NAMESPACE::hash<std::wstring> x2;
 
-    BOOST_CHECK(x1(L"Hello") == x2(std::wstring(L"Hel") + L"lo"));
-    BOOST_CHECK(x1(L"") == x2(std::wstring()));
+    BOOST_TEST(x1(L"Hello") == x2(std::wstring(L"Hel") + L"lo"));
+    BOOST_TEST(x1(L"") == x2(std::wstring()));
 
 #if defined(TEST_EXTENSIONS)
     std::wstring value1;
     std::wstring value2(L"Hello");
 
-    BOOST_CHECK(x1(value1) == HASH_NAMESPACE::hash_value(value1));
-    BOOST_CHECK(x1(value2) == HASH_NAMESPACE::hash_value(value2));
-    BOOST_CHECK(HASH_NAMESPACE::hash_value(value1) ==
+    BOOST_TEST(x1(value1) == HASH_NAMESPACE::hash_value(value1));
+    BOOST_TEST(x1(value2) == HASH_NAMESPACE::hash_value(value2));
+    BOOST_TEST(HASH_NAMESPACE::hash_value(value1) ==
             HASH_NAMESPACE::hash_range(value1.begin(), value1.end()));
-    BOOST_CHECK(HASH_NAMESPACE::hash_value(value2) ==
+    BOOST_TEST(HASH_NAMESPACE::hash_value(value2) ==
             HASH_NAMESPACE::hash_range(value2.begin(), value2.end()));
 #endif
 }
 #endif
+
+int main()
+{
+    string_tests();
+#if !defined(BOOST_NO_STD_WSTRING)
+    wstring_tests();
+#endif
+    return boost::report_errors();
+}
diff --git a/test/hash_value_array_test.cpp b/test/hash_value_array_test.cpp
index c76ba8b..5b646b8 100644
--- a/test/hash_value_array_test.cpp
+++ b/test/hash_value_array_test.cpp
@@ -17,12 +17,11 @@
 #  endif
 #endif
 
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef TEST_EXTENSIONS
 
-BOOST_AUTO_TEST_CASE(array_int_test)
+void array_int_test()
 {
     const int array1[25] = {
         26, -43, 32, 65, 45,
@@ -39,17 +38,28 @@ BOOST_AUTO_TEST_CASE(array_int_test)
     int array3[2] = {2, 3};
     HASH_NAMESPACE::hash<int[2]> hasher3;
 
-    BOOST_CHECK(hasher1(array1) == HASH_NAMESPACE::hash_value(array1));
-    BOOST_CHECK(hasher2(array2) == HASH_NAMESPACE::hash_value(array2));
-    BOOST_CHECK(hasher3(array3) == HASH_NAMESPACE::hash_value(array3));
+    BOOST_TEST(hasher1(array1) == HASH_NAMESPACE::hash_value(array1));
+    BOOST_TEST(hasher2(array2) == HASH_NAMESPACE::hash_value(array2));
+    BOOST_TEST(hasher3(array3) == HASH_NAMESPACE::hash_value(array3));
 }
 
-BOOST_AUTO_TEST_CASE(two_dimensional_array_test)
+void two_dimensional_array_test()
 {
     int array[3][2] = {{-5, 6}, {7, -3}, {26, 1}};
     HASH_NAMESPACE::hash<int[3][2]> hasher;
 
-    BOOST_CHECK(hasher(array) == HASH_NAMESPACE::hash_value(array));
+    BOOST_TEST(hasher(array) == HASH_NAMESPACE::hash_value(array));
 }
 
 #endif
+
+int main()
+{
+#ifdef TEST_EXTENSIONS
+    array_int_test();
+    two_dimensional_array_test();
+#endif
+
+    return boost::report_errors();
+}
+
diff --git a/test/hash_vector_test.cpp b/test/hash_vector_test.cpp
index 608dff0..27f230e 100644
--- a/test/hash_vector_test.cpp
+++ b/test/hash_vector_test.cpp
@@ -14,8 +14,7 @@
 #  endif
 #endif
 
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef TEST_EXTENSIONS
 
@@ -26,3 +25,12 @@ using std::vector;
 #include "./hash_sequence_test.hpp"
 
 #endif // TEST_EXTENSIONS
+
+int main()
+{
+#ifdef TEST_EXTENSIONS
+    vector_tests::vector_hash_integer_tests();
+#endif
+
+    return boost::report_errors();
+}