diff --git a/test/counting_iterator_test.cpp b/test/counting_iterator_test.cpp
index fd6e701..7770af5 100644
--- a/test/counting_iterator_test.cpp
+++ b/test/counting_iterator_test.cpp
@@ -45,7 +45,7 @@
 #endif 
 #include <vector>
 #include <list>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 #ifndef BOOST_NO_SLIST
 # ifdef BOOST_SLIST_HEADER
 #   include BOOST_SLIST_HEADER
@@ -59,7 +59,7 @@
 template <class T>
 struct signed_assert_nonnegative
 {
-    static void test(T x) { assert(x >= 0); }
+    static void test(T x) { BOOST_TEST(x >= 0); }
 };
 
 template <class T>
@@ -96,7 +96,7 @@ void category_test(
     difference_type offset = (unsigned)rand() % distance;
     
 #ifdef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-    assert(offset >= 0);
+    BOOST_TEST(offset >= 0);
 #else 
     assert_nonnegative<difference_type>::test(offset);
 #endif
@@ -105,17 +105,17 @@ void category_test(
     std::advance(internal, offset);
 
     // Try some binary searches on the range to show that it's ordered
-    assert(std::binary_search(start, finish, *internal));
+    BOOST_TEST(std::binary_search(start, finish, *internal));
 
     // #including tuple crashed borland, so I had to give up on tie().
     std::pair<CountingIterator,CountingIterator> xy(
         std::equal_range(start, finish, *internal));
     CountingIterator x = xy.first, y = xy.second;
     
-    assert(boost::detail::distance(x, y) == 1);
+    BOOST_TEST(boost::detail::distance(x, y) == 1);
 
     // Show that values outside the range can't be found
-    assert(!std::binary_search(start, boost::prior(finish), *finish));
+    BOOST_TEST(!std::binary_search(start, boost::prior(finish), *finish));
 
     // Do the generic random_access_iterator_test
     typedef typename CountingIterator::value_type value_type;
@@ -163,7 +163,7 @@ void test_aux(CountingIterator start, CountingIterator finish, Value v1)
              ; p != finish && boost::next(p) != finish
              ; ++p)
     {
-        assert(boost::next(*p) == *boost::next(p));
+        BOOST_TEST(boost::next(*p) == *boost::next(p));
     }
 
     // prove that a reference can be formed to these values
@@ -296,5 +296,5 @@ int main()
     int array[2000];
     test(boost::make_counting_iterator(array), boost::make_counting_iterator(array+2000-1));
 
-    return 0;
+    return boost::report_errors();
 }
diff --git a/test/indirect_iterator_test.cpp b/test/indirect_iterator_test.cpp
index e79cf12..8cea482 100644
--- a/test/indirect_iterator_test.cpp
+++ b/test/indirect_iterator_test.cpp
@@ -28,6 +28,9 @@
 #include <boost/mpl/has_xxx.hpp>
 
 #include <boost/type_traits/broken_compiler_spec.hpp>
+
+#include <boost/detail/lightweight_test.hpp>
+
 #include <vector>
 #include <stdlib.h>
 #include <set>
@@ -85,32 +88,32 @@ void more_indirect_iterator_tests()
 
     indirect_ra_container::iterator db(ptr_ra_container.begin());
     indirect_ra_container::iterator de(ptr_ra_container.end());
-    assert(static_cast<std::size_t>(de - db) == store.size());
-    assert(db + store.size() == de);
+    BOOST_TEST(static_cast<std::size_t>(de - db) == store.size());
+    BOOST_TEST(db + store.size() == de);
     indirect_ra_container::const_iterator dci = db;
     
-    assert(dci == db);
+    BOOST_TEST(dci == db);
     
 #ifndef NO_MUTABLE_CONST_RA_ITERATOR_INTEROPERABILITY
-    assert(db == dci);
+    BOOST_TEST(db == dci);
 #endif
     
-    assert(dci != de);
-    assert(dci < de);
-    assert(dci <= de);
+    BOOST_TEST(dci != de);
+    BOOST_TEST(dci < de);
+    BOOST_TEST(dci <= de);
     
 #ifndef NO_MUTABLE_CONST_RA_ITERATOR_INTEROPERABILITY
-    assert(de >= dci);
-    assert(de > dci);
+    BOOST_TEST(de >= dci);
+    BOOST_TEST(de > dci);
 #endif
     
     dci = de;
-    assert(dci == de);
+    BOOST_TEST(dci == de);
 
     boost::random_access_iterator_test(db + 1, store.size() - 1, boost::next(store.begin()));
     
     *db = 999;
-    assert(store.front() == 999);
+    BOOST_TEST(store.front() == 999);
 
     // Borland C++ is getting very confused about the typedefs here
     typedef boost::indirect_iterator<iterator_set::iterator> indirect_set_iterator;
@@ -122,22 +125,22 @@ void more_indirect_iterator_tests()
     indirect_set_iterator sb(iter_set.begin());
     indirect_set_iterator se(iter_set.end());
     const_indirect_set_iterator sci(iter_set.begin());
-    assert(sci == sb);
+    BOOST_TEST(sci == sb);
     
 # ifndef NO_MUTABLE_CONST_STD_SET_ITERATOR_INTEROPERABILITY
-    assert(se != sci);
+    BOOST_TEST(se != sci);
 # endif
     
-    assert(sci != se);
+    BOOST_TEST(sci != se);
     sci = se;
-    assert(sci == se);
+    BOOST_TEST(sci == se);
     
     *boost::prior(se) = 888;
-    assert(store.back() == 888);
-    assert(std::equal(sb, se, store.begin()));
+    BOOST_TEST(store.back() == 888);
+    BOOST_TEST(std::equal(sb, se, store.begin()));
 
     boost::bidirectional_iterator_test(boost::next(sb), store[1], store[2]);
-    assert(std::equal(db, de, store.begin()));
+    BOOST_TEST(std::equal(db, de, store.begin()));
 }
 
 // element_type detector; defaults to true so the test passes when
@@ -214,6 +217,5 @@ main()
 
       more_indirect_iterator_tests();
   }
-  std::cout << "test successful " << std::endl;
-  return 0;
+  return boost::report_errors();
 }
diff --git a/test/interoperable.cpp b/test/interoperable.cpp
index c228b9c..ba4196a 100755
--- a/test/interoperable.cpp
+++ b/test/interoperable.cpp
@@ -4,6 +4,7 @@
 
 #include <boost/iterator/iterator_adaptor.hpp>
 #include <boost/pending/iterator_tests.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <cassert>
 
 struct mutable_it : boost::iterator_adaptor<mutable_it,int*>
@@ -39,21 +40,21 @@ int main()
     
     mutable_it i(data);
     constant_it j(data + 1);
-    assert(i < j);
-    assert(j > i);
-    assert(i <= j);
-    assert(j >= i);
-    assert(j - i == 1);
-    assert(i - j == -1);
+    BOOST_TEST(i < j);
+    BOOST_TEST(j > i);
+    BOOST_TEST(i <= j);
+    BOOST_TEST(j >= i);
+    BOOST_TEST(j - i == 1);
+    BOOST_TEST(i - j == -1);
     
     constant_it k = i;
 
-    assert(!(i < k));
-    assert(!(k > i));
-    assert(i <= k);
-    assert(k >= i);
-    assert(k - i == 0);
-    assert(i - k == 0);
+    BOOST_TEST(!(i < k));
+    BOOST_TEST(!(k > i));
+    BOOST_TEST(i <= k);
+    BOOST_TEST(k >= i);
+    BOOST_TEST(k - i == 0);
+    BOOST_TEST(i - k == 0);
     
-    return 0;
+    return boost::report_errors();
 }
diff --git a/test/iterator_adaptor_test.cpp b/test/iterator_adaptor_test.cpp
index dddac26..e339fe1 100644
--- a/test/iterator_adaptor_test.cpp
+++ b/test/iterator_adaptor_test.cpp
@@ -21,6 +21,8 @@
 
 # include <boost/type_traits/broken_compiler_spec.hpp>
 
+# include <boost/detail/lightweight_test.hpp>
+
 #include <stdlib.h>
 #include <vector>
 #include <deque>
@@ -303,7 +305,7 @@ main()
     adaptor_type i(forward_iter);
     int zero = 0;
     if (zero) // don't do this, just make sure it compiles
-      assert((*i).m_x == i->foo());      
+      BOOST_TEST((*i).m_x == i->foo());      
   }
   
   // check operator-> with an input iterator
@@ -313,7 +315,7 @@ main()
     adaptor_type i(input_iter);
     int zero = 0;
     if (zero) // don't do this, just make sure it compiles
-      assert((*i).m_x == i->foo());      
+      BOOST_TEST((*i).m_x == i->foo());      
   }
 
   // check that base_type is correct
@@ -331,5 +333,5 @@ main()
 
   std::cout << "test successful " << std::endl;
   (void)test;
-  return 0;
+  return boost::report_errors();
 }
diff --git a/test/iterator_traits_test.cpp b/test/iterator_traits_test.cpp
index eed70ff..6a72e8f 100644
--- a/test/iterator_traits_test.cpp
+++ b/test/iterator_traits_test.cpp
@@ -27,7 +27,7 @@
 #include <iterator>
 #include <vector>
 #include <list>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 #include <iostream>
 
 // A UDT for which we can specialize std::iterator_traits<element*> on
@@ -204,15 +204,15 @@ int main()
     for (int length = 3; length < 100; length += length / 3)
     {
         std::list<int> l(length);
-        assert(boost::detail::distance(l.begin(), l.end()) == length);
+        BOOST_TEST(boost::detail::distance(l.begin(), l.end()) == length);
         
         std::vector<int> v(length);
-        assert(boost::detail::distance(v.begin(), v.end()) == length);
+        BOOST_TEST(boost::detail::distance(v.begin(), v.end()) == length);
 
-        assert(boost::detail::distance(&ints[0], ints + length) == length);
-        assert(boost::detail::distance(my_iterator1(chars), my_iterator1(chars + length)) == length);
-        assert(boost::detail::distance(my_iterator2(chars), my_iterator2(chars + length)) == length);
-        assert(boost::detail::distance(my_iterator3(chars), my_iterator3(chars + length)) == length);
+        BOOST_TEST(boost::detail::distance(&ints[0], ints + length) == length);
+        BOOST_TEST(boost::detail::distance(my_iterator1(chars), my_iterator1(chars + length)) == length);
+        BOOST_TEST(boost::detail::distance(my_iterator2(chars), my_iterator2(chars + length)) == length);
+        BOOST_TEST(boost::detail::distance(my_iterator3(chars), my_iterator3(chars + length)) == length);
     }
-    return 0;
+    return boost::report_errors();
 }