Index: boost/cast.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/cast.hpp,v
retrieving revision 1.27
diff -b -d -u -r1.27 cast.hpp
--- boost/cast.hpp	25 Aug 2005 16:27:20 -0000	1.27
+++ boost/cast.hpp	18 Feb 2006 22:54:44 -0000
@@ -44,7 +44,7 @@
 #define BOOST_CAST_HPP
 
 # include <boost/config.hpp>
-# include <cassert>
+# include <boost/assert.hpp>
 # include <typeinfo>
 # include <boost/type.hpp>
 # include <boost/limits.hpp>
@@ -82,17 +82,19 @@
 
 //  polymorphic_downcast  ----------------------------------------------------//
 
-    //  assert() checked polymorphic downcast.  Crosscasts prohibited.
+    //  BOOST_ASSERT() checked polymorphic downcast.  Crosscasts prohibited.
 
-    //  WARNING: Because this cast uses assert(), it violates the One Definition
-    //  Rule if NDEBUG is inconsistently defined across translation units.
+    //  WARNING: Because this cast uses BOOST_ASSERT(), it violates
+    //  the One Definition Rule if used in multiple translation units
+    //  where BOOST_DISABLE_ASSERTS, BOOST_ENABLE_ASSERT_HANDLER
+    //  NDEBUG are defined inconsistently.
 
     //  Contributed by Dave Abrahams
 
     template <class Target, class Source>
     inline Target polymorphic_downcast(Source* x BOOST_EXPLICIT_DEFAULT_TARGET)
     {
-        assert( dynamic_cast<Target>(x) == x );  // detect logic error
+        BOOST_ASSERT( dynamic_cast<Target>(x) == x );  // detect logic error
         return static_cast<Target>(x);
     }
 
Index: boost/mpl/aux_/test.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/mpl/aux_/test.hpp,v
retrieving revision 1.3
diff -b -d -u -r1.3 test.hpp
--- boost/mpl/aux_/test.hpp	2 Sep 2004 15:40:44 -0000	1.3
+++ boost/mpl/aux_/test.hpp	18 Feb 2006 22:54:45 -0000
@@ -17,12 +17,13 @@
 #include <boost/mpl/aux_/test/test_case.hpp>
 #include <boost/mpl/aux_/test/data.hpp>
 #include <boost/mpl/aux_/test/assert.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #include <boost/type_traits/is_same.hpp>
 
 int main()
 {
-    return 0;
+    return boost::report_errors();
 }
 
 using namespace boost;
Index: libs/conversion/test/implicit_cast.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/conversion/test/implicit_cast.cpp,v
retrieving revision 1.2
diff -b -d -u -r1.2 implicit_cast.cpp
--- libs/conversion/test/implicit_cast.cpp	26 Jul 2004 00:32:08 -0000	1.2
+++ libs/conversion/test/implicit_cast.cpp	18 Feb 2006 22:54:56 -0000
@@ -4,9 +4,8 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/implicit_cast.hpp>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 #include <boost/type.hpp>
-
 using boost::implicit_cast;
 using boost::type;
 
@@ -25,9 +24,9 @@
 int main()
 {
     type<long> x = check_return(boost::implicit_cast<long>(1));
-    assert(boost::implicit_cast<long>(1) == 1L);
+    BOOST_TEST(boost::implicit_cast<long>(1) == 1L);
 
     type<foo> f = check_return(boost::implicit_cast<foo>("hello"));
     type<long> z = check_return(boost::implicit_cast<long>(foo("hello")));
-    return 0;
+    return boost::report_errors();
 }
Index: libs/function/test/function_test.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/function/test/function_test.cpp,v
retrieving revision 1.33
diff -b -d -u -r1.33 function_test.cpp
--- libs/function/test/function_test.cpp	10 May 2005 13:30:35 -0000	1.33
+++ libs/function/test/function_test.cpp	18 Feb 2006 22:54:56 -0000
@@ -10,7 +10,6 @@
 #include <boost/test/minimal.hpp>
 #include <boost/function.hpp>
 #include <functional>
-#include <cassert>
 #include <string>
 #include <utility>
 
@@ -653,12 +652,12 @@
 
 static void test_call_obj(boost::function<int (int, int)> f)
 {
-  assert(!f.empty());
+  BOOST_CHECK(!f.empty());
 }
 
 static void test_call_cref(const boost::function<int (int, int)>& f)
 {
-  assert(!f.empty());
+  BOOST_CHECK(!f.empty());
 }
 
 static void test_call()
Index: libs/functional/hash/test/link_ext_test.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/functional/hash/test/link_ext_test.cpp,v
retrieving revision 1.1
diff -b -d -u -r1.1 link_ext_test.cpp
--- libs/functional/hash/test/link_ext_test.cpp	13 Feb 2006 18:26:00 -0000	1.1
+++ libs/functional/hash/test/link_ext_test.cpp	18 Feb 2006 22:54:56 -0000
@@ -6,12 +6,13 @@
 
 #define HASH_NAMESPACE boost
 #include <boost/functional/hash.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <vector>
 
 int f(std::size_t hash1, int* x1) {
     // Check that HASH_NAMESPACE::hash<int*> works in both files.
     HASH_NAMESPACE::hash<int*> ptr_hasher;
-    assert(hash1 == ptr_hasher(x1));
+    BOOST_TEST(hash1 == ptr_hasher(x1));
 
     // Check that std::vector<std::size_t> is avaiable in this file.
     std::vector<std::size_t> x;
Index: libs/functional/hash/test/link_no_ext_test.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/functional/hash/test/link_no_ext_test.cpp,v
retrieving revision 1.1
diff -b -d -u -r1.1 link_no_ext_test.cpp
--- libs/functional/hash/test/link_no_ext_test.cpp	13 Feb 2006 18:26:00 -0000	1.1
+++ libs/functional/hash/test/link_no_ext_test.cpp	18 Feb 2006 22:54:56 -0000
@@ -7,11 +7,13 @@
 #define HASH_NAMESPACE boost
 #define BOOST_HASH_NO_EXTENSIONS
 #include <boost/functional/hash.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 extern int f(std::size_t, int*);
 
 int main() {
     HASH_NAMESPACE::hash<int*> ptr_hasher;
     int x = 55;
-    return f(ptr_hasher(&x), &x);
+    BOOST_TEST(!f(ptr_hasher(&x), &x));
+    return boost::report_errors();
 }
Index: libs/graph/test/bidir_remove_edge.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/graph/test/bidir_remove_edge.cpp,v
retrieving revision 1.3
diff -b -d -u -r1.3 bidir_remove_edge.cpp
--- libs/graph/test/bidir_remove_edge.cpp	20 Oct 2004 13:19:52 -0000	1.3
+++ libs/graph/test/bidir_remove_edge.cpp	18 Feb 2006 22:55:00 -0000
@@ -6,7 +6,7 @@
 #include <iostream>
 #include <boost/graph/adjacency_list.hpp>
 #include <boost/cstdlib.hpp>
-#include <boost/test/test_tools.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 struct edge_prop {
   int weight;
@@ -25,10 +25,10 @@
     edge_prop p = { 42 };
     edge e; bool b;
     tie(e, b) = add_edge(0, 1, p, g);
-    assert( num_edges(g) == 1 );
-    assert( g[e].weight == 42 );
+    BOOST_TEST( num_edges(g) == 1 );
+    BOOST_TEST( g[e].weight == 42 );
     remove_edge(e, g);
-    assert( num_edges(g) == 0 );
+    BOOST_TEST( num_edges(g) == 0 );
   }
   {
     typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::bidirectionalS> graph;
@@ -38,9 +38,9 @@
 
     edge e; bool b;
     tie(e, b) = add_edge(0, 1, g);
-    assert( num_edges(g) == 1 );
+    BOOST_TEST( num_edges(g) == 1 );
     remove_edge(e, g);
-    assert( num_edges(g) == 0 );
+    BOOST_TEST( num_edges(g) == 0 );
   }
-  return boost::exit_success;
+  return boost::report_errors();
 }
Index: libs/graph/test/isomorphism.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/graph/test/isomorphism.cpp,v
retrieving revision 1.19
diff -b -d -u -r1.19 isomorphism.cpp
--- libs/graph/test/isomorphism.cpp	3 Feb 2005 12:22:38 -0000	1.19
+++ libs/graph/test/isomorphism.cpp	18 Feb 2006 22:55:00 -0000
@@ -49,8 +49,8 @@
 void randomly_permute_graph(const Graph1& g1, Graph2& g2)
 {
   // Need a clean graph to start with
-  assert(num_vertices(g2) == 0);
-  assert(num_edges(g2) == 0);
+  BOOST_REQUIRE(num_vertices(g2) == 0);
+  BOOST_REQUIRE(num_edges(g2) == 0);
 
   typedef typename graph_traits<Graph1>::vertex_descriptor vertex1;
   typedef typename graph_traits<Graph2>::vertex_descriptor vertex2;
Index: libs/iterator/test/counting_iterator_test.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/iterator/test/counting_iterator_test.cpp,v
retrieving revision 1.6
diff -b -d -u -r1.6 counting_iterator_test.cpp
--- libs/iterator/test/counting_iterator_test.cpp	31 Jan 2006 13:30:01 -0000	1.6
+++ libs/iterator/test/counting_iterator_test.cpp	18 Feb 2006 22:55:00 -0000
@@ -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 @@
     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 @@
     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 @@
              ; 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 array[2000];
     test(boost::make_counting_iterator(array), boost::make_counting_iterator(array+2000-1));
 
-    return 0;
+    return boost::report_errors();
 }
Index: libs/iterator/test/indirect_iterator_test.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/iterator/test/indirect_iterator_test.cpp,v
retrieving revision 1.8
diff -b -d -u -r1.8 indirect_iterator_test.cpp
--- libs/iterator/test/indirect_iterator_test.cpp	2 Sep 2004 15:41:28 -0000	1.8
+++ libs/iterator/test/indirect_iterator_test.cpp	18 Feb 2006 22:55:00 -0000
@@ -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 @@
 
     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 @@
     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 @@
 
       more_indirect_iterator_tests();
   }
-  std::cout << "test successful " << std::endl;
-  return 0;
+  return boost::report_errors();
 }
Index: libs/iterator/test/interoperable.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/iterator/test/interoperable.cpp,v
retrieving revision 1.1
diff -b -d -u -r1.1 interoperable.cpp
--- libs/iterator/test/interoperable.cpp	15 Jan 2004 17:08:03 -0000	1.1
+++ libs/iterator/test/interoperable.cpp	18 Feb 2006 22:55:00 -0000
@@ -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 @@
     
     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();
 }
Index: libs/iterator/test/iterator_adaptor_test.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/iterator/test/iterator_adaptor_test.cpp,v
retrieving revision 1.8
diff -b -d -u -r1.8 iterator_adaptor_test.cpp
--- libs/iterator/test/iterator_adaptor_test.cpp	23 Jan 2005 15:40:14 -0000	1.8
+++ libs/iterator/test/iterator_adaptor_test.cpp	18 Feb 2006 22:55:00 -0000
@@ -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 @@
     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 @@
     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 @@
 
   std::cout << "test successful " << std::endl;
   (void)test;
-  return 0;
+  return boost::report_errors();
 }
Index: libs/iterator/test/iterator_traits_test.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/iterator/test/iterator_traits_test.cpp,v
retrieving revision 1.3
diff -b -d -u -r1.3 iterator_traits_test.cpp
--- libs/iterator/test/iterator_traits_test.cpp	7 Sep 2005 16:03:55 -0000	1.3
+++ libs/iterator/test/iterator_traits_test.cpp	18 Feb 2006 22:55:01 -0000
@@ -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 @@
     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();
 }
Index: libs/mpl/test/Jamfile
===================================================================
RCS file: /cvsroot/boost/boost/libs/mpl/test/Jamfile,v
retrieving revision 1.17
diff -b -d -u -r1.17 Jamfile
--- libs/mpl/test/Jamfile	28 Nov 2004 03:35:12 -0000	1.17
+++ libs/mpl/test/Jamfile	18 Feb 2006 22:55:08 -0000
@@ -18,7 +18,7 @@
 compile back.cpp ;
 compile bind.cpp ;
 compile bitwise.cpp ;
-compile bool.cpp ;
+run bool.cpp ;
 compile comparison.cpp ;
 compile contains.cpp ;
 compile copy.cpp ;
@@ -36,7 +36,7 @@
 compile find.cpp ;
 compile find_if.cpp ;
 compile fold.cpp ;
-unit-test for_each : for_each.cpp : <sysinclude>$(BOOST_ROOT) ;
+run for_each.cpp ;
 compile front.cpp ;
 compile has_xxx.cpp ;
 compile identity.cpp ;
@@ -45,8 +45,8 @@
 compile inherit.cpp ;
 compile insert.cpp ;
 compile insert_range.cpp ;
-compile int.cpp ;
-compile integral_c.cpp ;
+run int.cpp ;
+run integral_c.cpp ;
 compile is_placeholder.cpp ;
 compile is_sequence.cpp ;
 compile iterator_tags.cpp ;
@@ -80,7 +80,7 @@
 compile set_c.cpp ;
 compile single_view.cpp ;
 compile size.cpp ;
-compile size_t.cpp ;
+run size_t.cpp ;
 compile sizeof.cpp ;
 compile sort.cpp ;
 compile stable_partition.cpp ;
Index: libs/mpl/test/Jamfile.v2
===================================================================
RCS file: /cvsroot/boost/boost/libs/mpl/test/Jamfile.v2,v
retrieving revision 1.1
diff -b -d -u -r1.1 Jamfile.v2
--- libs/mpl/test/Jamfile.v2	14 Apr 2005 11:47:45 -0000	1.1
+++ libs/mpl/test/Jamfile.v2	18 Feb 2006 22:55:08 -0000
@@ -14,7 +14,7 @@
 compile back.cpp ;
 compile bind.cpp ;
 compile bitwise.cpp ;
-compile bool.cpp ;
+run bool.cpp ;
 compile comparison.cpp ;
 compile contains.cpp ;
 compile copy.cpp ;
@@ -41,8 +41,8 @@
 compile inherit.cpp ;
 compile insert.cpp ;
 compile insert_range.cpp ;
-compile int.cpp ;
-compile integral_c.cpp ;
+run int.cpp ;
+run integral_c.cpp ;
 compile is_placeholder.cpp ;
 compile is_sequence.cpp ;
 compile iterator_tags.cpp ;
@@ -76,7 +76,7 @@
 compile set_c.cpp ;
 compile single_view.cpp ;
 compile size.cpp ;
-compile size_t.cpp ;
+run size_t.cpp ;
 compile sizeof.cpp ;
 compile sort.cpp ;
 compile stable_partition.cpp ;
Index: libs/mpl/test/bool.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/mpl/test/bool.cpp,v
retrieving revision 1.3
diff -b -d -u -r1.3 bool.cpp
--- libs/mpl/test/bool.cpp	2 Sep 2004 15:41:35 -0000	1.3
+++ libs/mpl/test/bool.cpp	18 Feb 2006 22:55:08 -0000
@@ -21,7 +21,7 @@
     { MPL_ASSERT(( is_same< bool_<c>, c##_ > )); } \
     { MPL_ASSERT(( is_same< bool_<c>::type, bool_<c> > )); } \
     { MPL_ASSERT_RELATION( bool_<c>::value, ==, c ); } \
-    assert( bool_<c>() == c ); \
+    BOOST_TEST( bool_<c>() == c ); \
 /**/
 
 MPL_TEST_CASE()
Index: libs/mpl/test/integral_wrapper_test.hpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/mpl/test/integral_wrapper_test.hpp,v
retrieving revision 1.3
diff -b -d -u -r1.3 integral_wrapper_test.hpp
--- libs/mpl/test/integral_wrapper_test.hpp	13 Oct 2004 14:27:35 -0000	1.3
+++ libs/mpl/test/integral_wrapper_test.hpp	18 Feb 2006 22:55:08 -0000
@@ -19,12 +19,12 @@
 
 #if !BOOST_WORKAROUND(__BORLANDC__, < 0x600)
 #   define INTEGRAL_WRAPPER_RUNTIME_TEST(i, T) \
-    assert(( WRAPPER(T,i)() == i )); \
-    assert(( WRAPPER(T,i)::value == i )); \
+    BOOST_TEST(( WRAPPER(T,i)() == i )); \
+    BOOST_TEST(( WRAPPER(T,i)::value == i )); \
     /**/
 #else
 #   define INTEGRAL_WRAPPER_RUNTIME_TEST(i, T) \
-    assert(( WRAPPER(T,i)::value == i )); \
+    BOOST_TEST(( WRAPPER(T,i)::value == i )); \
     /**/
 #endif
 
Index: libs/mpl/test/set.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/mpl/test/set.cpp,v
retrieving revision 1.10
diff -b -d -u -r1.10 set.cpp
--- libs/mpl/test/set.cpp	18 Jun 2005 20:51:18 -0000	1.10
+++ libs/mpl/test/set.cpp	18 Feb 2006 22:55:08 -0000
@@ -68,9 +68,9 @@
     typedef begin<s2>::type first2;
     typedef end<s2>::type last2;
 
-    MPL_ASSERT(( is_same< first2::type, int > ));
+    MPL_ASSERT(( is_same< deref<first2>::type, int > ));
     typedef next<first2>::type iter;
-    MPL_ASSERT(( is_same< iter::type, char > ));
+    MPL_ASSERT(( is_same< deref<iter>::type, char > ));
     MPL_ASSERT(( is_same< next<iter>::type, last2 > ));
 
     typedef insert<s2,int>::type s2_1;
@@ -166,15 +166,15 @@
 
 // Use a template for testing so that GCC will show us the actual types involved
 template <class S>
-struct test
+void test()
 {
     MPL_ASSERT_RELATION( size<S>::value, ==, 3 );
 
     typedef typename end<S>::type not_found;
-    BOOST_MPL_ASSERT_NOT(( is_same<typename find<S,int>::type,not_found> ));
-    BOOST_MPL_ASSERT_NOT(( is_same<typename find<S,long>::type,not_found> ));
-    BOOST_MPL_ASSERT_NOT(( is_same<typename find<S,char>::type,not_found> ));
-    BOOST_MPL_ASSERT(( is_same<typename find<S,char*>::type,not_found> ));
+    BOOST_MPL_ASSERT_NOT(( is_same<BOOST_DEDUCED_TYPENAME find<S,int>::type,not_found> ));
+    BOOST_MPL_ASSERT_NOT(( is_same<BOOST_DEDUCED_TYPENAME find<S,long>::type,not_found> ));
+    BOOST_MPL_ASSERT_NOT(( is_same<BOOST_DEDUCED_TYPENAME find<S,char>::type,not_found> ));
+    BOOST_MPL_ASSERT(( is_same<BOOST_DEDUCED_TYPENAME find<S,char*>::type,not_found> ));
 };
 
 MPL_TEST_CASE()
@@ -185,6 +185,6 @@
     
     typedef mpl::set<int,long,char> myset;
     
-    test<myset> x;
-    test<myset::type> y;
+    test<myset>();
+    test<myset::type>();
 }
Index: libs/parameter/test/singular.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/parameter/test/singular.cpp,v
retrieving revision 1.1
diff -b -d -u -r1.1 singular.cpp
--- libs/parameter/test/singular.cpp	6 Dec 2005 11:35:15 -0000	1.1
+++ libs/parameter/test/singular.cpp	18 Feb 2006 22:55:09 -0000
@@ -3,7 +3,7 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/parameter/keyword.hpp>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 BOOST_PARAMETER_KEYWORD(tag, x)
 BOOST_PARAMETER_KEYWORD(tag, y)
@@ -21,7 +21,7 @@
 template <class ArgumentPack, class K, class T>
 void check(ArgumentPack const& p, K const& kw, T const& value)
 {
-    assert(p[kw] == value);
+    BOOST_TEST(p[kw] == value);
 }
 
 int main()
@@ -37,6 +37,6 @@
     
     check(y = 20, x | 0, 0);
     check(y = 20, x || default_src(), 0);
-    return 0;
+    return boost::report_errors();
 }
 
Index: libs/program_options/test/test_convert.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/program_options/test/test_convert.cpp,v
retrieving revision 1.1
diff -b -d -u -r1.1 test_convert.cpp
--- libs/program_options/test/test_convert.cpp	14 May 2004 13:40:31 -0000	1.1
+++ libs/program_options/test/test_convert.cpp	18 Feb 2006 22:55:09 -0000
@@ -7,7 +7,6 @@
 #include <fstream>
 #include <sstream>
 #include <iostream>
-#include <cassert>
 #include <boost/progress.hpp>
 #include <boost/bind.hpp>
 #include <boost/ref.hpp>
@@ -94,7 +93,7 @@
                 facet);
     }
 
-    assert(output.size()*2 == expected_output.size());
+    BOOST_CHECK(output.size()*2 == expected_output.size());
 
     for(unsigned i = 0; i < output.size(); ++i) {
 
@@ -103,20 +102,20 @@
             low &= 0xFF;
             unsigned low2 = expected_output[2*i];
             low2 &= 0xFF;
-            assert(low == low2);
+            BOOST_CHECK(low == low2);
         }
         {        
             unsigned high = output[i];
             high >>= 8;
             high &= 0xFF;
             unsigned high2 = expected_output[2*i+1];            
-            assert(high == high2);
+            BOOST_CHECK(high == high2);
         }
     }
 
     string ref = boost::to_8_bit(output, facet);
 
-    assert(ref == input);
+    BOOST_CHECK(ref == input);
 }
 
 int test_main(int ac, char* av[])
Index: libs/ptr_container/test/pointainer_speed.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/ptr_container/test/pointainer_speed.cpp,v
retrieving revision 1.3
diff -b -d -u -r1.3 pointainer_speed.cpp
--- libs/ptr_container/test/pointainer_speed.cpp	1 May 2005 22:22:51 -0000	1.3
+++ libs/ptr_container/test/pointainer_speed.cpp	18 Feb 2006 22:55:09 -0000
@@ -183,7 +183,7 @@
             cout << copy1[i] << endl;
     }   
 
-    assert( pvec.size() == size );
+    BOOST_REQUIRE( pvec.size() == size );
     cout << endl;
 }
 
Index: libs/python/test/back_reference.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/python/test/back_reference.cpp,v
retrieving revision 1.12
diff -b -d -u -r1.12 back_reference.cpp
--- libs/python/test/back_reference.cpp	22 Jan 2006 19:28:57 -0000	1.12
+++ libs/python/test/back_reference.cpp	18 Feb 2006 22:55:09 -0000
@@ -10,7 +10,8 @@
 #include <boost/ref.hpp>
 #include <boost/utility.hpp>
 #include <memory>
-#include <cassert>
+#define BOOST_ENABLE_ASSERT_HANDLER
+#include <boost/assert.hpp>
 #include <boost/python/copy_const_reference.hpp>
 #include <boost/python/return_value_policy.hpp>
 #include <boost/mpl/bool.hpp>
@@ -24,10 +25,10 @@
 {
     explicit X(int x) : x(x), magic(7654321) { ++counter; }
     X(X const& rhs) : x(rhs.x), magic(7654321) { ++counter; }
-    virtual ~X() { assert(magic == 7654321); magic = 6666666; x = 9999; --counter; }
+    virtual ~X() { BOOST_ASSERT(magic == 7654321); magic = 6666666; x = 9999; --counter; }
 
-    void set(int x) { assert(magic == 7654321); this->x = x; }
-    int value() const { assert(magic == 7654321); return x; }
+    void set(int x) { BOOST_ASSERT(magic == 7654321); this->x = x; }
+    int value() const { BOOST_ASSERT(magic == 7654321); return x; }
     static int count() { return counter; }
  private:
     void operator=(X const&);
Index: libs/python/test/callbacks.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/python/test/callbacks.cpp,v
retrieving revision 1.15
diff -b -d -u -r1.15 callbacks.cpp
--- libs/python/test/callbacks.cpp	20 Aug 2004 11:09:19 -0000	1.15
+++ libs/python/test/callbacks.cpp	18 Feb 2006 22:55:09 -0000
@@ -2,6 +2,8 @@
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
+#include <boost/assert.hpp>
+
 #include <boost/python/module.hpp>
 #include <boost/python/def.hpp>
 #include <boost/python/class.hpp>
@@ -29,10 +31,10 @@
 {
     explicit X(int x) : x(x), magic(7654321) { ++counter; }
     X(X const& rhs) : x(rhs.x), magic(7654321) { ++counter; }
-    ~X() { assert(magic == 7654321); magic = 6666666; x = 9999; --counter; }
+    ~X() { BOOST_ASSERT(magic == 7654321); magic = 6666666; x = 9999; --counter; }
 
-    void set(int x) { assert(magic == 7654321); this->x = x; }
-    int value() const { assert(magic == 7654321); return x; }
+    void set(int x) { BOOST_ASSERT(magic == 7654321); this->x = x; }
+    int value() const { BOOST_ASSERT(magic == 7654321); return x; }
     static int count() { return counter; }
  private:
     void operator=(X const&);
Index: libs/python/test/destroy_test.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/python/test/destroy_test.cpp,v
retrieving revision 1.4
diff -b -d -u -r1.4 destroy_test.cpp
--- libs/python/test/destroy_test.cpp	10 Aug 2004 14:59:57 -0000	1.4
+++ libs/python/test/destroy_test.cpp	18 Feb 2006 22:55:09 -0000
@@ -2,7 +2,8 @@
 // Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 #include <boost/python/detail/destroy.hpp>
-#include <cassert>
+
+#include <boost/detail/lightweight_test.hpp>
 
 int count;
 int marks[] = {
@@ -26,8 +27,8 @@
 void assert_destructions(int n)
 {
     for (int i = 0; i < n; ++i)
-        assert(marks[i] == i);
-    assert(marks[n] == -1);
+        BOOST_TEST(marks[i] == i);
+    BOOST_TEST(marks[n] == -1);
 }
 
 int main()
@@ -50,5 +51,5 @@
     boost::python::detail::destroy_referent<y&>(f3);
     assert_destructions(7);
 
-    return 0;
+    return boost::report_errors();
 }
Index: libs/python/test/dict.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/python/test/dict.cpp,v
retrieving revision 1.7
diff -b -d -u -r1.7 dict.cpp
--- libs/python/test/dict.cpp	8 Sep 2004 19:18:55 -0000	1.7
+++ libs/python/test/dict.cpp	18 Feb 2006 22:55:09 -0000
@@ -2,6 +2,8 @@
 // Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 #include <boost/python/module.hpp>
+#include <boost/assert.hpp>
+
 #include <boost/python/def.hpp>
 #include <boost/python/class.hpp>
 #include <boost/python/dict.hpp>
@@ -69,7 +71,7 @@
     print(tmp.get(2,"default"));
     print(tmp.setdefault(3,"default"));
 
-    assert(!tmp.has_key(key));
+    BOOST_ASSERT(!tmp.has_key(key));
     //print(tmp[3]);
 }
     
Index: libs/python/test/exec.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/python/test/exec.cpp,v
retrieving revision 1.4
diff -b -d -u -r1.4 exec.cpp
--- libs/python/test/exec.cpp	13 Sep 2005 14:42:03 -0000	1.4
+++ libs/python/test/exec.cpp	18 Feb 2006 22:55:09 -0000
@@ -4,22 +4,10 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/python.hpp>
-#define BOOST_ENABLE_ASSERT_HANDLER 1
-#include <boost/assert.hpp>
-#include <iostream>
-
-namespace boost
-{
 
-void assertion_failed(char const * expr, char const * function,
-		      char const * file, long line)
-{
-  std::cerr << "assertion failed : " << expr << " in " << function
-	    << " at " << file << ':' << line << std::endl;
-  abort();
-}
+#include <boost/detail/lightweight_test.hpp>
+#include <iostream>
 
-} // namespace boost
 
 namespace python = boost::python;
 
@@ -85,7 +73,7 @@
 
   // Creating and using instances of the C++ class is as easy as always.
   CppDerived cpp;
-  BOOST_ASSERT(cpp.hello() == "Hello from C++!");
+  BOOST_TEST(cpp.hello() == "Hello from C++!");
 
   // But now creating and using instances of the Python class is almost
   // as easy!
@@ -93,7 +81,7 @@
   Base& py = python::extract<Base&>(py_base) BOOST_EXTRACT_WORKAROUND;
 
   // Make sure the right 'hello' method is called.
-  BOOST_ASSERT(py.hello() == "Hello from Python!");
+  BOOST_TEST(py.hello() == "Hello from Python!");
 }
 
 void exec_file_test(std::string const &script)
@@ -103,7 +91,7 @@
   python::object result = python::exec_file(script.c_str(), global, global);
 
   // Extract an object the script stored in the global dictionary.
-  BOOST_ASSERT(python::extract<int>(global["number"]) ==  42);
+  BOOST_TEST(python::extract<int>(global["number"]) ==  42);
 }
 
 void exec_test_error()
@@ -115,9 +103,8 @@
 
 int main(int argc, char **argv)
 {
-  assert(argc == 2);
+  BOOST_TEST(argc == 2);
   std::string script = argv[1];
-  bool success = true;
   // Initialize the interpreter
   Py_Initialize();
 
@@ -126,15 +113,16 @@
   {
     if (PyErr_Occurred())
     {
+      BOOST_ERROR("Python Error detected");
       PyErr_Print();
     }
     else
     {
-      std::cerr << "A C++ exception was thrown  for which "
-		<< "there was no exception handler registered." << std::endl;
+        BOOST_ERROR("A C++ exception was thrown  for which "
+                    "there was no exception handler registered.");
     }
-    success = false;
   }
+  
   if (python::handle_exception(exec_test_error))
   {
     if (PyErr_Occurred())
@@ -143,18 +131,18 @@
     }
     else
     {
-      std::cerr << "A C++ exception was thrown  for which "
-		<< "there was no exception handler registered." << std::endl;
-      success = false;
+        BOOST_ERROR("A C++ exception was thrown  for which "
+                    "there was no exception handler registered.");
     }
   }
   else
   {
-    success = false;
+      BOOST_ERROR("Python exception expected, but not seen.");
   }
+  
   // Boost.Python doesn't support Py_Finalize yet.
   // Py_Finalize();
-  return success ? 0 : 1;
+  return boost::report_errors();
 }
 
 // Including this file makes sure
Index: libs/python/test/extract.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/python/test/extract.cpp,v
retrieving revision 1.17
diff -b -d -u -r1.17 extract.cpp
--- libs/python/test/extract.cpp	22 Jan 2006 19:28:58 -0000	1.17
+++ libs/python/test/extract.cpp	18 Feb 2006 22:55:12 -0000
@@ -13,7 +13,8 @@
 #include <boost/python/implicit.hpp>
 #include <string>
 #include <boost/lexical_cast.hpp>
-#include <cassert>
+#define BOOST_ENABLE_ASSERT_HANDLER
+#include <boost/assert.hpp>
 #include "test_class.hpp"
 
 using namespace boost::python;
Index: libs/python/test/indirect_traits_test.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/python/test/indirect_traits_test.cpp,v
retrieving revision 1.9
diff -b -d -u -r1.9 indirect_traits_test.cpp
--- libs/python/test/indirect_traits_test.cpp	24 Jun 2005 15:42:22 -0000	1.9
+++ libs/python/test/indirect_traits_test.cpp	18 Feb 2006 22:55:12 -0000
@@ -2,7 +2,8 @@
 // Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //#include <stdio.h>
-#include <cassert>
+#define BOOST_ENABLE_ASSERT_HANDLER
+#include <boost/assert.hpp>
 #include <boost/type_traits/is_member_function_pointer.hpp>
 #include <boost/mpl/assert.hpp>
 #include <boost/python/detail/indirect_traits.hpp>
Index: libs/python/test/list.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/python/test/list.cpp,v
retrieving revision 1.11
diff -b -d -u -r1.11 list.cpp
--- libs/python/test/list.cpp	25 Oct 2004 11:58:45 -0000	1.11
+++ libs/python/test/list.cpp	18 Feb 2006 22:55:12 -0000
@@ -2,6 +2,8 @@
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
+#include <boost/assert.hpp>
+
 
 #include <boost/python/module.hpp>
 #include <boost/python/def.hpp>
@@ -118,10 +120,10 @@
     w.append(5);
     w.append(6);
     w += "hi";
-    assert(w[0] == 5);
-    assert(w[1] == 6);
-    assert(w[2] == 'h');
-    assert(w[3] == 'i');
+    BOOST_ASSERT(w[0] == 5);
+    BOOST_ASSERT(w[1] == 6);
+    BOOST_ASSERT(w[2] == 'h');
+    BOOST_ASSERT(w[3] == 'i');
 }
 
 BOOST_PYTHON_MODULE(list_ext)
Index: libs/python/test/long.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/python/test/long.cpp,v
retrieving revision 1.5
diff -b -d -u -r1.5 long.cpp
--- libs/python/test/long.cpp	20 Aug 2004 11:09:19 -0000	1.5
+++ libs/python/test/long.cpp	18 Feb 2006 22:55:12 -0000
@@ -7,7 +7,8 @@
 #include <boost/python/def.hpp>
 #include <boost/python/long.hpp>
 #include <boost/python/class.hpp>
-#include <cassert>
+#define BOOST_ENABLE_ASSERT_HANDLER
+#include <boost/assert.hpp>
 
 using namespace boost::python;
 
@@ -30,7 +31,7 @@
 {
     long_ y = x;
     x += 50;
-    assert(x == y + 50);
+    BOOST_ASSERT(x == y + 50);
     return "yes";
 }
 
@@ -59,3 +60,4 @@
         ;
 }
 
+#include "module_tail.cpp"
Index: libs/python/test/module_tail.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/python/test/module_tail.cpp,v
retrieving revision 1.6
diff -b -d -u -r1.6 module_tail.cpp
--- libs/python/test/module_tail.cpp	18 May 2005 01:34:30 -0000	1.6
+++ libs/python/test/module_tail.cpp	18 Feb 2006 22:55:12 -0000
@@ -27,3 +27,29 @@
 
 #endif // _WIN32
 
+#include <exception>
+#include <boost/python/extract.hpp>
+#include <boost/python/str.hpp>
+struct test_failure : std::exception
+{
+    test_failure(char const* expr, char const* function, char const* file, unsigned line)
+      : msg(file + boost::python::str(":%s:") % line + ": Boost.Python assertion failure: " + expr)
+    {}
+    
+    char const* what() throw()
+    {
+        return boost::python::extract<char const*>(msg)();
+    }
+
+    boost::python::str msg;
+};
+
+namespace boost
+{
+
+void assertion_failed(char const * expr, char const * function, char const * file, long line)
+{
+    throw ::test_failure(expr,function, file, line);
+}
+
+} // namespace boost
Index: libs/python/test/pointer_type_id_test.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/python/test/pointer_type_id_test.cpp,v
retrieving revision 1.3
diff -b -d -u -r1.3 pointer_type_id_test.cpp
--- libs/python/test/pointer_type_id_test.cpp	10 Aug 2004 14:59:57 -0000	1.3
+++ libs/python/test/pointer_type_id_test.cpp	18 Feb 2006 22:55:12 -0000
@@ -2,7 +2,8 @@
 // Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 #include <boost/python/type_id.hpp>
-#include <cassert>
+
+#include <boost/detail/lightweight_test.hpp>
 #include <boost/python/converter/pointer_type_id.hpp>
 
 int main()
@@ -13,30 +14,30 @@
         = boost::python::type_id<int>();
     
 
-    assert(pointer_type_id<int*>() == x);
-    assert(pointer_type_id<int const*>() == x);
-    assert(pointer_type_id<int volatile*>() == x);
-    assert(pointer_type_id<int const volatile*>() == x);
+    BOOST_TEST(pointer_type_id<int*>() == x);
+    BOOST_TEST(pointer_type_id<int const*>() == x);
+    BOOST_TEST(pointer_type_id<int volatile*>() == x);
+    BOOST_TEST(pointer_type_id<int const volatile*>() == x);
     
-    assert(pointer_type_id<int*&>() == x);
-    assert(pointer_type_id<int const*&>() == x);
-    assert(pointer_type_id<int volatile*&>() == x);
-    assert(pointer_type_id<int const volatile*&>() == x);
+    BOOST_TEST(pointer_type_id<int*&>() == x);
+    BOOST_TEST(pointer_type_id<int const*&>() == x);
+    BOOST_TEST(pointer_type_id<int volatile*&>() == x);
+    BOOST_TEST(pointer_type_id<int const volatile*&>() == x);
     
-    assert(pointer_type_id<int*const&>() == x);
-    assert(pointer_type_id<int const*const&>() == x);
-    assert(pointer_type_id<int volatile*const&>() == x);
-    assert(pointer_type_id<int const volatile*const&>() == x);
+    BOOST_TEST(pointer_type_id<int*const&>() == x);
+    BOOST_TEST(pointer_type_id<int const*const&>() == x);
+    BOOST_TEST(pointer_type_id<int volatile*const&>() == x);
+    BOOST_TEST(pointer_type_id<int const volatile*const&>() == x);
     
-    assert(pointer_type_id<int*volatile&>() == x);
-    assert(pointer_type_id<int const*volatile&>() == x);
-    assert(pointer_type_id<int volatile*volatile&>() == x);
-    assert(pointer_type_id<int const volatile*volatile&>() == x);
+    BOOST_TEST(pointer_type_id<int*volatile&>() == x);
+    BOOST_TEST(pointer_type_id<int const*volatile&>() == x);
+    BOOST_TEST(pointer_type_id<int volatile*volatile&>() == x);
+    BOOST_TEST(pointer_type_id<int const volatile*volatile&>() == x);
     
-    assert(pointer_type_id<int*const volatile&>() == x);
-    assert(pointer_type_id<int const*const volatile&>() == x);
-    assert(pointer_type_id<int volatile*const volatile&>() == x);
-    assert(pointer_type_id<int const volatile*const volatile&>() == x);
+    BOOST_TEST(pointer_type_id<int*const volatile&>() == x);
+    BOOST_TEST(pointer_type_id<int const*const volatile&>() == x);
+    BOOST_TEST(pointer_type_id<int volatile*const volatile&>() == x);
+    BOOST_TEST(pointer_type_id<int const volatile*const volatile&>() == x);
     
-    return 0;
+    return boost::report_errors();
 }
Index: libs/python/test/raw_pyobject_fail1.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/python/test/raw_pyobject_fail1.cpp,v
retrieving revision 1.2
diff -b -d -u -r1.2 raw_pyobject_fail1.cpp
--- libs/python/test/raw_pyobject_fail1.cpp	20 Aug 2004 11:09:19 -0000	1.2
+++ libs/python/test/raw_pyobject_fail1.cpp	18 Feb 2006 22:55:12 -0000
@@ -7,5 +7,5 @@
 int main()
 {
     boost::python::converter::arg_to_python<PyTypeObject*> x(0);
-    return 0;
+    return boost::report_errors();
 }
Index: libs/python/test/raw_pyobject_fail2.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/python/test/raw_pyobject_fail2.cpp,v
retrieving revision 1.2
diff -b -d -u -r1.2 raw_pyobject_fail2.cpp
--- libs/python/test/raw_pyobject_fail2.cpp	20 Aug 2004 11:09:19 -0000	1.2
+++ libs/python/test/raw_pyobject_fail2.cpp	18 Feb 2006 22:55:12 -0000
@@ -9,5 +9,5 @@
 int main()
 {
     boost::python::converter::arg_to_python<X*> x(0);
-    return 0;
+    return boost::report_errors();
 }
Index: libs/python/test/staticmethod.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/python/test/staticmethod.cpp,v
retrieving revision 1.2
diff -b -d -u -r1.2 staticmethod.cpp
--- libs/python/test/staticmethod.cpp	20 Aug 2004 11:09:19 -0000	1.2
+++ libs/python/test/staticmethod.cpp	18 Feb 2006 22:55:12 -0000
@@ -2,6 +2,8 @@
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
+#include <boost/assert.hpp>
+
 #include <boost/python/class.hpp>
 #include <boost/python/module.hpp>
 #include <boost/python/def.hpp>
@@ -15,10 +17,10 @@
 {
     explicit X(int x) : x(x), magic(7654321) { ++counter; }
     X(X const& rhs) : x(rhs.x), magic(7654321) { ++counter; }
-    virtual ~X() { assert(magic == 7654321); magic = 6666666; x = 9999; --counter; }
+    virtual ~X() { BOOST_ASSERT(magic == 7654321); magic = 6666666; x = 9999; --counter; }
 
-    void set(int x) { assert(magic == 7654321); this->x = x; }
-    int value() const { assert(magic == 7654321); return x; }
+    void set(int x) { BOOST_ASSERT(magic == 7654321); this->x = x; }
+    int value() const { BOOST_ASSERT(magic == 7654321); return x; }
     static int count() { return counter; }
  private:
     void operator=(X const&);
Index: libs/python/test/str.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/python/test/str.cpp,v
retrieving revision 1.7
diff -b -d -u -r1.7 str.cpp
--- libs/python/test/str.cpp	8 Sep 2004 19:18:55 -0000	1.7
+++ libs/python/test/str.cpp	18 Feb 2006 22:55:12 -0000
@@ -2,6 +2,8 @@
 // Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 #include <boost/python/module.hpp>
+#include <boost/assert.hpp>
+
 #include <boost/python/def.hpp>
 #include <boost/python/class.hpp>
 #include <boost/python/str.hpp>
@@ -25,8 +27,8 @@
     print(data.encode("utf-8"));
     print(data.decode("utf-8"));
     
-    assert(!data.endswith("xx"));
-    assert(!data.startswith("test"));
+    BOOST_ASSERT(!data.endswith("xx"));
+    BOOST_ASSERT(!data.startswith("test"));
     
     print(data.splitlines());
     print(data.strip());
@@ -54,8 +56,8 @@
     print(data.rfind("i",5));
     print(data.rindex("i",5));
 
-    assert(!data.startswith("asdf"));
-    assert(!data.endswith("asdf"));
+    BOOST_ASSERT(!data.startswith("asdf"));
+    BOOST_ASSERT(!data.endswith("asdf"));
     
     print(data.translate(str('a')*256));
 
Index: libs/python/test/string_literal.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/python/test/string_literal.cpp,v
retrieving revision 1.4
diff -b -d -u -r1.4 string_literal.cpp
--- libs/python/test/string_literal.cpp	10 Aug 2004 14:59:57 -0000	1.4
+++ libs/python/test/string_literal.cpp	18 Feb 2006 22:55:12 -0000
@@ -3,7 +3,8 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 #include <boost/python/detail/string_literal.hpp>
 //#include <stdio.h>
-#include <cassert>
+
+#include <boost/detail/lightweight_test.hpp>
 #include <boost/static_assert.hpp>
 
 using namespace boost::python::detail;
@@ -37,5 +38,5 @@
     BOOST_STATIC_ASSERT(!is_string_literal<int[20]>::value);
     BOOST_STATIC_ASSERT(!is_string_literal<int const[20]>::value);
     BOOST_STATIC_ASSERT(!is_string_literal<int const[3]>::value);
-    return 0;
+    return boost::report_errors();
 }
Index: libs/python/test/test_class.hpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/python/test/test_class.hpp,v
retrieving revision 1.4
diff -b -d -u -r1.4 test_class.hpp
--- libs/python/test/test_class.hpp	20 Aug 2004 11:09:19 -0000	1.4
+++ libs/python/test/test_class.hpp	18 Feb 2006 22:55:12 -0000
@@ -4,17 +4,17 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 #ifndef TEST_CLASS_DWA2002326_HPP
 # define TEST_CLASS_DWA2002326_HPP
-# include <cassert>
+# include <boost/detail/lightweight_test.hpp>
 
 template <int n = 0>
 struct test_class
 {
     explicit test_class(int x) : x(x), magic(7654321 + n) { ++counter; }
     test_class(test_class const& rhs) : x(rhs.x), magic(7654321 + n) { ++counter; }
-    virtual ~test_class() { assert(magic == 7654321 + n); magic = 6666666; x = 9999; --counter; }
+    virtual ~test_class() { BOOST_TEST(magic == 7654321 + n); magic = 6666666; x = 9999; --counter; }
 
-    void set(int x) { assert(magic == 7654321 + n); this->x = x; }
-    int value() const { assert(magic == 7654321 + n); return x; }
+    void set(int x) { BOOST_TEST(magic == 7654321 + n); this->x = x; }
+    int value() const { BOOST_TEST(magic == 7654321 + n); return x; }
     operator int() const { return x; }
     static int count() { return counter; }
 
Index: libs/python/test/upcast.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/python/test/upcast.cpp,v
retrieving revision 1.2
diff -b -d -u -r1.2 upcast.cpp
--- libs/python/test/upcast.cpp	20 Aug 2004 11:09:19 -0000	1.2
+++ libs/python/test/upcast.cpp	18 Feb 2006 22:55:12 -0000
@@ -2,6 +2,7 @@
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
+#include <boost/detail/lightweight_test.hpp>
 #include <boost/python/cast.hpp>
 
 struct X { long x; };
@@ -11,8 +12,8 @@
 {
     PyTypeObject o;
     Y y;
-    assert(&boost::python::upcast<PyObject>(&o)->ob_refcnt == &o.ob_refcnt);
-    assert(&boost::python::upcast<PyObject>(&y)->ob_refcnt == &y.ob_refcnt);
-    return 0;
+    BOOST_TEST(&boost::python::upcast<PyObject>(&o)->ob_refcnt == &o.ob_refcnt);
+    BOOST_TEST(&boost::python::upcast<PyObject>(&y)->ob_refcnt == &y.ob_refcnt);
+    return boost::report_errors();
 }
 
Index: libs/python/test/virtual_functions.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/python/test/virtual_functions.cpp,v
retrieving revision 1.13
diff -b -d -u -r1.13 virtual_functions.cpp
--- libs/python/test/virtual_functions.cpp	20 Aug 2004 11:09:19 -0000	1.13
+++ libs/python/test/virtual_functions.cpp	18 Feb 2006 22:55:12 -0000
@@ -2,6 +2,8 @@
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
+#include <boost/assert.hpp>
+
 #include <boost/python/class.hpp>
 #include <boost/python/module.hpp>
 #include <boost/python/def.hpp>
@@ -16,10 +18,10 @@
 {
     explicit X(int x) : x(x), magic(7654321) { ++counter; }
     X(X const& rhs) : x(rhs.x), magic(7654321) { ++counter; }
-    virtual ~X() { assert(magic == 7654321); magic = 6666666; x = 9999; --counter; }
+    virtual ~X() { BOOST_ASSERT(magic == 7654321); magic = 6666666; x = 9999; --counter; }
 
-    void set(int x) { assert(magic == 7654321); this->x = x; }
-    int value() const { assert(magic == 7654321); return x; }
+    void set(int x) { BOOST_ASSERT(magic == 7654321); this->x = x; }
+    int value() const { BOOST_ASSERT(magic == 7654321); return x; }
     static int count() { return counter; }
  private:
     void operator=(X const&);
Index: libs/spirit/fusion/test/pair_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/fusion/test/pair_tests.cpp,v
retrieving revision 1.1
diff -b -d -u -r1.1 pair_tests.cpp
--- libs/spirit/fusion/test/pair_tests.cpp	28 Nov 2005 23:09:23 -0000	1.1
+++ libs/spirit/fusion/test/pair_tests.cpp	18 Feb 2006 22:55:12 -0000
@@ -6,6 +6,8 @@
 #include <boost/mpl/assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 
+#include <boost/detail/lightweight_test.hpp>
+
 #include <utility>
 #include <iostream>
 #include <string>
@@ -19,17 +21,17 @@
     BOOST_MPL_ASSERT((boost::is_same<tuple_element<1, std::pair<int, float> >::type, float>));
 
     std::pair<int, std::string> pr(1, "hello");
-    assert(get<0>(pr) == 1);
-    assert(get<1>(pr) == "hello");
+    BOOST_TEST(get<0>(pr) == 1);
+    BOOST_TEST(get<1>(pr) == "hello");
 
     get<0>(pr) = 2;
     get<1>(pr) = "world";
-    assert(get<0>(pr) == 2);
-    assert(get<1>(pr) == "world");
+    BOOST_TEST(get<0>(pr) == 2);
+    BOOST_TEST(get<1>(pr) == "world");
 
     const std::pair<int, std::string> pr2(pr);
-    assert(get<0>(pr2) == 2);
-    assert(get<1>(pr2) == "world");
+    BOOST_TEST(get<0>(pr2) == 2);
+    BOOST_TEST(get<1>(pr2) == "world");
     
     return 0;
 }
Index: libs/spirit/phoenix/test/binary_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/phoenix/test/binary_tests.cpp,v
retrieving revision 1.8
diff -b -d -u -r1.8 binary_tests.cpp
--- libs/spirit/phoenix/test/binary_tests.cpp	28 Jul 2004 01:57:15 -0000	1.8
+++ libs/spirit/phoenix/test/binary_tests.cpp	18 Feb 2006 22:55:12 -0000
@@ -13,7 +13,7 @@
 #endif
 
 #include <iostream>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 #define PHOENIX_LIMIT 15
 #include <boost/spirit/phoenix/primitives.hpp>
@@ -34,59 +34,59 @@
 //  Binary operators
 //
 ///////////////////////////////////////////////////////////////////////////////
-    assert((var(i) = var(i))() == 5);
-    assert((var(i) = 3)() == 3);
-    assert(i == 3);
+    BOOST_TEST((var(i) = var(i))() == 5);
+    BOOST_TEST((var(i) = 3)() == 3);
+    BOOST_TEST(i == 3);
     i = 5;
     int x, y, z;
     (var(x) = var(y) = var(z) = 10)();
-    assert(x == 10 && y == 10 && z == 10);
-    assert((val(world)[3])() == world[3]);
+    BOOST_TEST(x == 10 && y == 10 && z == 10);
+    BOOST_TEST((val(world)[3])() == world[3]);
 
-    assert((var(i) += 5)() == 10);
-    assert((var(i) -= 5)() == 5);
-    assert((var(i) *= 5)() == 25);
-    assert((var(i) /= 5)() == 5);
-    assert((var(i) %= 2)() == 1);
+    BOOST_TEST((var(i) += 5)() == 10);
+    BOOST_TEST((var(i) -= 5)() == 5);
+    BOOST_TEST((var(i) *= 5)() == 25);
+    BOOST_TEST((var(i) /= 5)() == 5);
+    BOOST_TEST((var(i) %= 2)() == 1);
 
-    assert((var(i) <<= 3)() == 8);
-    assert((var(i) >>= 1)() == 4);
-    assert((var(i) |= 0xFF)() == 0xFF);
-    assert((var(i) &= 0xF0)() == 0xF0);
-    assert((var(i) ^= 0xFFFFFFFF)() == int(0xFFFFFF0F));
+    BOOST_TEST((var(i) <<= 3)() == 8);
+    BOOST_TEST((var(i) >>= 1)() == 4);
+    BOOST_TEST((var(i) |= 0xFF)() == 0xFF);
+    BOOST_TEST((var(i) &= 0xF0)() == 0xF0);
+    BOOST_TEST((var(i) ^= 0xFFFFFFFF)() == int(0xFFFFFF0F));
 
-    assert((val(5) == val(5))());
-    assert((val(5) == 5)());
+    BOOST_TEST((val(5) == val(5))());
+    BOOST_TEST((val(5) == 5)());
 
-    assert((arg1 + arg2)(i2, i3) == i2 + i3);
-    assert((arg1 - arg2)(i2, i3) == i2 - i3);
-    assert((arg1 * arg2)(i2, i3) == i2 * i3);
-    assert((arg1 / arg2)(i2, i3) == i2 / i3);
-    assert((arg1 % arg2)(i2, i3) == i2 % i3);
-    assert((arg1 & arg2)(i2, i3) == i2 & i3);
-    assert((arg1 | arg2)(i2, i3) == i2 | i3);
-    assert((arg1 ^ arg2)(i2, i3) == i2 ^ i3);
-    assert((arg1 << arg2)(i2, i3) == i2 << i3);
-    assert((arg1 >> arg2)(i2, i3) == i2 >> i3);
+    BOOST_TEST((arg1 + arg2)(i2, i3) == i2 + i3);
+    BOOST_TEST((arg1 - arg2)(i2, i3) == i2 - i3);
+    BOOST_TEST((arg1 * arg2)(i2, i3) == i2 * i3);
+    BOOST_TEST((arg1 / arg2)(i2, i3) == i2 / i3);
+    BOOST_TEST((arg1 % arg2)(i2, i3) == i2 % i3);
+    BOOST_TEST((arg1 & arg2)(i2, i3) == i2 & i3);
+    BOOST_TEST((arg1 | arg2)(i2, i3) == i2 | i3);
+    BOOST_TEST((arg1 ^ arg2)(i2, i3) == i2 ^ i3);
+    BOOST_TEST((arg1 << arg2)(i2, i3) == i2 << i3);
+    BOOST_TEST((arg1 >> arg2)(i2, i3) == i2 >> i3);
 
-    assert((val(5) != val(6))());
-    assert((val(5) < val(6))());
-    assert(!(val(5) > val(6))());
-    assert((val(5) < val(6))());
-    assert((val(5) <= val(6))());
-    assert((val(5) <= val(5))());
-    assert((val(7) >= val(6))());
-    assert((val(7) >= val(7))());
+    BOOST_TEST((val(5) != val(6))());
+    BOOST_TEST((val(5) < val(6))());
+    BOOST_TEST(!(val(5) > val(6))());
+    BOOST_TEST((val(5) < val(6))());
+    BOOST_TEST((val(5) <= val(6))());
+    BOOST_TEST((val(5) <= val(5))());
+    BOOST_TEST((val(7) >= val(6))());
+    BOOST_TEST((val(7) >= val(7))());
 
-    assert((val(false) && val(false))() == false);
-    assert((val(true) && val(false))() == false);
-    assert((val(false) && val(true))() == false);
-    assert((val(true) && val(true))() == true);
+    BOOST_TEST((val(false) && val(false))() == false);
+    BOOST_TEST((val(true) && val(false))() == false);
+    BOOST_TEST((val(false) && val(true))() == false);
+    BOOST_TEST((val(true) && val(true))() == true);
 
-    assert((val(false) || val(false))() == false);
-    assert((val(true) || val(false))() == true);
-    assert((val(false) || val(true))() == true);
-    assert((val(true) || val(true))() == true);
+    BOOST_TEST((val(false) || val(false))() == false);
+    BOOST_TEST((val(true) || val(false))() == true);
+    BOOST_TEST((val(false) || val(true))() == true);
+    BOOST_TEST((val(true) || val(true))() == true);
 
 ///////////////////////////////////////////////////////////////////////////////
 //
@@ -94,8 +94,5 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-    cout << "///////////////////////////////////////////////////////////////////////////////\n";
-    cout << "\t\tTests concluded\n";
-    cout << "\t\tSUCCESS!!!\n";
-    cout << "///////////////////////////////////////////////////////////////////////////////\n";
+    return boost::report_errors();
 }
Index: libs/spirit/phoenix/test/binders_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/phoenix/test/binders_tests.cpp,v
retrieving revision 1.8
diff -b -d -u -r1.8 binders_tests.cpp
--- libs/spirit/phoenix/test/binders_tests.cpp	28 Jul 2004 01:57:15 -0000	1.8
+++ libs/spirit/phoenix/test/binders_tests.cpp	18 Feb 2006 22:55:12 -0000
@@ -8,7 +8,7 @@
 ==============================================================================*/
 #include <iostream>
 #include <functional>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 #define PHOENIX_LIMIT 15
 #include <boost/spirit/phoenix/primitives.hpp>
@@ -102,11 +102,11 @@
 //  Member var binders
 
     printer.x = 3;
-    assert(bind(&print_::x)(arg1)(printer) == 3);
-    assert(print_x(arg1)(printer) == 3);
-    assert(print_x(printer)() == 3);
-    assert(0 != (print_x(var(printer))() = 4));
-    assert(printer.x == 4);
+    BOOST_TEST(bind(&print_::x)(arg1)(printer) == 3);
+    BOOST_TEST(print_x(arg1)(printer) == 3);
+    BOOST_TEST(print_x(printer)() == 3);
+    BOOST_TEST(0 != (print_x(var(printer))() = 4));
+    BOOST_TEST(printer.x == 4);
 
 //  Bound member functions
 
@@ -118,8 +118,5 @@
     bound_print_foo2(111, 222)();
     bound_print_foo2(111, arg1)(i100);
 
-    cout << "///////////////////////////////////////////////////////////////////////////////\n";
-    cout << "\t\tTests concluded\n";
-    cout << "\t\tSUCCESS!!!\n";
-    cout << "///////////////////////////////////////////////////////////////////////////////\n";
+    return boost::report_errors();
 }
Index: libs/spirit/phoenix/test/functors_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/phoenix/test/functors_tests.cpp,v
retrieving revision 1.8
diff -b -d -u -r1.8 functors_tests.cpp
--- libs/spirit/phoenix/test/functors_tests.cpp	28 Jul 2004 01:57:15 -0000	1.8
+++ libs/spirit/phoenix/test/functors_tests.cpp	18 Feb 2006 22:55:12 -0000
@@ -8,7 +8,7 @@
 ==============================================================================*/
 #include <iostream>
 #include <cmath>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 #define PHOENIX_LIMIT 15
 #include <boost/spirit/phoenix/primitives.hpp>
@@ -79,11 +79,11 @@
 ///////////////////////////////////////////////////////////////////////////////
 
     test()();
-    assert(sqr(arg1)(i5) == (i5*i5));
-    assert(fact(4)() == 24);
-    assert(fact(arg1)(i5) == 120);    
-    assert((int)power(arg1, arg2)(d5, d3) == (int)pow(d5, d3));
-    assert((sqr(arg1) + 5)(i5) == ((i5*i5)+5));
+    BOOST_TEST(sqr(arg1)(i5) == (i5*i5));
+    BOOST_TEST(fact(4)() == 24);
+    BOOST_TEST(fact(arg1)(i5) == 120);    
+    BOOST_TEST((int)power(arg1, arg2)(d5, d3) == (int)pow(d5, d3));
+    BOOST_TEST((sqr(arg1) + 5)(i5) == ((i5*i5)+5));
 
 ///////////////////////////////////////////////////////////////////////////////
 //
@@ -91,8 +91,5 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-    cout << "///////////////////////////////////////////////////////////////////////////////\n";
-    cout << "\t\tTests concluded\n";
-    cout << "\t\tSUCCESS!!!\n";
-    cout << "///////////////////////////////////////////////////////////////////////////////\n";
+    return boost::report_errors();
 }
Index: libs/spirit/phoenix/test/iostream_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/phoenix/test/iostream_tests.cpp,v
retrieving revision 1.8
diff -b -d -u -r1.8 iostream_tests.cpp
--- libs/spirit/phoenix/test/iostream_tests.cpp	28 Jul 2004 01:57:15 -0000	1.8
+++ libs/spirit/phoenix/test/iostream_tests.cpp	18 Feb 2006 22:55:12 -0000
@@ -10,7 +10,7 @@
 #include <vector>
 #include <algorithm>
 #include <string>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 #include <boost/config.hpp>
 #ifdef BOOST_NO_STRINGSTREAM
@@ -74,7 +74,7 @@
     SSTREAM sstr;
     (sstr << arg1)(out);
     (sstr >> arg1)(in);
-    assert(in == out);
+    BOOST_TEST(in == out);
 
 ///////////////////////////////////////////////////////////////////////////////
 //
@@ -82,8 +82,5 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-    cout << "///////////////////////////////////////////////////////////////////////////////\n";
-    cout << "\t\tTests concluded\n";
-    cout << "\t\tSUCCESS!!!\n";
-    cout << "///////////////////////////////////////////////////////////////////////////////\n";
+    return boost::report_errors();    
 }
Index: libs/spirit/phoenix/test/mixed_binary_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/phoenix/test/mixed_binary_tests.cpp,v
retrieving revision 1.8
diff -b -d -u -r1.8 mixed_binary_tests.cpp
--- libs/spirit/phoenix/test/mixed_binary_tests.cpp	28 Jul 2004 01:57:15 -0000	1.8
+++ libs/spirit/phoenix/test/mixed_binary_tests.cpp	18 Feb 2006 22:55:12 -0000
@@ -8,7 +8,7 @@
 ==============================================================================*/
 #include <iostream>
 #include <string>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 #define PHOENIX_LIMIT 15
 #include <boost/spirit/phoenix/primitives.hpp>
@@ -31,14 +31,14 @@
 //  Mixed type operators
 //
 ///////////////////////////////////////////////////////////////////////////////
-    assert((arg1 + arg2)(i100, i50) == (i100 + i50));
-    assert((arg1 + 3)(i100) == (3 + i100));
-    assert((arg1 + arg2)(hello, world) == "hello world");
-    assert((arg1 + arg2)(i1, d2_5) == (i1 + d2_5));
+    BOOST_TEST((arg1 + arg2)(i100, i50) == (i100 + i50));
+    BOOST_TEST((arg1 + 3)(i100) == (3 + i100));
+    BOOST_TEST((arg1 + arg2)(hello, world) == "hello world");
+    BOOST_TEST((arg1 + arg2)(i1, d2_5) == (i1 + d2_5));
 
-    assert((*(arg1 + arg2))(world, i2) == *(world + i2));
-    assert((*(arg1 + arg2))(i2, world) == *(i2 + world));
-    assert((*(val(world+i2) - arg1))(i2) == *world);
+    BOOST_TEST((*(arg1 + arg2))(world, i2) == *(world + i2));
+    BOOST_TEST((*(arg1 + arg2))(i2, world) == *(i2 + world));
+    BOOST_TEST((*(val(world+i2) - arg1))(i2) == *world);
 
 ///////////////////////////////////////////////////////////////////////////////
 //
@@ -46,8 +46,5 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-    cout << "///////////////////////////////////////////////////////////////////////////////\n";
-    cout << "\t\tTests concluded\n";
-    cout << "\t\tSUCCESS!!!\n";
-    cout << "///////////////////////////////////////////////////////////////////////////////\n";
+    return boost::report_errors();    
 }
Index: libs/spirit/phoenix/test/more_expressions_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/phoenix/test/more_expressions_tests.cpp,v
retrieving revision 1.8
diff -b -d -u -r1.8 more_expressions_tests.cpp
--- libs/spirit/phoenix/test/more_expressions_tests.cpp	28 Jul 2004 01:57:15 -0000	1.8
+++ libs/spirit/phoenix/test/more_expressions_tests.cpp	18 Feb 2006 22:55:12 -0000
@@ -7,7 +7,7 @@
     http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 #include <iostream>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 #define PHOENIX_LIMIT 15
 #include <boost/spirit/phoenix/primitives.hpp>
@@ -55,18 +55,18 @@
 //  More complex expressions
 //
 ///////////////////////////////////////////////////////////////////////////////
-    assert((10 - arg1)(i100) == (10 - i100));
-    assert((20 - arg1)(i100) == (20 - i100));
-    assert((arg1 - 10)(i100) == (i100 - 10));
-    assert((arg1 - 20)(i100) == (i100 - 20));
-    assert((arg1 - arg2)(i100, i50) == (i100 - i50));
-    assert((arg1 - var(i))(i10) == (i10 - i));
-    assert((arg1 + arg2 - arg3)(i100, i50, i20) == (i100 + i50 - i20));
-    assert((sqr(arg1) + arg2 - arg3)(i100, i50, i20) == ((i100*i100) + i50 - i20));
+    BOOST_TEST((10 - arg1)(i100) == (10 - i100));
+    BOOST_TEST((20 - arg1)(i100) == (20 - i100));
+    BOOST_TEST((arg1 - 10)(i100) == (i100 - 10));
+    BOOST_TEST((arg1 - 20)(i100) == (i100 - 20));
+    BOOST_TEST((arg1 - arg2)(i100, i50) == (i100 - i50));
+    BOOST_TEST((arg1 - var(i))(i10) == (i10 - i));
+    BOOST_TEST((arg1 + arg2 - arg3)(i100, i50, i20) == (i100 + i50 - i20));
+    BOOST_TEST((sqr(arg1) + arg2 - arg3)(i100, i50, i20) == ((i100*i100) + i50 - i20));
 
     int ii = i;
-    assert((var(i) += arg1)(i2) == (ii += i2));
-    assert((sqr(sqr(arg1)))(i100) == (i100*i100*i100*i100));
+    BOOST_TEST((var(i) += arg1)(i2) == (ii += i2));
+    BOOST_TEST((sqr(sqr(arg1)))(i100) == (i100*i100*i100*i100));
 
 
 #if 0   /*** SHOULD NOT COMPILE ***/
@@ -74,15 +74,15 @@
     (val(3) = 3)();
 #endif
 
-    assert(((adder(arg1, arg2, arg3) + arg2 - arg3)(i100, i50, i20)) == (i100 + i50 + i20) + i50 - i20);
-    assert((adder(arg1, arg2, arg3)(i100, i50, i20)) == (i100 + i50 + i20));
-    assert((sqr(sqr(sqr(sqr(arg1)))))(d10) == 1e16);
-    assert((sqr(sqr(arg1)) / arg1 / arg1)(d5) == 25);
+    BOOST_TEST(((adder(arg1, arg2, arg3) + arg2 - arg3)(i100, i50, i20)) == (i100 + i50 + i20) + i50 - i20);
+    BOOST_TEST((adder(arg1, arg2, arg3)(i100, i50, i20)) == (i100 + i50 + i20));
+    BOOST_TEST((sqr(sqr(sqr(sqr(arg1)))))(d10) == 1e16);
+    BOOST_TEST((sqr(sqr(arg1)) / arg1 / arg1)(d5) == 25);
 
     for (int j = 0; j < 20; ++j)
     {
         cout << (10 < arg1)(j);
-        assert((10 < arg1)(j) == (10 < j));
+        BOOST_TEST((10 < arg1)(j) == (10 < j));
     }
     cout << endl;
 
@@ -90,7 +90,7 @@
     {
         bool r = ((arg1 % 2 == 0) && (arg1 < 15))(k);
         cout << r;
-        assert(r == ((k % 2 == 0) && (k < 15)));
+        BOOST_TEST(r == ((k % 2 == 0) && (k < 15)));
     }
     cout << endl;
 
@@ -100,8 +100,5 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-    cout << "///////////////////////////////////////////////////////////////////////////////\n";
-    cout << "\t\tTests concluded\n";
-    cout << "\t\tSUCCESS!!!\n";
-    cout << "///////////////////////////////////////////////////////////////////////////////\n";
+    return boost::report_errors();    
 }
Index: libs/spirit/phoenix/test/new_test.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/phoenix/test/new_test.cpp,v
retrieving revision 1.6
diff -b -d -u -r1.6 new_test.cpp
--- libs/spirit/phoenix/test/new_test.cpp	28 Jul 2004 01:57:15 -0000	1.6
+++ libs/spirit/phoenix/test/new_test.cpp	18 Feb 2006 22:55:12 -0000
@@ -8,7 +8,7 @@
     http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 #include <iostream>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 #define PHOENIX_LIMIT 15
 #include <boost/spirit/phoenix/primitives.hpp>
@@ -34,16 +34,13 @@
     int i2 = 2;
     X   x3(3);
 
-    assert(new_<int>()() != NULL);
-    assert(*new_<int>(arg1)(i2) == 2);
+    BOOST_TEST(new_<int>()() != NULL);
+    BOOST_TEST(*new_<int>(arg1)(i2) == 2);
 
-    assert(new_<X>()() != NULL);
-    assert(new_<X>()()->i == 1);
-    assert(new_<X>(arg1)(i2)->i == 2);
-    assert(new_<X>(arg1)(x3)->i == 3);
+    BOOST_TEST(new_<X>()() != NULL);
+    BOOST_TEST(new_<X>()()->i == 1);
+    BOOST_TEST(new_<X>(arg1)(i2)->i == 2);
+    BOOST_TEST(new_<X>(arg1)(x3)->i == 3);
 
-    cout << "///////////////////////////////////////////////////////////////////////////////\n";
-    cout << "\t\tTests concluded\n";
-    cout << "\t\tSUCCESS!!!\n";
-    cout << "///////////////////////////////////////////////////////////////////////////////\n";
+    return boost::report_errors();    
 }
Index: libs/spirit/phoenix/test/primitives_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/phoenix/test/primitives_tests.cpp,v
retrieving revision 1.8
diff -b -d -u -r1.8 primitives_tests.cpp
--- libs/spirit/phoenix/test/primitives_tests.cpp	28 Jul 2004 01:57:15 -0000	1.8
+++ libs/spirit/phoenix/test/primitives_tests.cpp	18 Feb 2006 22:55:12 -0000
@@ -7,7 +7,7 @@
     http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 #include <iostream>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 #define PHOENIX_LIMIT 15
 #include <boost/spirit/phoenix/primitives.hpp>
@@ -30,16 +30,13 @@
 ///////////////////////////////////////////////////////////////////////////////
     cout << val("Hello")() << val(' ')() << val("World")() << endl;
 
-    assert(arg1(c1) == c1);
-    assert(arg1(i1, i2) == i1);
-    assert(arg2(i1, s2) == s2);
+    BOOST_TEST(arg1(c1) == c1);
+    BOOST_TEST(arg1(i1, i2) == i1);
+    BOOST_TEST(arg2(i1, s2) == s2);
 
-    assert(val(3)() == 3);
-    assert(var(i)() == 4);
-    assert(var(++i)() == 5);
+    BOOST_TEST(val(3)() == 3);
+    BOOST_TEST(var(i)() == 4);
+    BOOST_TEST(var(++i)() == 5);
 
-    cout << "///////////////////////////////////////////////////////////////////////////////\n";
-    cout << "\t\tTests concluded\n";
-    cout << "\t\tSUCCESS!!!\n";
-    cout << "///////////////////////////////////////////////////////////////////////////////\n";
+    return boost::report_errors();    
 }
Index: libs/spirit/phoenix/test/statements_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/phoenix/test/statements_tests.cpp,v
retrieving revision 1.8
diff -b -d -u -r1.8 statements_tests.cpp
--- libs/spirit/phoenix/test/statements_tests.cpp	28 Jul 2004 01:57:15 -0000	1.8
+++ libs/spirit/phoenix/test/statements_tests.cpp	18 Feb 2006 22:55:12 -0000
@@ -9,7 +9,7 @@
 #include <iostream>
 #include <vector>
 #include <algorithm>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 #define PHOENIX_LIMIT 15
 #include <boost/spirit/phoenix/primitives.hpp>
@@ -161,8 +161,5 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-    cout << "///////////////////////////////////////////////////////////////////////////////\n";
-    cout << "\t\tTests concluded\n";
-    cout << "\t\tSUCCESS!!!\n";
-    cout << "///////////////////////////////////////////////////////////////////////////////\n";
+    return boost::report_errors();    
 }
Index: libs/spirit/phoenix/test/stl_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/phoenix/test/stl_tests.cpp,v
retrieving revision 1.8
diff -b -d -u -r1.8 stl_tests.cpp
--- libs/spirit/phoenix/test/stl_tests.cpp	28 Jul 2004 01:57:15 -0000	1.8
+++ libs/spirit/phoenix/test/stl_tests.cpp	18 Feb 2006 22:55:12 -0000
@@ -10,7 +10,7 @@
 #include <vector>
 #include <list>
 #include <algorithm>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 #define PHOENIX_LIMIT 15
 #include <boost/spirit/phoenix/primitives.hpp>
@@ -53,7 +53,7 @@
     for (int m = 0; m < 5; ++m, (cout << ','))
     {
         cout << v[m];
-        assert(v[m] == (m+1)*2);
+        BOOST_TEST(v[m] == (m+1)*2);
     }
     cout << endl;
 
@@ -69,8 +69,8 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-    assert((arg1[0])(v) == v[0]);
-    assert((arg1[1])(v) == v[1]);
+    BOOST_TEST((arg1[0])(v) == v[0]);
+    BOOST_TEST((arg1[1])(v) == v[1]);
 
     list<int> l;
     l.push_back(1);
@@ -82,8 +82,8 @@
     list<int>::iterator first = l.begin();
     list<int>::iterator last = l.end();
 
-    assert((*(++arg1))(first) == 2);
-    assert((*(----arg1))(last) == 4);
+    BOOST_TEST((*(++arg1))(first) == 2);
+    BOOST_TEST((*(----arg1))(last) == 4);
 
 ///////////////////////////////////////////////////////////////////////////////
 //
@@ -91,8 +91,5 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-    cout << "///////////////////////////////////////////////////////////////////////////////\n";
-    cout << "\t\tTests concluded\n";
-    cout << "\t\tSUCCESS!!!\n";
-    cout << "///////////////////////////////////////////////////////////////////////////////\n";
+    return boost::report_errors();    
 }
Index: libs/spirit/phoenix/test/tuples_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/phoenix/test/tuples_tests.cpp,v
retrieving revision 1.8
diff -b -d -u -r1.8 tuples_tests.cpp
--- libs/spirit/phoenix/test/tuples_tests.cpp	28 Jul 2004 01:57:15 -0000	1.8
+++ libs/spirit/phoenix/test/tuples_tests.cpp	18 Feb 2006 22:55:12 -0000
@@ -8,7 +8,7 @@
 ==============================================================================*/
 #include <iostream>
 #include <string>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 #include <boost/spirit/phoenix/tuples.hpp>
 
 using namespace std;
@@ -26,8 +26,8 @@
         tuple_element<0, tuple_t>::type& e0 = ttt[_1];
         tuple_element<1, tuple_t>::type& e1 = ttt[_2];
 
-        assert(e0 == 3);
-        assert(e1 == 'c');
+        BOOST_TEST(e0 == 3);
+        BOOST_TEST(e1 == 'c');
 
         cout << e0 << endl;
         cout << e1 << endl;
@@ -42,15 +42,15 @@
         tuple_element<1, tuple_t>::type& e1 = ttt[_2];
         tuple_element<2, tuple_t>::type& e2 = ttt[_3];
 
-        assert(e0 == 3);
-        assert(e1 == 'c');
-        assert(string(e2) == "hello world");
+        BOOST_TEST(e0 == 3);
+        BOOST_TEST(e1 == 'c');
+        BOOST_TEST(string(e2) == "hello world");
 
         cout << e0 << endl;
         cout << e1 << endl;
         cout << e2 << endl;
     }
 
-    return 0;
+    return boost::report_errors();    
 }
 
Index: libs/spirit/phoenix/test/unary_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/phoenix/test/unary_tests.cpp,v
retrieving revision 1.8
diff -b -d -u -r1.8 unary_tests.cpp
--- libs/spirit/phoenix/test/unary_tests.cpp	28 Jul 2004 01:57:15 -0000	1.8
+++ libs/spirit/phoenix/test/unary_tests.cpp	18 Feb 2006 22:55:12 -0000
@@ -7,7 +7,7 @@
     http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 #include <iostream>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 #define PHOENIX_LIMIT 15
 #include <boost/spirit/phoenix/primitives.hpp>
@@ -27,24 +27,21 @@
 //  Unary operators
 //
 ///////////////////////////////////////////////////////////////////////////////
-    assert((!val(true))() == false);
-    assert((-val(1))() == -1);
-    assert((+val(1))() == +1);
-    assert((~val(1))() == ~1);
-    assert(*(&arg1)(i1) == *(&i1));
-    assert((&arg1)(i1) == &i1);
+    BOOST_TEST((!val(true))() == false);
+    BOOST_TEST((-val(1))() == -1);
+    BOOST_TEST((+val(1))() == +1);
+    BOOST_TEST((~val(1))() == ~1);
+    BOOST_TEST(*(&arg1)(i1) == *(&i1));
+    BOOST_TEST((&arg1)(i1) == &i1);
 
-    assert((*val(&i1))() == *(&i1));
-    assert((*&arg1)(i1) == *(&i1));
-    assert((++var(i))() == 6);
-    assert((--var(i))() == 5);
-    assert((var(i)++)() == 5);
-    assert(i == 6);
-    assert((var(i)--)() == 6);
-    assert(i == 5);
+    BOOST_TEST((*val(&i1))() == *(&i1));
+    BOOST_TEST((*&arg1)(i1) == *(&i1));
+    BOOST_TEST((++var(i))() == 6);
+    BOOST_TEST((--var(i))() == 5);
+    BOOST_TEST((var(i)++)() == 5);
+    BOOST_TEST(i == 6);
+    BOOST_TEST((var(i)--)() == 6);
+    BOOST_TEST(i == 5);
 
-    cout << "///////////////////////////////////////////////////////////////////////////////\n";
-    cout << "\t\tTests concluded\n";
-    cout << "\t\tSUCCESS!!!\n";
-    cout << "///////////////////////////////////////////////////////////////////////////////\n";
+    return boost::report_errors();    
 }
Index: libs/spirit/test/ast_calc_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/ast_calc_tests.cpp,v
retrieving revision 1.5
diff -b -d -u -r1.5 ast_calc_tests.cpp
--- libs/spirit/test/ast_calc_tests.cpp	9 Jul 2004 08:30:38 -0000	1.5
+++ libs/spirit/test/ast_calc_tests.cpp	18 Feb 2006 22:55:12 -0000
@@ -17,7 +17,7 @@
 #include <stack>
 #include <functional>
 #include <string>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace boost::spirit;
 
@@ -143,7 +143,7 @@
     {
         case calculator::integerID:
         {
-            assert(i->children.size() == 0);
+            BOOST_TEST(i->children.size() == 0);
             // extract integer (not always delimited by '\0')
 #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
             // std::string(iter,iter) constructor has a bug in MWCW 8.3: 
@@ -162,7 +162,7 @@
         case calculator::factorID:
         {
             // factor can only be unary minus
-            assert(*i->value.begin() == '-');
+            BOOST_TEST(*i->value.begin() == '-');
             return - eval_expression(i->children.begin());
         }
 
@@ -170,40 +170,40 @@
         {
             if (*i->value.begin() == '*')
             {
-                assert(i->children.size() == 2);
+                BOOST_TEST(i->children.size() == 2);
                 return eval_expression(i->children.begin()) *
                     eval_expression(i->children.begin()+1);
             }
             else if (*i->value.begin() == '/')
             {
-                assert(i->children.size() == 2);
+                BOOST_TEST(i->children.size() == 2);
                 return eval_expression(i->children.begin()) /
                     eval_expression(i->children.begin()+1);
             }
             else
-                assert(0);
+                BOOST_TEST(0);
         }
 
         case calculator::expressionID:
         {
             if (*i->value.begin() == '+')
             {
-                assert(i->children.size() == 2);
+                BOOST_TEST(i->children.size() == 2);
                 return eval_expression(i->children.begin()) +
                     eval_expression(i->children.begin()+1);
             }
             else if (*i->value.begin() == '-')
             {
-                assert(i->children.size() == 2);
+                BOOST_TEST(i->children.size() == 2);
                 return eval_expression(i->children.begin()) -
                     eval_expression(i->children.begin()+1);
             }
             else
-                assert(0);
+                BOOST_TEST(0);
         }
 
         default:
-            assert(0); // error
+            BOOST_TEST(0); // error
     }
 
     return 0;
@@ -238,41 +238,40 @@
 main()
 {
 // test the calculator with statically assigned rule ID's
-    assert(parse("12345") == 12345);
-    assert(parse("-12345") == -12345);
-    assert(parse("1 + 2") == 1 + 2);
-    assert(parse("1 * 2") == 1 * 2);
-    assert(parse("1/2 + 3/4") == 1/2 + 3/4);
-    assert(parse("1 + 2 + 3 + 4") == 1 + 2 + 3 + 4);
-    assert(parse("1 * 2 * 3 * 4") == 1 * 2 * 3 * 4);
-    assert(parse("(1 + 2) * (3 + 4)") == (1 + 2) * (3 + 4));
-    assert(parse("(-1 + 2) * (3 + -4)") == (-1 + 2) * (3 + -4));
-    assert(parse("1 + ((6 * 200) - 20) / 6") == 1 + ((6 * 200) - 20) / 6);
-    assert(parse("(1 + (2 + (3 + (4 + 5))))") == (1 + (2 + (3 + (4 + 5)))));
-    assert(parse("1 + 2 + 3 + 4 + 5") == 1 + 2 + 3 + 4 + 5);
-    assert(parse("(12 * 22) + (36 + -4 + 5)") == (12 * 22) + (36 + -4 + 5));
-    assert(parse("(12 * 22) / (5 - 10 + 15)") == (12 * 22) / (5 - 10 + 15));
-    assert(parse("12 * 6 * 15 + 5 - 25") == 12 * 6 * 15 + 5 - 25);
+    BOOST_TEST(parse("12345") == 12345);
+    BOOST_TEST(parse("-12345") == -12345);
+    BOOST_TEST(parse("1 + 2") == 1 + 2);
+    BOOST_TEST(parse("1 * 2") == 1 * 2);
+    BOOST_TEST(parse("1/2 + 3/4") == 1/2 + 3/4);
+    BOOST_TEST(parse("1 + 2 + 3 + 4") == 1 + 2 + 3 + 4);
+    BOOST_TEST(parse("1 * 2 * 3 * 4") == 1 * 2 * 3 * 4);
+    BOOST_TEST(parse("(1 + 2) * (3 + 4)") == (1 + 2) * (3 + 4));
+    BOOST_TEST(parse("(-1 + 2) * (3 + -4)") == (-1 + 2) * (3 + -4));
+    BOOST_TEST(parse("1 + ((6 * 200) - 20) / 6") == 1 + ((6 * 200) - 20) / 6);
+    BOOST_TEST(parse("(1 + (2 + (3 + (4 + 5))))") == (1 + (2 + (3 + (4 + 5)))));
+    BOOST_TEST(parse("1 + 2 + 3 + 4 + 5") == 1 + 2 + 3 + 4 + 5);
+    BOOST_TEST(parse("(12 * 22) + (36 + -4 + 5)") == (12 * 22) + (36 + -4 + 5));
+    BOOST_TEST(parse("(12 * 22) / (5 - 10 + 15)") == (12 * 22) / (5 - 10 + 15));
+    BOOST_TEST(parse("12 * 6 * 15 + 5 - 25") == 12 * 6 * 15 + 5 - 25);
 
 // test the calculator with dynamically assigned rule ID's
-    assert(parse_dyn("12345") == 12345);
-    assert(parse_dyn("-12345") == -12345);
-    assert(parse_dyn("1 + 2") == 1 + 2);
-    assert(parse_dyn("1 * 2") == 1 * 2);
-    assert(parse_dyn("1/2 + 3/4") == 1/2 + 3/4);
-    assert(parse_dyn("1 + 2 + 3 + 4") == 1 + 2 + 3 + 4);
-    assert(parse_dyn("1 * 2 * 3 * 4") == 1 * 2 * 3 * 4);
-    assert(parse_dyn("(1 + 2) * (3 + 4)") == (1 + 2) * (3 + 4));
-    assert(parse_dyn("(-1 + 2) * (3 + -4)") == (-1 + 2) * (3 + -4));
-    assert(parse_dyn("1 + ((6 * 200) - 20) / 6") == 1 + ((6 * 200) - 20) / 6);
-    assert(parse_dyn("(1 + (2 + (3 + (4 + 5))))") == (1 + (2 + (3 + (4 + 5)))));
-    assert(parse_dyn("1 + 2 + 3 + 4 + 5") == 1 + 2 + 3 + 4 + 5);
-    assert(parse_dyn("(12 * 22) + (36 + -4 + 5)") == (12 * 22) + (36 + -4 + 5));
-    assert(parse_dyn("(12 * 22) / (5 - 10 + 15)") == (12 * 22) / (5 - 10 + 15));
-    assert(parse_dyn("12 * 6 * 15 + 5 - 25") == 12 * 6 * 15 + 5 - 25);
+    BOOST_TEST(parse_dyn("12345") == 12345);
+    BOOST_TEST(parse_dyn("-12345") == -12345);
+    BOOST_TEST(parse_dyn("1 + 2") == 1 + 2);
+    BOOST_TEST(parse_dyn("1 * 2") == 1 * 2);
+    BOOST_TEST(parse_dyn("1/2 + 3/4") == 1/2 + 3/4);
+    BOOST_TEST(parse_dyn("1 + 2 + 3 + 4") == 1 + 2 + 3 + 4);
+    BOOST_TEST(parse_dyn("1 * 2 * 3 * 4") == 1 * 2 * 3 * 4);
+    BOOST_TEST(parse_dyn("(1 + 2) * (3 + 4)") == (1 + 2) * (3 + 4));
+    BOOST_TEST(parse_dyn("(-1 + 2) * (3 + -4)") == (-1 + 2) * (3 + -4));
+    BOOST_TEST(parse_dyn("1 + ((6 * 200) - 20) / 6") == 1 + ((6 * 200) - 20) / 6);
+    BOOST_TEST(parse_dyn("(1 + (2 + (3 + (4 + 5))))") == (1 + (2 + (3 + (4 + 5)))));
+    BOOST_TEST(parse_dyn("1 + 2 + 3 + 4 + 5") == 1 + 2 + 3 + 4 + 5);
+    BOOST_TEST(parse_dyn("(12 * 22) + (36 + -4 + 5)") == (12 * 22) + (36 + -4 + 5));
+    BOOST_TEST(parse_dyn("(12 * 22) / (5 - 10 + 15)") == (12 * 22) / (5 - 10 + 15));
+    BOOST_TEST(parse_dyn("12 * 6 * 15 + 5 - 25") == 12 * 6 * 15 + 5 - 25);
 
-    cout << "SUCCESS!!!\n";
-    return 0;
+    return boost::report_errors();    
 }
 
 
Index: libs/spirit/test/bug_fixes.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/bug_fixes.cpp,v
retrieving revision 1.11
diff -b -d -u -r1.11 bug_fixes.cpp
--- libs/spirit/test/bug_fixes.cpp	18 Oct 2005 10:00:15 -0000	1.11
+++ libs/spirit/test/bug_fixes.cpp	18 Feb 2006 22:55:12 -0000
@@ -261,7 +261,7 @@
 #include <string>
 #include <fstream>
 #include <iostream>
-#include <assert.h>
+#include <boost/detail/lightweight_test.hpp>
 #include <stdio.h>
 
 template <typename IterT>
Index: libs/spirit/test/chset_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/chset_tests.cpp,v
retrieving revision 1.9
diff -b -d -u -r1.9 chset_tests.cpp
--- libs/spirit/test/chset_tests.cpp	31 Jul 2004 11:35:26 -0000	1.9
+++ libs/spirit/test/chset_tests.cpp	18 Feb 2006 22:55:12 -0000
@@ -9,7 +9,7 @@
     http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
 #include <iostream>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include "impl/sstream.hpp"
 
Index: libs/spirit/test/closure_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/closure_tests.cpp,v
retrieving revision 1.9
diff -b -d -u -r1.9 closure_tests.cpp
--- libs/spirit/test/closure_tests.cpp	9 Jul 2004 08:30:38 -0000	1.9
+++ libs/spirit/test/closure_tests.cpp	18 Feb 2006 22:55:12 -0000
@@ -7,7 +7,7 @@
     http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
 #include <iostream>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace std;
 
@@ -97,32 +97,32 @@
 
     parse_info<char const*> pi;
     pi = parse("123, 456, 789", num_list, space_p);
-    assert(pi.hit);
-    assert(pi.full);
-    assert(n == 123 + 456 + 789);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
+    BOOST_TEST(n == 123 + 456 + 789);
 
     rule<scanner<>, my_closure2::context_t> rev;
     rev = anychar_p[rev.ch = arg1] >> !rev >> f_ch_p(rev.ch);
 
     pi = parse("xyzzyx", rev);
-    assert(pi.hit);
-    assert(pi.full);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
 
     pi = parse("xyzczyx", rev);
-    assert(!pi.hit);
+    BOOST_TEST(!pi.hit);
 
     subrule<0, my_closure3::context_t> rev2;
     pi = parse("atoyyota",
         rev2 = anychar_p[rev2.ch = arg1] >> !rev2 >> f_ch_p(rev2.ch)
     );
 
-    assert(pi.hit);
-    assert(pi.full);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
 
     pi = parse("whatdahell",
         rev2 = anychar_p[rev2.ch = arg1] >> !rev2 >> f_ch_p(rev2.ch)
     );
-    assert(!pi.hit);
+    BOOST_TEST(!pi.hit);
 
     rule<phrase_scanner_t, my_closure4::context_t> complex_p;
     complex_p =
@@ -133,9 +133,9 @@
 
     X x;
     pi = parse("123, 456", complex_p[var(x) = arg1], space_p);
-    assert(pi.hit);
-    assert(x.a == 123);
-    assert(x.b == 456);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(x.a == 123);
+    BOOST_TEST(x.b == 456);
 
     rule<scanner<>, my_closure5::context_t> init1; // compile check only
     rule<> r1 = init1(3, 3); // member2 is constructed from int
@@ -153,7 +153,6 @@
 main()
 {
     closure_tests();
-    cout << "Tests concluded successfully\n";
-    return 0;
+    return boost::report_errors();
 }
 
Index: libs/spirit/test/directives_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/directives_tests.cpp,v
retrieving revision 1.12
diff -b -d -u -r1.12 directives_tests.cpp
--- libs/spirit/test/directives_tests.cpp	18 Aug 2004 10:03:07 -0000	1.12
+++ libs/spirit/test/directives_tests.cpp	18 Feb 2006 22:55:12 -0000
@@ -7,7 +7,7 @@
     http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
 #include <iostream>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 #include <string>
 
 using namespace std;
@@ -35,11 +35,11 @@
         scanx(cpx_first, cpx_last);
 
     hit = str_p("Hello").parse(scanx);
-    assert(!hit);
+    BOOST_TEST(!hit);
     scanx.first = cpx;
 
     hit = chseq_p("Hello").parse(scanx);
-    assert(!!hit);
+    BOOST_TEST(!!hit);
     scanx.first = cpx;
 
     char const* cp = "Hello \n\tWorld";
@@ -50,33 +50,33 @@
         scan(cp_first, cp_last);
 
     hit = (+(alpha_p | punct_p)).parse(scan);
-    assert(!!hit);
-    assert(scan.first == scan.last);
+    BOOST_TEST(!!hit);
+    BOOST_TEST(scan.first == scan.last);
     scan.first = cp;
 
     hit = (+(lexeme_d[+(alpha_p | '\'')])).parse(scan);
-    assert(!!hit);
-    assert(scan.first == scan.last);
+    BOOST_TEST(!!hit);
+    BOOST_TEST(scan.first == scan.last);
     scan.first = cp;
 
     hit = (+(lexeme_d[lexeme_d[+anychar_p]])).parse(scan);
-    assert(!!hit);
-    assert(scan.first == scan.last);
+    BOOST_TEST(!!hit);
+    BOOST_TEST(scan.first == scan.last);
     scan.first = cp;
 
     hit = (str_p("Hello") >> "World").parse(scan);
-    assert(!!hit);
-    assert(scan.first == scan.last);
+    BOOST_TEST(!!hit);
+    BOOST_TEST(scan.first == scan.last);
     scan.first = cp;
 
     hit = as_lower_d[str_p("hello") >> "world"].parse(scan);
-    assert(!!hit);
-    assert(scan.first == scan.last);
+    BOOST_TEST(!!hit);
+    BOOST_TEST(scan.first == scan.last);
     scan.first = cp;
 
     hit = (+(as_lower_d[as_lower_d[+lower_p | '\'']])).parse(scan);
-    assert(!!hit);
-    assert(scan.first == scan.last);
+    BOOST_TEST(!!hit);
+    BOOST_TEST(scan.first == scan.last);
     scan.first = cp;
 
     char const* cpy = "123.456";
@@ -85,13 +85,13 @@
 
     scanner<> scany(cpy_first, cpy_last);
     hit = longest_d[(+digit_p >> '.' >> +digit_p) | (+digit_p)].parse(scany);
-    assert(!!hit);
-    assert(scany.first == scany.last);
+    BOOST_TEST(!!hit);
+    BOOST_TEST(scany.first == scany.last);
     scany.first = cpy;
 
     hit = shortest_d[(+digit_p >> '.' >> +digit_p) | (+digit_p)].parse(scany);
-    assert(!!hit);
-    assert(scany.first != scany.last);
+    BOOST_TEST(!!hit);
+    BOOST_TEST(scany.first != scany.last);
     scany.first = cpy;
 
     char const* cpz = "razamanaz";
@@ -100,40 +100,40 @@
 
     scanner<> scanz(cpz_first, cpz_last);
     hit = longest_d[str_p("raza") | "razaman" | "razamanaz"].parse(scanz);
-    assert(!!hit);
-    assert(scanz.first == scanz.last);
+    BOOST_TEST(!!hit);
+    BOOST_TEST(scanz.first == scanz.last);
     scanz.first = cpz;
 
     hit = shortest_d[str_p("raza") | "razaman" | "razamanaz"].parse(scanz);
-    assert(!!hit);
-    assert(scanz.first == cpz+4);
+    BOOST_TEST(!!hit);
+    BOOST_TEST(scanz.first == cpz+4);
     scanz.first = cpz;
 
 //  bounds_d
 
     parse_info<> pr = parse("123", limit_d(0, 60)[int_p]);
-    assert(!pr.hit);
+    BOOST_TEST(!pr.hit);
 
     pr = parse("-2", limit_d(0, 60)[int_p]);
-    assert(!pr.hit);
+    BOOST_TEST(!pr.hit);
 
     pr = parse("60", limit_d(0, 60)[int_p]);
-    assert(pr.hit);
+    BOOST_TEST(pr.hit);
 
     pr = parse("0", limit_d(0, 60)[int_p]);
-    assert(pr.hit);
+    BOOST_TEST(pr.hit);
 
     pr = parse("-2", min_limit_d(0)[int_p]);
-    assert(!pr.hit);
+    BOOST_TEST(!pr.hit);
 
     pr = parse("-2", min_limit_d(-5)[int_p]);
-    assert(pr.hit);
+    BOOST_TEST(pr.hit);
 
     pr = parse("101", max_limit_d(100)[int_p]);
-    assert(!pr.hit);
+    BOOST_TEST(!pr.hit);
 
     pr = parse("100", max_limit_d(100)[int_p]);
-    assert(pr.hit);
+    BOOST_TEST(pr.hit);
 }
 
 struct identifier : public grammar<identifier>
@@ -171,8 +171,8 @@
     cout << '*' << str1 << ',' << str2 << '*' << endl;
 
 
-    assert(str1 == "rock_n_roll");
-    assert(str2 == "never_dies");
+    BOOST_TEST(str1 == "rock_n_roll");
+    BOOST_TEST(str2 == "never_dies");
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -185,7 +185,6 @@
 {
     directives_test1();
     directives_test2();
-    cout << "Tests concluded successfully\n";
-    return 0;
+    return boost::report_errors();
 }
 
Index: libs/spirit/test/epsilon_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/epsilon_tests.cpp,v
retrieving revision 1.11
diff -b -d -u -r1.11 epsilon_tests.cpp
--- libs/spirit/test/epsilon_tests.cpp	3 Aug 2004 03:45:18 -0000	1.11
+++ libs/spirit/test/epsilon_tests.cpp	18 Feb 2006 22:55:12 -0000
@@ -8,7 +8,7 @@
 =============================================================================*/
 #include <iostream>
 #include <cstring>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 // This test program only includes the epsilon.hpp header from Spirit
 #include <boost/spirit/core/composite/epsilon.hpp>
Index: libs/spirit/test/escape_char_parser_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/escape_char_parser_tests.cpp,v
retrieving revision 1.14
diff -b -d -u -r1.14 escape_char_parser_tests.cpp
--- libs/spirit/test/escape_char_parser_tests.cpp	14 Oct 2005 14:46:13 -0000	1.14
+++ libs/spirit/test/escape_char_parser_tests.cpp	18 Feb 2006 22:55:12 -0000
@@ -12,7 +12,7 @@
 #include <boost/spirit/utility/escape_char.hpp>
 
 #include <iostream>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 #include <cstdio>       // for sprintf
 
 #if !defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_SWPRINTF)
@@ -30,91 +30,91 @@
     char c;
 
     // testing good C escapes
-    assert(parse("a", c_escape_ch_p[assign_a(c)]).full);
-    assert(c == 'a');
-    assert(parse("\\b", c_escape_ch_p[assign_a(c)]).full);
-    assert(c == '\b');
-    assert(parse("\\t", c_escape_ch_p[assign_a(c)]).full);
-    assert(c == '\t');
-    assert(parse("\\n", c_escape_ch_p[assign_a(c)]).full);
-    assert(c == '\n');
-    assert(parse("\\f", c_escape_ch_p[assign_a(c)]).full);
-    assert(c == '\f');
-    assert(parse("\\r", c_escape_ch_p[assign_a(c)]).full);
-    assert(c == '\r');
-    assert(parse("\\\"", c_escape_ch_p[assign_a(c)]).full);
-    assert(c == '\"');
-    assert(parse("\\'", c_escape_ch_p[assign_a(c)]).full);
-    assert(c == '\'');
-    assert(parse("\\\\", c_escape_ch_p[assign_a(c)]).full);
-    assert(c == '\\');
-    assert(parse("\\120", c_escape_ch_p[assign_a(c)]).full);
-    assert(c == '\120');
-    assert(parse("\\x2e", c_escape_ch_p[assign_a(c)]).full);
-    assert(c == '\x2e');
+    BOOST_TEST(parse("a", c_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == 'a');
+    BOOST_TEST(parse("\\b", c_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == '\b');
+    BOOST_TEST(parse("\\t", c_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == '\t');
+    BOOST_TEST(parse("\\n", c_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == '\n');
+    BOOST_TEST(parse("\\f", c_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == '\f');
+    BOOST_TEST(parse("\\r", c_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == '\r');
+    BOOST_TEST(parse("\\\"", c_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == '\"');
+    BOOST_TEST(parse("\\'", c_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == '\'');
+    BOOST_TEST(parse("\\\\", c_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == '\\');
+    BOOST_TEST(parse("\\120", c_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == '\120');
+    BOOST_TEST(parse("\\x2e", c_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == '\x2e');
 
     // test bad C escapes
-    assert(!parse("\\z", c_escape_ch_p[assign_a(c)]).hit);
+    BOOST_TEST(!parse("\\z", c_escape_ch_p[assign_a(c)]).hit);
 
     // testing good lex escapes
-    assert(parse("a", lex_escape_ch_p[assign_a(c)]).full);
-    assert(c == 'a');
-    assert(parse("\\b", lex_escape_ch_p[assign_a(c)]).full);
-    assert(c == '\b');
-    assert(parse("\\t", lex_escape_ch_p[assign_a(c)]).full);
-    assert(c == '\t');
-    assert(parse("\\n", lex_escape_ch_p[assign_a(c)]).full);
-    assert(c == '\n');
-    assert(parse("\\f", lex_escape_ch_p[assign_a(c)]).full);
-    assert(c == '\f');
-    assert(parse("\\r", lex_escape_ch_p[assign_a(c)]).full);
-    assert(c == '\r');
-    assert(parse("\\\"", lex_escape_ch_p[assign_a(c)]).full);
-    assert(c == '\"');
-    assert(parse("\\'", lex_escape_ch_p[assign_a(c)]).full);
-    assert(c == '\'');
-    assert(parse("\\\\", lex_escape_ch_p[assign_a(c)]).full);
-    assert(c == '\\');
-    assert(parse("\\120", lex_escape_ch_p[assign_a(c)]).full);
-    assert(c == '\120');
-    assert(parse("\\x2e", lex_escape_ch_p[assign_a(c)]).full);
-    assert(c == '\x2e');
-    assert(parse("\\z", lex_escape_ch_p[assign_a(c)]).full);
-    assert(c == 'z');
-    assert(parse("\\a", lex_escape_ch_p[assign_a(c)]).full);
-    assert(c == 'a');
+    BOOST_TEST(parse("a", lex_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == 'a');
+    BOOST_TEST(parse("\\b", lex_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == '\b');
+    BOOST_TEST(parse("\\t", lex_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == '\t');
+    BOOST_TEST(parse("\\n", lex_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == '\n');
+    BOOST_TEST(parse("\\f", lex_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == '\f');
+    BOOST_TEST(parse("\\r", lex_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == '\r');
+    BOOST_TEST(parse("\\\"", lex_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == '\"');
+    BOOST_TEST(parse("\\'", lex_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == '\'');
+    BOOST_TEST(parse("\\\\", lex_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == '\\');
+    BOOST_TEST(parse("\\120", lex_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == '\120');
+    BOOST_TEST(parse("\\x2e", lex_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == '\x2e');
+    BOOST_TEST(parse("\\z", lex_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == 'z');
+    BOOST_TEST(parse("\\a", lex_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == 'a');
 
     // test bad lex escapes
-    assert(!parse("\\xz", lex_escape_ch_p[assign_a(c)]).hit);
+    BOOST_TEST(!parse("\\xz", lex_escape_ch_p[assign_a(c)]).hit);
 
     // test out of range octal escape
-    assert(!parse("\\777", lex_escape_ch_p[assign_a(c)]).hit);
+    BOOST_TEST(!parse("\\777", lex_escape_ch_p[assign_a(c)]).hit);
 
 #if CHAR_MAX == 127
-    assert(!parse("\\200", lex_escape_ch_p[assign_a(c)]).hit);
+    BOOST_TEST(!parse("\\200", lex_escape_ch_p[assign_a(c)]).hit);
 
-    assert(parse("\\177", lex_escape_ch_p[assign_a(c)]).full);
-    assert(c == '\177');
+    BOOST_TEST(parse("\\177", lex_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == '\177');
 #elif CHAR_MAX == 255
-    assert(!parse("\\400", lex_escape_ch_p[assign_a(c)]).hit);
+    BOOST_TEST(!parse("\\400", lex_escape_ch_p[assign_a(c)]).hit);
 
-    assert(parse("\\377", lex_escape_ch_p[assign_a(c)]).full);
-    assert(c == '\377');
+    BOOST_TEST(parse("\\377", lex_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == '\377');
 #endif
 
     // test out of range hex escape
-    assert(!parse("\\xFFF", lex_escape_ch_p[assign_a(c)]).hit);
+    BOOST_TEST(!parse("\\xFFF", lex_escape_ch_p[assign_a(c)]).hit);
 
 #if CHAR_MAX == 127
-    assert(!parse("\\X80", lex_escape_ch_p[assign_a(c)]).hit);
+    BOOST_TEST(!parse("\\X80", lex_escape_ch_p[assign_a(c)]).hit);
 
-    assert(parse("\\X7F", lex_escape_ch_p[assign_a(c)]).full);
-    assert(c == '\x7f');
+    BOOST_TEST(parse("\\X7F", lex_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == '\x7f');
 #elif CHAR_MAX == 255
-    assert(!parse("\\X100", lex_escape_ch_p[assign_a(c)]).hit);
+    BOOST_TEST(!parse("\\X100", lex_escape_ch_p[assign_a(c)]).hit);
 
-    assert(parse("\\XFf", lex_escape_ch_p[assign_a(c)]).full);
-    assert(c == '\xff');
+    BOOST_TEST(parse("\\XFf", lex_escape_ch_p[assign_a(c)]).full);
+    BOOST_TEST(c == '\xff');
 #endif
 
 #ifndef BOOST_NO_CWCHAR
@@ -130,31 +130,31 @@
     //wchar_t const* wend(wstr + wcslen(wstr));
 
     wchar_t wc;
-    assert(parse(L"a", wcep[assign_a(wc)]).hit);
-    assert(wc == L'a');
-    assert(parse(L"\\b", wcep[assign_a(wc)]).full);
-    assert(wc == L'\b');
-    assert(parse(L"\\t", wcep[assign_a(wc)]).full);
-    assert(wc == L'\t');
-    assert(parse(L"\\n", wcep[assign_a(wc)]).full);
-    assert(wc == L'\n');
-    assert(parse(L"\\f", wcep[assign_a(wc)]).full);
-    assert(wc == L'\f');
-    assert(parse(L"\\r", wcep[assign_a(wc)]).full);
-    assert(wc == L'\r');
-    assert(parse(L"\\\"", wcep[assign_a(wc)]).full);
-    assert(wc == L'\"');
-    assert(parse(L"\\'", wcep[assign_a(wc)]).full);
-    assert(wc == L'\'');
-    assert(parse(L"\\\\", wcep[assign_a(wc)]).full);
-    assert(wc == L'\\');
-    assert(parse(L"\\120", wcep[assign_a(wc)]).full);
-    assert(wc == L'\120');
-    assert(parse(L"\\x2e", wcep[assign_a(wc)]).full);
-    assert(wc == L'\x2e');
+    BOOST_TEST(parse(L"a", wcep[assign_a(wc)]).hit);
+    BOOST_TEST(wc == L'a');
+    BOOST_TEST(parse(L"\\b", wcep[assign_a(wc)]).full);
+    BOOST_TEST(wc == L'\b');
+    BOOST_TEST(parse(L"\\t", wcep[assign_a(wc)]).full);
+    BOOST_TEST(wc == L'\t');
+    BOOST_TEST(parse(L"\\n", wcep[assign_a(wc)]).full);
+    BOOST_TEST(wc == L'\n');
+    BOOST_TEST(parse(L"\\f", wcep[assign_a(wc)]).full);
+    BOOST_TEST(wc == L'\f');
+    BOOST_TEST(parse(L"\\r", wcep[assign_a(wc)]).full);
+    BOOST_TEST(wc == L'\r');
+    BOOST_TEST(parse(L"\\\"", wcep[assign_a(wc)]).full);
+    BOOST_TEST(wc == L'\"');
+    BOOST_TEST(parse(L"\\'", wcep[assign_a(wc)]).full);
+    BOOST_TEST(wc == L'\'');
+    BOOST_TEST(parse(L"\\\\", wcep[assign_a(wc)]).full);
+    BOOST_TEST(wc == L'\\');
+    BOOST_TEST(parse(L"\\120", wcep[assign_a(wc)]).full);
+    BOOST_TEST(wc == L'\120');
+    BOOST_TEST(parse(L"\\x2e", wcep[assign_a(wc)]).full);
+    BOOST_TEST(wc == L'\x2e');
 
     // test bad wc escapes
-    assert(!parse(L"\\z", wcep[assign_a(wc)]).hit);
+    BOOST_TEST(!parse(L"\\z", wcep[assign_a(wc)]).hit);
 
     // test out of range octal escape
     size_t const octmax_size = 16;
@@ -163,13 +163,13 @@
 #if !defined(BOOST_NO_SWPRINTF)
     swprintf(octmax, octmax_size,
       L"\\%lo", (unsigned long)(std::numeric_limits<wchar_t>::max)());
-    assert(parse(octmax, wlep[assign_a(wc)]).full);
-    //assert(lex_escape_ch_p[assign_a(wc)].parse(str, end));
-    assert(wc == (std::numeric_limits<wchar_t>::max)());
+    BOOST_TEST(parse(octmax, wlep[assign_a(wc)]).full);
+    //BOOST_TEST(lex_escape_ch_p[assign_a(wc)].parse(str, end));
+    BOOST_TEST(wc == (std::numeric_limits<wchar_t>::max)());
 
     swprintf(octmax, octmax_size,
       L"\\%lo", (unsigned long)(std::numeric_limits<wchar_t>::max)() + 1);
-    assert(!parse(octmax, wlep[assign_a(wc)]).hit);
+    BOOST_TEST(!parse(octmax, wlep[assign_a(wc)]).hit);
 
     // test out of range hex escape
     size_t const hexmax_size = 16;
@@ -177,15 +177,15 @@
 
     swprintf(hexmax, hexmax_size,
       L"\\x%lx", (unsigned long)(std::numeric_limits<wchar_t>::max)());
-    assert(parse(hexmax, wlep[assign_a(wc)]).full);
-    assert(wc == (std::numeric_limits<wchar_t>::max)());
+    BOOST_TEST(parse(hexmax, wlep[assign_a(wc)]).full);
+    BOOST_TEST(wc == (std::numeric_limits<wchar_t>::max)());
 
     swprintf(hexmax, hexmax_size,
       L"\\x%lx", (unsigned long)(std::numeric_limits<wchar_t>::max)() + 1);
-    assert(!parse(hexmax, wlep[assign_a(wc)]).hit);
+    BOOST_TEST(!parse(hexmax, wlep[assign_a(wc)]).hit);
 #endif // !defined(BOOST_NO_SWPRINTF)
 
 #endif
 
-    return 0;
+    return boost::report_errors();
 }
Index: libs/spirit/test/exception_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/exception_tests.cpp,v
retrieving revision 1.7
diff -b -d -u -r1.7 exception_tests.cpp
--- libs/spirit/test/exception_tests.cpp	9 Jul 2004 08:30:38 -0000	1.7
+++ libs/spirit/test/exception_tests.cpp	18 Feb 2006 22:55:12 -0000
@@ -9,7 +9,7 @@
 #include <boost/spirit/core.hpp>
 #include <boost/spirit/error_handling/exceptions.hpp>
 #include <iostream>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace std;
 using namespace boost::spirit;
@@ -43,7 +43,7 @@
             ]
         ).full;
 
-    assert(!r);
-    return 0;
+    BOOST_TEST(!r);
+    return boost::report_errors();
 }
 
Index: libs/spirit/test/file_iterator_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/file_iterator_tests.cpp,v
retrieving revision 1.7
diff -b -d -u -r1.7 file_iterator_tests.cpp
--- libs/spirit/test/file_iterator_tests.cpp	31 Jan 2006 07:59:17 -0000	1.7
+++ libs/spirit/test/file_iterator_tests.cpp	18 Feb 2006 22:55:12 -0000
@@ -6,7 +6,7 @@
     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 #include <cstdio>
 #include <iostream>
 #include <boost/concept_check.hpp>
@@ -53,79 +53,79 @@
 {
     // Check constructor opening a file
     ITER a(TMP_FILE);
-    assert(!!a);
+    BOOST_TEST(!!a);
 
     // Assert dereference (twice: derefence
     //  must not move the iterator)
-    assert(*a == 0);
-    assert(*a == 0);
+    BOOST_TEST(*a == 0);
+    BOOST_TEST(*a == 0);
 
     // Check random access
-    assert(a[123] == 123);
+    BOOST_TEST(a[123] == 123);
 
     // Check copy constructor and operator==
     ITER c(a);
-    assert(c == a);
-    assert(!(c != a));
+    BOOST_TEST(c == a);
+    BOOST_TEST(!(c != a));
 
     // Check assignment operator
     ITER d; d = a;
-    assert(d == a);
-    assert(!(d != a));
+    BOOST_TEST(d == a);
+    BOOST_TEST(!(d != a));
 
     // Check make_end()
     ITER b(a.make_end());
-    assert(!!b);
-    assert(a != b);
-    assert(a+256 == b);
-    assert(a == b-256);
+    BOOST_TEST(!!b);
+    BOOST_TEST(a != b);
+    BOOST_TEST(a+256 == b);
+    BOOST_TEST(a == b-256);
 
     // Check copy constructor on non-trivial position
-    assert(*ITER(a+67) == 67);
+    BOOST_TEST(*ITER(a+67) == 67);
 
     // Check increment
     ++a; ++a; a++; a++;
-    assert(*a == 4);
-    assert(a == c+4);
+    BOOST_TEST(*a == 4);
+    BOOST_TEST(a == c+4);
 
     // Check decrement
     --a; --a; a--; a--;
-    assert(*a == 0);
-    assert(a == c);
+    BOOST_TEST(*a == 0);
+    BOOST_TEST(a == c);
 
     // Check end iterator increment/decrement
     --b; b--;
-    assert(*b == 254);
-    assert(a+254 == b);
+    BOOST_TEST(*b == 254);
+    BOOST_TEST(a+254 == b);
     ++b; b++;
-    assert(a+256 == b);
+    BOOST_TEST(a+256 == b);
 
     // Check order
     a += 128;
-    assert(c < a);
-    assert(a < b);
-    assert(a > c);
-    assert(b > a);
+    BOOST_TEST(c < a);
+    BOOST_TEST(a < b);
+    BOOST_TEST(a > c);
+    BOOST_TEST(b > a);
 
     // Check assignment
     a = b;
-    assert(a == b);
+    BOOST_TEST(a == b);
     a = c;
-    assert(a == c);
+    BOOST_TEST(a == c);
 
     // Check weak order
-    assert(a <= c);
-    assert(a >= c);
-    assert(a <= b);
-    assert(!(a >= b));
+    BOOST_TEST(a <= c);
+    BOOST_TEST(a >= c);
+    BOOST_TEST(a <= b);
+    BOOST_TEST(!(a >= b));
 
     // Check increment through end
     a += 255;
-    assert(a != b);
+    BOOST_TEST(a != b);
     ++a;
-    assert(a == b);
+    BOOST_TEST(a == b);
     ++a;
-    assert(a != b);
+    BOOST_TEST(a != b);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -169,10 +169,9 @@
 #endif
 
     // Check if the file handles were closed correctly
-    assert(remove(TMP_FILE) == 0);
+    BOOST_TEST(remove(TMP_FILE) == 0);
 
-    cerr << "Test completed successfully" << endl;
-    return 0;
+    return boost::report_errors();
 }
 
 #ifdef BOOST_NO_EXCEPTIONS
@@ -180,7 +179,7 @@
 namespace boost {
     void throw_exception(std::exception const& e)
     {
-        assert(0);
+        BOOST_EROR("throw_exception");
     }
 }
 
Index: libs/spirit/test/fixed_size_queue_fail_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/fixed_size_queue_fail_tests.cpp,v
retrieving revision 1.5
diff -b -d -u -r1.5 fixed_size_queue_fail_tests.cpp
--- libs/spirit/test/fixed_size_queue_fail_tests.cpp	2 Sep 2004 15:41:37 -0000	1.5
+++ libs/spirit/test/fixed_size_queue_fail_tests.cpp	18 Feb 2006 22:55:12 -0000
@@ -11,7 +11,7 @@
 #include <boost/mpl/assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/concept_check.hpp>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 #include <iostream>
 
 typedef boost::spirit::fixed_size_queue<int, 5> queue_t;
@@ -59,8 +59,6 @@
     (void) c+4 > b;
     (void) c < b+4;
 
-    std::cout << "Test completed succesfully" << std::endl;
-
-    return 0;
+    return boost::report_errors();
 }
 
Index: libs/spirit/test/fixed_size_queue_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/fixed_size_queue_tests.cpp,v
retrieving revision 1.9
diff -b -d -u -r1.9 fixed_size_queue_tests.cpp
--- libs/spirit/test/fixed_size_queue_tests.cpp	2 Sep 2004 15:41:37 -0000	1.9
+++ libs/spirit/test/fixed_size_queue_tests.cpp	18 Feb 2006 22:55:12 -0000
@@ -11,7 +11,7 @@
 #include <boost/mpl/assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/concept_check.hpp>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 #include <iostream>
 
 typedef boost::spirit::fixed_size_queue<int, 5> queue_t;
@@ -34,25 +34,25 @@
     q.push_back(2);
     q.push_back(3);
     q.push_back(4);
-    assert(q.front() == 1);
+    BOOST_TEST(q.front() == 1);
     q.pop_front();
-    assert(q.front() == 2);
+    BOOST_TEST(q.front() == 2);
     q.pop_front();
-    assert(q.front() == 3);
+    BOOST_TEST(q.front() == 3);
     q.pop_front();
-    assert(q.front() == 4);
+    BOOST_TEST(q.front() == 4);
     q.pop_front();
     q.push_back(5);
     q.push_back(6);
     q.push_back(7);
     q.push_back(8);
-    assert(q.front() == 5);
+    BOOST_TEST(q.front() == 5);
     q.pop_front();
-    assert(q.front() == 6);
+    BOOST_TEST(q.front() == 6);
     q.pop_front();
-    assert(q.front() == 7);
+    BOOST_TEST(q.front() == 7);
     q.pop_front();
-    assert(q.front() == 8);
+    BOOST_TEST(q.front() == 8);
     q.pop_front();
 
     q.push_front(5);
@@ -65,33 +65,33 @@
 
     // Check iterator
     iter_t b = q.begin();
-    assert(*b++ == 1);
-    assert(*b++ == 2);
-    assert(*b++ == 3);
-    assert(*b++ == 4);
-    assert(*b++ == 5);
-    assert(b == q.end());
-    assert(*--b == 5);
-    assert(*--b == 4);
-    assert(*--b == 3);
-    assert(*--b == 2);
-    assert(*--b == 1);
-    assert(b == q.begin());
+    BOOST_TEST(*b++ == 1);
+    BOOST_TEST(*b++ == 2);
+    BOOST_TEST(*b++ == 3);
+    BOOST_TEST(*b++ == 4);
+    BOOST_TEST(*b++ == 5);
+    BOOST_TEST(b == q.end());
+    BOOST_TEST(*--b == 5);
+    BOOST_TEST(*--b == 4);
+    BOOST_TEST(*--b == 3);
+    BOOST_TEST(*--b == 2);
+    BOOST_TEST(*--b == 1);
+    BOOST_TEST(b == q.begin());
 
     // Check const_iterator
     const_iter_t c = cq.begin();
-    assert(*c++ == 1);
-    assert(*c++ == 2);
-    assert(*c++ == 3);
-    assert(*c++ == 4);
-    assert(*c++ == 5);
-    assert(c == cq.end());
-    assert(*--c == 5);
-    assert(*--c == 4);
-    assert(*--c == 3);
-    assert(*--c == 2);
-    assert(*--c == 1);
-    assert(c == cq.begin());
+    BOOST_TEST(*c++ == 1);
+    BOOST_TEST(*c++ == 2);
+    BOOST_TEST(*c++ == 3);
+    BOOST_TEST(*c++ == 4);
+    BOOST_TEST(*c++ == 5);
+    BOOST_TEST(c == cq.end());
+    BOOST_TEST(*--c == 5);
+    BOOST_TEST(*--c == 4);
+    BOOST_TEST(*--c == 3);
+    BOOST_TEST(*--c == 2);
+    BOOST_TEST(*--c == 1);
+    BOOST_TEST(c == cq.begin());
 
 #if 0
 
@@ -118,22 +118,20 @@
 
     //  Check comparisons and interoperations (we are comparing
     //  const and non-const iterators)
-    assert(c == b);
-    assert(c+4 > b);
-    assert(c < b+4);
+    BOOST_TEST(c == b);
+    BOOST_TEST(c+4 > b);
+    BOOST_TEST(c < b+4);
 
 #endif
 
     // Check that you can actually modify the queue with an iterator
     *b = 123;
-    assert(*c == 123);
+    BOOST_TEST(*c == 123);
 
     // Check random access
-    assert(*((c+4)-4) == 123);
-    assert(*((c-4)+4) == 123);
-
-    std::cout << "Test completed succesfully" << std::endl;
+    BOOST_TEST(*((c+4)-4) == 123);
+    BOOST_TEST(*((c-4)+4) == 123);
 
-    return 0;
+    return boost::report_errors();
 }
 
Index: libs/spirit/test/fundamental_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/fundamental_tests.cpp,v
retrieving revision 1.7
diff -b -d -u -r1.7 fundamental_tests.cpp
--- libs/spirit/test/fundamental_tests.cpp	9 Jul 2004 08:30:38 -0000	1.7
+++ libs/spirit/test/fundamental_tests.cpp	18 Feb 2006 22:55:12 -0000
@@ -12,7 +12,7 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 #include <iostream>
 #include <boost/static_assert.hpp>
 #include <boost/spirit/core.hpp>
@@ -90,7 +90,6 @@
     node_count_tests();
     leaf_count_tests();
 
-    cout << "Tests concluded successfully\n";
-    return 0;
+    return boost::report_errors();
 }
 
Index: libs/spirit/test/grammar_multi_instance_tst.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/grammar_multi_instance_tst.cpp,v
retrieving revision 1.1
diff -b -d -u -r1.1 grammar_multi_instance_tst.cpp
--- libs/spirit/test/grammar_multi_instance_tst.cpp	13 Sep 2004 09:24:06 -0000	1.1
+++ libs/spirit/test/grammar_multi_instance_tst.cpp	18 Feb 2006 22:55:12 -0000
@@ -7,7 +7,7 @@
     http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
 #include <iostream>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 #include <boost/spirit/core.hpp>
 
 using namespace boost::spirit;
@@ -43,9 +43,8 @@
     grammar_tests();
     grammar_tests();
     grammar_tests();
-    assert(g_count == 3);
+    BOOST_TEST(g_count == 3);
 
-    cout << "Tests concluded successfully\n";
-    return 0;
+    return boost::report_errors();
 }
 
Index: libs/spirit/test/grammar_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/grammar_tests.cpp,v
retrieving revision 1.9
diff -b -d -u -r1.9 grammar_tests.cpp
--- libs/spirit/test/grammar_tests.cpp	9 Jul 2004 08:30:38 -0000	1.9
+++ libs/spirit/test/grammar_tests.cpp	18 Feb 2006 22:55:12 -0000
@@ -8,7 +8,7 @@
     http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
 #include <iostream>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace std;
 
@@ -108,8 +108,8 @@
 
     parse_info<char const*> pi;
     pi = parse("123, 456, 789", nlist, space_p);
-    assert(pi.hit);
-    assert(pi.full);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
 
 #if defined(BOOST_SPIRIT_USE_GRAMMARDEF)
     num_list_ex nlistex;
@@ -117,30 +117,30 @@
 
     pi = parse("123, 456, 789", nlist.use_parser<num_list::default_rule>(),
         space_p);
-    assert(pi.hit);
-    assert(pi.full);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
 
     pi = parse("123", nlist.use_parser<num_list::num_rule>(), space_p);
-    assert(pi.hit);
-    assert(pi.full);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
 
     pi = parse("123, 456, 789", nlistex, space_p);
-    assert(pi.hit);
-    assert(pi.full);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
 
     pi = parse("123, 456, 789",
         nlistex.use_parser<num_list_ex::default_rule>(), space_p);
-    assert(pi.hit);
-    assert(pi.full);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
 
     pi = parse("123", nlistex.use_parser<num_list_ex::num_rule>(), space_p);
-    assert(pi.hit);
-    assert(pi.full);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
 
     pi = parse("123", nlistex.use_parser<num_list_ex::integer_rule>(),
         space_p);
-    assert(pi.hit);
-    assert(pi.full);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
 #endif // defined(BOOST_SPIRIT_USE_GRAMMARDEF)
 }
 
@@ -153,7 +153,6 @@
 main()
 {
     grammar_tests();
-    cout << "Tests concluded successfully\n";
-    return 0;
+    return boost::report_errors();
 }
 
Index: libs/spirit/test/loops_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/loops_tests.cpp,v
retrieving revision 1.8
diff -b -d -u -r1.8 loops_tests.cpp
--- libs/spirit/test/loops_tests.cpp	9 Jul 2004 08:30:38 -0000	1.8
+++ libs/spirit/test/loops_tests.cpp	18 Feb 2006 22:55:13 -0000
@@ -7,7 +7,7 @@
     http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
 #include <iostream>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace std;
 
@@ -27,84 +27,84 @@
     parse_info<char const*> pi;
 
     pi = parse("\"Hello World\"", "\"" >> *(anychar_p - "\"") >> "\"");
-    assert(pi.hit);
-    assert(pi.full);
-    assert(pi.length == 13);
-    assert(*pi.stop == 0);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
+    BOOST_TEST(pi.length == 13);
+    BOOST_TEST(*pi.stop == 0);
 
     pi = parse("\"Hello World\"", "\"" >> repeat_p(0, more)[anychar_p - "\""] >> "\"");
-    assert(pi.hit);
-    assert(pi.full);
-    assert(pi.length == 13);
-    assert(*pi.stop == 0);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
+    BOOST_TEST(pi.length == 13);
+    BOOST_TEST(*pi.stop == 0);
 
     pi = parse("xx", +ch_p('x'));
-    assert(pi.hit);
-    assert(pi.full);
-    assert(pi.length == 2);
-    assert(*pi.stop == 0);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
+    BOOST_TEST(pi.length == 2);
+    BOOST_TEST(*pi.stop == 0);
 
     pi = parse("xx", repeat_p(1, more)[ch_p('x')]);
-    assert(pi.hit);
-    assert(pi.full);
-    assert(pi.length == 2);
-    assert(*pi.stop == 0);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
+    BOOST_TEST(pi.length == 2);
+    BOOST_TEST(*pi.stop == 0);
 
     pi = parse("", +ch_p('x'));
-    assert(!pi.hit);
+    BOOST_TEST(!pi.hit);
 
     pi = parse("", repeat_p(1, more)[ch_p('x')]);
-    assert(!pi.hit);
+    BOOST_TEST(!pi.hit);
 
     pi = parse("", *ch_p('x'));
-    assert(pi.hit);
-    assert(pi.full);
-    assert(pi.length == 0);
-    assert(*pi.stop == 0);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
+    BOOST_TEST(pi.length == 0);
+    BOOST_TEST(*pi.stop == 0);
 
     pi = parse("", repeat_p(0, more)[ch_p('x')]);
-    assert(pi.hit);
-    assert(pi.full);
-    assert(pi.length == 0);
-    assert(*pi.stop == 0);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
+    BOOST_TEST(pi.length == 0);
+    BOOST_TEST(*pi.stop == 0);
 
     //  repeat exact 8
     rule<>  rep8 = repeat_p(8)[alpha_p] >> 'X';
-    assert(!parse("abcdefgX", rep8).hit);
-    assert(parse("abcdefghX", rep8).full);
-    assert(!parse("abcdefghiX", rep8).hit);
-    assert(!parse("abcdefgX", rep8).hit);
-    assert(!parse("aX", rep8).hit);
+    BOOST_TEST(!parse("abcdefgX", rep8).hit);
+    BOOST_TEST(parse("abcdefghX", rep8).full);
+    BOOST_TEST(!parse("abcdefghiX", rep8).hit);
+    BOOST_TEST(!parse("abcdefgX", rep8).hit);
+    BOOST_TEST(!parse("aX", rep8).hit);
 
     //  repeat 2 to 8
     rule<>  rep28 = repeat_p(2, 8)[alpha_p] >> '*';
-    assert(parse("abcdefg*", rep28).full);
-    assert(parse("abcdefgh*", rep28).full);
-    assert(!parse("abcdefghi*", rep28).hit);
-    assert(!parse("a*", rep28).hit);
+    BOOST_TEST(parse("abcdefg*", rep28).full);
+    BOOST_TEST(parse("abcdefgh*", rep28).full);
+    BOOST_TEST(!parse("abcdefghi*", rep28).hit);
+    BOOST_TEST(!parse("a*", rep28).hit);
 
     //  repeat 2 or more
     rule<>  rep2_ = repeat_p(2, more)[alpha_p] >> '+';
-    assert(parse("abcdefg+", rep2_).full);
-    assert(parse("abcdefgh+", rep2_).full);
-    assert(parse("abcdefghi+", rep2_).full);
-    assert(parse("abcdefg+", rep2_).full);
-    assert(!parse("a+", rep2_).hit);
+    BOOST_TEST(parse("abcdefg+", rep2_).full);
+    BOOST_TEST(parse("abcdefgh+", rep2_).full);
+    BOOST_TEST(parse("abcdefghi+", rep2_).full);
+    BOOST_TEST(parse("abcdefg+", rep2_).full);
+    BOOST_TEST(!parse("a+", rep2_).hit);
 
     //  repeat 0
     rule<>  rep0 = repeat_p(0)[alpha_p] >> '/';
-    assert(parse("/", rep0).full);
-    assert(!parse("a/", rep0).hit);
+    BOOST_TEST(parse("/", rep0).full);
+    BOOST_TEST(!parse("a/", rep0).hit);
 
     //  repeat 0 or 1
     rule<>  rep01 = repeat_p(0, 1)[alpha_p >> digit_p] >> '?';
-    assert(!parse("abcdefg?", rep01).hit);
-    assert(!parse("a?", rep01).hit);
-    assert(!parse("1?", rep01).hit);
-    assert(!parse("11?", rep01).hit);
-    assert(!parse("aa?", rep01).hit);
-    assert(parse("?", rep01).full);
-    assert(parse("a1?", rep01).full);
+    BOOST_TEST(!parse("abcdefg?", rep01).hit);
+    BOOST_TEST(!parse("a?", rep01).hit);
+    BOOST_TEST(!parse("1?", rep01).hit);
+    BOOST_TEST(!parse("11?", rep01).hit);
+    BOOST_TEST(!parse("aa?", rep01).hit);
+    BOOST_TEST(parse("?", rep01).full);
+    BOOST_TEST(parse("a1?", rep01).full);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -116,7 +116,6 @@
 main()
 {
     loops_tests();
-    cout << "Tests concluded successfully\n";
-    return 0;
+    return boost::report_errors();
 }
 
Index: libs/spirit/test/match_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/match_tests.cpp,v
retrieving revision 1.10
diff -b -d -u -r1.10 match_tests.cpp
--- libs/spirit/test/match_tests.cpp	23 Feb 2005 11:42:00 -0000	1.10
+++ libs/spirit/test/match_tests.cpp	18 Feb 2006 22:55:13 -0000
@@ -7,7 +7,7 @@
     http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
 #include <iostream>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 #include <string>
 
 using namespace std;
@@ -28,43 +28,43 @@
 match_tests()
 {
     match<> m0;
-    assert(!m0.has_valid_attribute());
+    BOOST_TEST(!m0.has_valid_attribute());
 
     match<int> m1(m0);
     m1.value(123);
-    assert(m1.has_valid_attribute());
-    assert(m1.value() == 123);
+    BOOST_TEST(m1.has_valid_attribute());
+    BOOST_TEST(m1.value() == 123);
 
     match<double> m2(m1);
-    assert(m2.has_valid_attribute());
-    assert(m1.value() == int(m2.value()));
+    BOOST_TEST(m2.has_valid_attribute());
+    BOOST_TEST(m1.value() == int(m2.value()));
     m2.value(456);
 
     m0 = m0; // match<nil> = match<nil>
     m0 = m1; // match<nil> = match<int>
     m0 = m2; // match<nil> = match<double>
     m1 = m0; // match<int> = match<nil>
-    assert(!m1);
-    assert(!m1.has_valid_attribute());
+    BOOST_TEST(!m1);
+    BOOST_TEST(!m1.has_valid_attribute());
 
     m1 = m1; // match<int> = match<int>
     m1.value(int(m2.value()));
-    assert(m1.has_valid_attribute());
-    assert(m1.value() == int(m2.value()));
+    BOOST_TEST(m1.has_valid_attribute());
+    BOOST_TEST(m1.value() == int(m2.value()));
 
     m2.value(123.456);
     match<Z> mz(m2); // copy from match<double>
     mz = m2; // assign from match<double>
-    assert(mz.value().n == 123.456);
+    BOOST_TEST(mz.value().n == 123.456);
 
     m1.value(123);
     m2 = m0;
-    assert(!m2);
-    assert(!m2.has_valid_attribute());
+    BOOST_TEST(!m2);
+    BOOST_TEST(!m2.has_valid_attribute());
 
     m2 = m1; // match<double> = match<int>
-    assert(m2.has_valid_attribute());
-    assert(m1.value() == int(m2.value()));
+    BOOST_TEST(m2.has_valid_attribute());
+    BOOST_TEST(m1.value() == int(m2.value()));
     m2 = m2; // match<double> = match<double>
 
     cout << "sizeof(int) == " << sizeof(int) << '\n';
@@ -73,64 +73,64 @@
     cout << "sizeof(match<double>) == " << sizeof(m2) << '\n';
 
     match<int&> mr;
-    assert(!mr.has_valid_attribute());
+    BOOST_TEST(!mr.has_valid_attribute());
 
     match<int&> mrr(4);
-    assert(!mrr.has_valid_attribute());
+    BOOST_TEST(!mrr.has_valid_attribute());
 
     int ri = 3;
     match<int&> mr2(4, ri);
-    assert(mr2.has_valid_attribute());
+    BOOST_TEST(mr2.has_valid_attribute());
     mr = mr2;
-    assert(mr.has_valid_attribute());
+    BOOST_TEST(mr.has_valid_attribute());
 
     match<int&> mr3(mrr);
-    assert(!mr3.has_valid_attribute());
+    BOOST_TEST(!mr3.has_valid_attribute());
     mr2 = mr3;
-    assert(!mr2.has_valid_attribute());
+    BOOST_TEST(!mr2.has_valid_attribute());
 
     match<X> mx;
     m1 = mx;
     m0 = mx;
-    assert(!mx.has_valid_attribute());
-    assert(!m0.has_valid_attribute());
-    assert(!m1.has_valid_attribute());
+    BOOST_TEST(!mx.has_valid_attribute());
+    BOOST_TEST(!m0.has_valid_attribute());
+    BOOST_TEST(!m1.has_valid_attribute());
 
     match<Y> my;
-    assert(!my.has_valid_attribute());
+    BOOST_TEST(!my.has_valid_attribute());
 
     match<std::string> ms;
-    assert(!ms.has_valid_attribute());
+    BOOST_TEST(!ms.has_valid_attribute());
     ms.value("Kimpo Ponchwayla");
-    assert(ms.has_valid_attribute());
-    assert(ms.value() == "Kimpo Ponchwayla");
+    BOOST_TEST(ms.has_valid_attribute());
+    BOOST_TEST(ms.value() == "Kimpo Ponchwayla");
     ms = match<>();
-    assert(!ms.has_valid_attribute());
+    BOOST_TEST(!ms.has_valid_attribute());
 
     // let's try a match with a reference:
     int i;
     match<int&> mr4(4, i);
-    assert(mr4.has_valid_attribute());
+    BOOST_TEST(mr4.has_valid_attribute());
     mr4.value(3);
-    assert(mr4.value() == 3);
-    assert(i == 3);
+    BOOST_TEST(mr4.value() == 3);
+    BOOST_TEST(i == 3);
     (void)i;
 
     int x = 456;
     match<int&> mref(1, x);
-    assert(mref.value() == 456);
+    BOOST_TEST(mref.value() == 456);
     mref.value(123);
-    assert(mref.value() == 123);
+    BOOST_TEST(mref.value() == 123);
     x = mref.value();
-    assert(x == 123);
+    BOOST_TEST(x == 123);
     mref.value() = 986;
-    assert(x == 986);
+    BOOST_TEST(x == 986);
     
     std::string s("hello");
     match<int> mint(1, x);
-    assert(mint.value() == x);
+    BOOST_TEST(mint.value() == x);
     match<std::string> mstr(1, s);
-    assert(mstr.value() == "hello");
+    BOOST_TEST(mstr.value() == "hello");
     mstr = mint;
     mint = mstr;
 }
@@ -148,16 +148,16 @@
     match<double>   m2;
     match_policy    mp;
 
-    m0 = mp.no_match();     assert(!m0);
-    m1 = mp.no_match();     assert(!m1);
-    m0 = mp.empty_match();  assert(!!m0);
-    m2 = mp.empty_match();  assert(!!m2);
+    m0 = mp.no_match();     BOOST_TEST(!m0);
+    m1 = mp.no_match();     BOOST_TEST(!m1);
+    m0 = mp.empty_match();  BOOST_TEST(!!m0);
+    m2 = mp.empty_match();  BOOST_TEST(!!m2);
 
     m1 = mp.create_match(5, 100, 0, 0);
     m2 = mp.create_match(5, 10.5, 0, 0);
 
     mp.concat_match(m1, m2);
-    assert(m1.length() == 10);
+    BOOST_TEST(m1.length() == 10);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -170,7 +170,6 @@
 {
     match_tests();
     match_policy_tests();
-    cout << "Tests concluded successfully\n";
-    return 0;
+    return boost::report_errors();
 }
 
Index: libs/spirit/test/multi_pass_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/multi_pass_tests.cpp,v
retrieving revision 1.9
diff -b -d -u -r1.9 multi_pass_tests.cpp
--- libs/spirit/test/multi_pass_tests.cpp	9 Jul 2004 08:30:38 -0000	1.9
+++ libs/spirit/test/multi_pass_tests.cpp	18 Feb 2006 22:55:13 -0000
@@ -10,7 +10,7 @@
 #include <boost/scoped_ptr.hpp>
 #include <iterator>
 #include <string>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 #include "impl/sstream.hpp"
 
 using namespace std;
@@ -170,49 +170,49 @@
         boost::scoped_ptr<default_multi_pass_t> mp1(new default_multi_pass_t(a));
         boost::scoped_ptr<default_multi_pass_t> mp2(new default_multi_pass_t(*mp1));
 
-        assert(*mp1 == *mp2);
-        assert(*mp1 >= *mp2);
-        assert(*mp1 <= *mp2);
+        BOOST_TEST(*mp1 == *mp2);
+        BOOST_TEST(*mp1 >= *mp2);
+        BOOST_TEST(*mp1 <= *mp2);
         for (int i = 0; i < 4; ++i)
         {
             res << **mp1;
             ++*mp1;
         }
 
-        assert(*mp1 != *mp2);
-        assert(*mp1 > *mp2);
-        assert(*mp1 >= *mp2);
-        assert(*mp2 < *mp1);
-        assert(*mp2 <= *mp1);
+        BOOST_TEST(*mp1 != *mp2);
+        BOOST_TEST(*mp1 > *mp2);
+        BOOST_TEST(*mp1 >= *mp2);
+        BOOST_TEST(*mp2 < *mp1);
+        BOOST_TEST(*mp2 <= *mp1);
         while (*mp2 != *mp1)
         {
             res << **mp2;
             ++*mp2;
         }
 
-        assert(*mp1 == *mp2);
-        assert(*mp1 >= *mp2);
-        assert(*mp1 <= *mp2);
+        BOOST_TEST(*mp1 == *mp2);
+        BOOST_TEST(*mp1 >= *mp2);
+        BOOST_TEST(*mp1 <= *mp2);
         while (*mp1 != *mpend)
         {
             res << **mp1;
             ++*mp1;
         }
 
-        assert(*mp1 != *mp2);
-        assert(*mp1 > *mp2);
-        assert(*mp1 >= *mp2);
-        assert(*mp2 < *mp1);
-        assert(*mp2 <= *mp1);
+        BOOST_TEST(*mp1 != *mp2);
+        BOOST_TEST(*mp1 > *mp2);
+        BOOST_TEST(*mp1 >= *mp2);
+        BOOST_TEST(*mp2 < *mp1);
+        BOOST_TEST(*mp2 <= *mp1);
         while (*mp2 != *mpend)
         {
             res << **mp2;
             ++*mp2;
         }
 
-        assert(*mp1 == *mp2);
-        assert(*mp1 >= *mp2);
-        assert(*mp1 <= *mp2);
+        BOOST_TEST(*mp1 == *mp2);
+        BOOST_TEST(*mp1 >= *mp2);
+        BOOST_TEST(*mp1 <= *mp2);
         res << endl;
     }
 
@@ -222,9 +222,9 @@
         istream_iterator<char> a(ss);
         boost::scoped_ptr<default_multi_pass_t> mp1(new default_multi_pass_t(a));
         boost::scoped_ptr<default_multi_pass_t> mp2(new default_multi_pass_t(a));
-        assert(*mp1 != *mp2);
+        BOOST_TEST(*mp1 != *mp2);
         ++*mp1;
-        assert(*mp1 != *mp2);
+        BOOST_TEST(*mp1 != *mp2);
 
     }
 
@@ -253,7 +253,7 @@
         try
         {
             res << **mp3; // this should throw illegal_backtracking
-            assert(0);
+            BOOST_TEST(0);
         }
         catch (const boost::spirit::multi_pass_policies::illegal_backtracking& /*e*/)
         {
@@ -369,49 +369,49 @@
         boost::scoped_ptr<fixed_multi_pass_t> mp1(new fixed_multi_pass_t(a));
         boost::scoped_ptr<fixed_multi_pass_t> mp2(new fixed_multi_pass_t(*mp1));
 
-        assert(*mp1 == *mp2);
-        assert(*mp1 >= *mp2);
-        assert(*mp1 <= *mp2);
+        BOOST_TEST(*mp1 == *mp2);
+        BOOST_TEST(*mp1 >= *mp2);
+        BOOST_TEST(*mp1 <= *mp2);
         for (int i = 0; i < 4; ++i)
         {
             res << **mp1;
             ++*mp1;
         }
 
-        assert(*mp1 != *mp2);
-        assert(*mp1 > *mp2);
-        assert(*mp1 >= *mp2);
-        assert(*mp2 < *mp1);
-        assert(*mp2 <= *mp1);
+        BOOST_TEST(*mp1 != *mp2);
+        BOOST_TEST(*mp1 > *mp2);
+        BOOST_TEST(*mp1 >= *mp2);
+        BOOST_TEST(*mp2 < *mp1);
+        BOOST_TEST(*mp2 <= *mp1);
         while (*mp2 != *mp1)
         {
             res << **mp2;
             ++*mp2;
         }
 
-        assert(*mp1 == *mp2);
-        assert(*mp1 >= *mp2);
-        assert(*mp1 <= *mp2);
+        BOOST_TEST(*mp1 == *mp2);
+        BOOST_TEST(*mp1 >= *mp2);
+        BOOST_TEST(*mp1 <= *mp2);
         while (*mp1 != *mpend)
         {
             res << **mp1;
             ++*mp1;
         }
 
-        assert(*mp1 != *mp2);
-        assert(*mp1 > *mp2);
-        assert(*mp1 >= *mp2);
-        assert(*mp2 < *mp1);
-        assert(*mp2 <= *mp1);
+        BOOST_TEST(*mp1 != *mp2);
+        BOOST_TEST(*mp1 > *mp2);
+        BOOST_TEST(*mp1 >= *mp2);
+        BOOST_TEST(*mp2 < *mp1);
+        BOOST_TEST(*mp2 <= *mp1);
         while (*mp2 != *mpend)
         {
             res << **mp2;
             ++*mp2;
         }
 
-        assert(*mp1 == *mp2);
-        assert(*mp1 >= *mp2);
-        assert(*mp1 <= *mp2);
+        BOOST_TEST(*mp1 == *mp2);
+        BOOST_TEST(*mp1 >= *mp2);
+        BOOST_TEST(*mp1 <= *mp2);
         res << endl;
     }
 
@@ -421,9 +421,9 @@
         istream_iterator<char> a(ss);
         boost::scoped_ptr<fixed_multi_pass_t> mp1(new fixed_multi_pass_t(a));
         boost::scoped_ptr<fixed_multi_pass_t> mp2(new fixed_multi_pass_t(a));
-        assert(*mp1 != *mp2);
+        BOOST_TEST(*mp1 != *mp2);
         ++*mp1;
-        assert(*mp1 != *mp2);
+        BOOST_TEST(*mp1 != *mp2);
 
     }
 
@@ -534,49 +534,49 @@
         boost::scoped_ptr<first_owner_multi_pass_t> mp1(new first_owner_multi_pass_t(a));
         boost::scoped_ptr<first_owner_multi_pass_t> mp2(new first_owner_multi_pass_t(*mp1));
 
-        assert(*mp1 == *mp2);
-        assert(*mp1 >= *mp2);
-        assert(*mp1 <= *mp2);
+        BOOST_TEST(*mp1 == *mp2);
+        BOOST_TEST(*mp1 >= *mp2);
+        BOOST_TEST(*mp1 <= *mp2);
         for (int i = 0; i < 4; ++i)
         {
             res << **mp1;
             ++*mp1;
         }
 
-        assert(*mp1 != *mp2);
-        assert(*mp1 > *mp2);
-        assert(*mp1 >= *mp2);
-        assert(*mp2 < *mp1);
-        assert(*mp2 <= *mp1);
+        BOOST_TEST(*mp1 != *mp2);
+        BOOST_TEST(*mp1 > *mp2);
+        BOOST_TEST(*mp1 >= *mp2);
+        BOOST_TEST(*mp2 < *mp1);
+        BOOST_TEST(*mp2 <= *mp1);
         while (*mp2 != *mp1)
         {
             res << **mp2;
             ++*mp2;
         }
 
-        assert(*mp1 == *mp2);
-        assert(*mp1 >= *mp2);
-        assert(*mp1 <= *mp2);
+        BOOST_TEST(*mp1 == *mp2);
+        BOOST_TEST(*mp1 >= *mp2);
+        BOOST_TEST(*mp1 <= *mp2);
         while (*mp1 != *mpend)
         {
             res << **mp1;
             ++*mp1;
         }
 
-        assert(*mp1 != *mp2);
-        assert(*mp1 > *mp2);
-        assert(*mp1 >= *mp2);
-        assert(*mp2 < *mp1);
-        assert(*mp2 <= *mp1);
+        BOOST_TEST(*mp1 != *mp2);
+        BOOST_TEST(*mp1 > *mp2);
+        BOOST_TEST(*mp1 >= *mp2);
+        BOOST_TEST(*mp2 < *mp1);
+        BOOST_TEST(*mp2 <= *mp1);
         while (*mp2 != *mpend)
         {
             res << **mp2;
             ++*mp2;
         }
 
-        assert(*mp1 == *mp2);
-        assert(*mp1 >= *mp2);
-        assert(*mp1 <= *mp2);
+        BOOST_TEST(*mp1 == *mp2);
+        BOOST_TEST(*mp1 >= *mp2);
+        BOOST_TEST(*mp1 <= *mp2);
         res << endl;
     }
 
@@ -586,9 +586,9 @@
         istream_iterator<char> a(ss);
         boost::scoped_ptr<first_owner_multi_pass_t> mp1(new first_owner_multi_pass_t(a));
         boost::scoped_ptr<first_owner_multi_pass_t> mp2(new first_owner_multi_pass_t(a));
-        assert(*mp1 != *mp2);
+        BOOST_TEST(*mp1 != *mp2);
         ++*mp1;
-        assert(*mp1 != *mp2);
+        BOOST_TEST(*mp1 != *mp2);
 
     }
 
@@ -616,7 +616,7 @@
         try
         {
             res << **mp3; // this should throw illegal_backtracking
-            assert(0);
+            BOOST_TEST(0);
         }
         catch (const boost::spirit::multi_pass_policies::illegal_backtracking& /*e*/)
         {
@@ -672,58 +672,58 @@
         functor_multi_pass_t mp1 = functor_multi_pass_t(my_functor());
         functor_multi_pass_t mp2 = functor_multi_pass_t(mp1);
 
-        assert(mp1 == mp2);
-        assert(mp1 >= mp2);
-        assert(mp1 <= mp2);
+        BOOST_TEST(mp1 == mp2);
+        BOOST_TEST(mp1 >= mp2);
+        BOOST_TEST(mp1 <= mp2);
         for (int i = 0; i < 4; ++i)
         {
             res << *mp1;
             ++mp1;
         }
 
-        assert(mp1 != mp2);
-        assert(mp1 > mp2);
-        assert(mp1 >= mp2);
-        assert(mp2 < mp1);
-        assert(mp2 <= mp1);
+        BOOST_TEST(mp1 != mp2);
+        BOOST_TEST(mp1 > mp2);
+        BOOST_TEST(mp1 >= mp2);
+        BOOST_TEST(mp2 < mp1);
+        BOOST_TEST(mp2 <= mp1);
         while (mp2 != mp1)
         {
             res << *mp2;
             ++mp2;
         }
 
-        assert(mp1 == mp2);
-        assert(mp1 >= mp2);
-        assert(mp1 <= mp2);
+        BOOST_TEST(mp1 == mp2);
+        BOOST_TEST(mp1 >= mp2);
+        BOOST_TEST(mp1 <= mp2);
         while (mp1 != mpend)
         {
             res << *mp1;
             ++mp1;
         }
 
-        assert(mp1 != mp2);
-        assert(mp1 > mp2);
-        assert(mp1 >= mp2);
-        assert(mp2 < mp1);
-        assert(mp2 <= mp1);
+        BOOST_TEST(mp1 != mp2);
+        BOOST_TEST(mp1 > mp2);
+        BOOST_TEST(mp1 >= mp2);
+        BOOST_TEST(mp2 < mp1);
+        BOOST_TEST(mp2 <= mp1);
         while (mp2 != mpend)
         {
             res << *mp2;
             ++mp2;
         }
 
-        assert(mp1 == mp2);
-        assert(mp1 >= mp2);
-        assert(mp1 <= mp2);
+        BOOST_TEST(mp1 == mp2);
+        BOOST_TEST(mp1 >= mp2);
+        BOOST_TEST(mp1 <= mp2);
         res << endl;
     }
 
     {
         functor_multi_pass_t mp1 = functor_multi_pass_t(my_functor());
         functor_multi_pass_t mp2 = functor_multi_pass_t(my_functor());
-        assert(mp1 != mp2);
+        BOOST_TEST(mp1 != mp2);
         ++mp1;
-        assert(mp1 != mp2);
+        BOOST_TEST(mp1 != mp2);
 
     }
 }
@@ -736,7 +736,7 @@
     test_first_owner_multi_pass();
     test_functor_multi_pass();
 
-    assert(getstring(res) == "-*= test_default_multi_pass =*-\n"
+    BOOST_TEST(getstring(res) == "-*= test_default_multi_pass =*-\n"
             "teststring\n"
             "teststring\n"
             "testteststringstring\n"
@@ -761,5 +761,5 @@
             "ABCDABCDEFGHIJKLEFGHIJKL\n"
             "ABCDABCDEFGHIJKLEFGHIJKL\n");
 
-    cout << "Test completed succesfully!" << endl;
+    return boost::report_errors();
 }
Index: libs/spirit/test/numerics_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/numerics_tests.cpp,v
retrieving revision 1.11
diff -b -d -u -r1.11 numerics_tests.cpp
--- libs/spirit/test/numerics_tests.cpp	3 Jul 2005 15:39:31 -0000	1.11
+++ libs/spirit/test/numerics_tests.cpp	18 Feb 2006 22:55:14 -0000
@@ -10,7 +10,7 @@
 #include <boost/spirit/core.hpp>
 #include <boost/spirit/actor/assign_actor.hpp>
 #include <iostream>
-#include <assert.h>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace std;
 using namespace boost::spirit;
@@ -132,76 +132,76 @@
 //  unsigned integer
 
     parse("123456", uint_p[assign_a(u)]);
-    assert(u == 123456);
+    BOOST_TEST(u == 123456);
 
     parse(max_unsigned, uint_p[assign_a(u)]);
-    assert(u == UINT_MAX);
+    BOOST_TEST(u == UINT_MAX);
 
-    assert(!parse(unsigned_overflow, uint_p).full);
+    BOOST_TEST(!parse(unsigned_overflow, uint_p).full);
 
 //  signed integer
 
     int i;
 
     parse("123456", int_p[assign_a(i)]);
-    assert(i == 123456);
+    BOOST_TEST(i == 123456);
 
     parse("-123456", int_p[assign_a(i)]);
-    assert(i == -123456);
+    BOOST_TEST(i == -123456);
 
     parse(max_int, int_p[assign_a(i)]);
-    assert(i == INT_MAX);
+    BOOST_TEST(i == INT_MAX);
 
     parse(min_int, int_p[assign_a(i)]);
-    assert(i == INT_MIN);
+    BOOST_TEST(i == INT_MIN);
 
-    assert(!parse(int_overflow, int_p).full);
-    assert(!parse(int_underflow, int_p).full);
+    BOOST_TEST(!parse(int_overflow, int_p).full);
+    BOOST_TEST(!parse(int_underflow, int_p).full);
 
-    assert(!parse("-", int_p).hit);
+    BOOST_TEST(!parse("-", int_p).hit);
 
 //  binary
 
     parse("11111110", bin_p[assign_a(u)]);
-    assert(u == 0xFE);
+    BOOST_TEST(u == 0xFE);
 
     parse(max_binary, bin_p[assign_a(u)]);
-    assert(u == UINT_MAX);
+    BOOST_TEST(u == UINT_MAX);
 
-    assert(!parse(binary_overflow, bin_p).full);
+    BOOST_TEST(!parse(binary_overflow, bin_p).full);
 
 //  octal
 
     parse("12545674515", oct_p[assign_a(u)]);
-    assert(u == 012545674515);
+    BOOST_TEST(u == 012545674515);
 
     parse(max_octal, oct_p[assign_a(u)]);
-    assert(u == UINT_MAX);
+    BOOST_TEST(u == UINT_MAX);
 
-    assert(!parse(octal_overflow, oct_p).full);
+    BOOST_TEST(!parse(octal_overflow, oct_p).full);
 
 //  hex
 
     parse("95BC8DF", hex_p[assign_a(u)]);
-    assert(u == 0x95BC8DF);
+    BOOST_TEST(u == 0x95BC8DF);
 
     parse("abcdef12", hex_p[assign_a(u)]);
-    assert(u == 0xabcdef12);
+    BOOST_TEST(u == 0xabcdef12);
 
     parse(max_hex, hex_p[assign_a(u)]);
-    assert(u == UINT_MAX);
+    BOOST_TEST(u == UINT_MAX);
 
-    assert(!parse(hex_overflow, hex_p).full);
+    BOOST_TEST(!parse(hex_overflow, hex_p).full);
 
 //  limited fieldwidth
 
     uint_parser<unsigned, 10, 1, 3> uint3_p;
     parse("123456", uint3_p[assign_a(u)]);
-    assert(u == 123);
+    BOOST_TEST(u == 123);
 
     uint_parser<unsigned, 10, 1, 4> uint4_p;
     parse("123456", uint4_p[assign_a(u)]);
-    assert(u == 1234);
+    BOOST_TEST(u == 1234);
 
     uint_parser<unsigned, 10, 3, 3> uint3_3_p;
 
@@ -209,12 +209,12 @@
 
 #define r (uint3_p >> *(',' >> uint3_3_p))
 
-    assert(parse("1,234,567,890", r).full);     //  OK
-    assert(parse("12,345,678,900", r).full);    //  OK
-    assert(parse("123,456,789,000", r).full);   //  OK
-    assert(!parse("1000,234,567,890", r).full); //  Bad
-    assert(!parse("1,234,56,890", r).full);     //  Bad
-    assert(!parse("1,66", r).full);             //  Bad
+    BOOST_TEST(parse("1,234,567,890", r).full);     //  OK
+    BOOST_TEST(parse("12,345,678,900", r).full);    //  OK
+    BOOST_TEST(parse("123,456,789,000", r).full);   //  OK
+    BOOST_TEST(!parse("1000,234,567,890", r).full); //  Bad
+    BOOST_TEST(!parse("1,234,56,890", r).full);     //  Bad
+    BOOST_TEST(!parse("1,66", r).full);             //  Bad
 
 //  long long
 
@@ -234,27 +234,27 @@
     int_parser< ::boost::long_long_type> long_long_p;
 
     parse("1234567890123456789", long_long_p[assign_a(ll)]);
-    assert(ll == 1234567890123456789LL);
+    BOOST_TEST(ll == 1234567890123456789LL);
 
     parse("-1234567890123456789", long_long_p[assign_a(ll)]);
-    assert(ll == -1234567890123456789LL);
+    BOOST_TEST(ll == -1234567890123456789LL);
 
     parse(max_long_long, long_long_p[assign_a(ll)]);
-    assert(ll == LONG_LONG_MAX);
+    BOOST_TEST(ll == LONG_LONG_MAX);
 
     parse(min_long_long, long_long_p[assign_a(ll)]);
-    assert(ll == LONG_LONG_MIN);
+    BOOST_TEST(ll == LONG_LONG_MIN);
 
 #if defined(__GNUG__) && (__GNUG__ == 3) && (__GNUC_MINOR__ < 3) \
     && !defined(__EDG__)
     // gcc 3.2.3 crashes on parse(long_long_overflow, long_long_p)
     // wrapping long_long_p into a rule avoids the crash
     rule<> gcc_3_2_3_long_long_r = long_long_p;
-    assert(!parse(long_long_overflow, gcc_3_2_3_long_long_r).full);
-    assert(!parse(long_long_underflow, gcc_3_2_3_long_long_r).full);
+    BOOST_TEST(!parse(long_long_overflow, gcc_3_2_3_long_long_r).full);
+    BOOST_TEST(!parse(long_long_underflow, gcc_3_2_3_long_long_r).full);
 #else
-    assert(!parse(long_long_overflow, long_long_p).full);
-    assert(!parse(long_long_underflow, long_long_p).full);
+    BOOST_TEST(!parse(long_long_overflow, long_long_p).full);
+    BOOST_TEST(!parse(long_long_underflow, long_long_p).full);
 #endif
 
 #endif
@@ -263,51 +263,50 @@
 
     double  d;
 
-    assert(parse("1234", ureal_p[assign_a(d)]).full && d == 1234);      //  Good.
-    assert(parse("1.2e3", ureal_p[assign_a(d)]).full && d == 1.2e3);    //  Good.
-    assert(parse("1.2e-3", ureal_p[assign_a(d)]).full && d == 1.2e-3);  //  Good.
-    assert(parse("1.e2", ureal_p[assign_a(d)]).full && d == 1.e2);      //  Good.
-    assert(parse(".2e3", ureal_p[assign_a(d)]).full && d == .2e3);      //  Good.
-    assert(parse("2e3", ureal_p[assign_a(d)]).full && d == 2e3);        //  Good. No fraction
-    assert(!parse("e3", ureal_p).full);                                 //  Bad! No number
-    assert(!parse("-1.2e3", ureal_p).full);                             //  Bad! Negative number
-    assert(!parse("+1.2e3", ureal_p).full);                             //  Bad! Positive sign
-    assert(!parse("1.2e", ureal_p).full);                               //  Bad! No exponent
-    assert(!parse("-.3", ureal_p).full);                                //  Bad! Negative
+    BOOST_TEST(parse("1234", ureal_p[assign_a(d)]).full && d == 1234);      //  Good.
+    BOOST_TEST(parse("1.2e3", ureal_p[assign_a(d)]).full && d == 1.2e3);    //  Good.
+    BOOST_TEST(parse("1.2e-3", ureal_p[assign_a(d)]).full && d == 1.2e-3);  //  Good.
+    BOOST_TEST(parse("1.e2", ureal_p[assign_a(d)]).full && d == 1.e2);      //  Good.
+    BOOST_TEST(parse(".2e3", ureal_p[assign_a(d)]).full && d == .2e3);      //  Good.
+    BOOST_TEST(parse("2e3", ureal_p[assign_a(d)]).full && d == 2e3);        //  Good. No fraction
+    BOOST_TEST(!parse("e3", ureal_p).full);                                 //  Bad! No number
+    BOOST_TEST(!parse("-1.2e3", ureal_p).full);                             //  Bad! Negative number
+    BOOST_TEST(!parse("+1.2e3", ureal_p).full);                             //  Bad! Positive sign
+    BOOST_TEST(!parse("1.2e", ureal_p).full);                               //  Bad! No exponent
+    BOOST_TEST(!parse("-.3", ureal_p).full);                                //  Bad! Negative
 
-    assert(parse("-1234", real_p[assign_a(d)]).full && d == -1234);     //  Good.
-    assert(parse("-1.2e3", real_p[assign_a(d)]).full && d == -1.2e3);   //  Good.
-    assert(parse("+1.2e3", real_p[assign_a(d)]).full && d == 1.2e3);    //  Good.
-    assert(parse("-0.1", real_p[assign_a(d)]).full && d == -0.1);       //  Good.
-    assert(parse("-1.2e-3", real_p[assign_a(d)]).full && d == -1.2e-3); //  Good.
-    assert(parse("-1.e2", real_p[assign_a(d)]).full && d == -1.e2);     //  Good.
-    assert(parse("-.2e3", real_p[assign_a(d)]).full && d == -.2e3);     //  Good.
-    assert(parse("-2e3", real_p[assign_a(d)]).full && d == -2e3);       //  Good. No fraction
-    assert(!parse("-e3", real_p).full);                                 //  Bad! No number
-    assert(!parse("-1.2e", real_p).full);                               //  Bad! No exponent
+    BOOST_TEST(parse("-1234", real_p[assign_a(d)]).full && d == -1234);     //  Good.
+    BOOST_TEST(parse("-1.2e3", real_p[assign_a(d)]).full && d == -1.2e3);   //  Good.
+    BOOST_TEST(parse("+1.2e3", real_p[assign_a(d)]).full && d == 1.2e3);    //  Good.
+    BOOST_TEST(parse("-0.1", real_p[assign_a(d)]).full && d == -0.1);       //  Good.
+    BOOST_TEST(parse("-1.2e-3", real_p[assign_a(d)]).full && d == -1.2e-3); //  Good.
+    BOOST_TEST(parse("-1.e2", real_p[assign_a(d)]).full && d == -1.e2);     //  Good.
+    BOOST_TEST(parse("-.2e3", real_p[assign_a(d)]).full && d == -.2e3);     //  Good.
+    BOOST_TEST(parse("-2e3", real_p[assign_a(d)]).full && d == -2e3);       //  Good. No fraction
+    BOOST_TEST(!parse("-e3", real_p).full);                                 //  Bad! No number
+    BOOST_TEST(!parse("-1.2e", real_p).full);                               //  Bad! No exponent
 
-    assert(!parse("1234", strict_ureal_p[assign_a(d)]).full);           //  Bad. Strict real
-    assert(parse("1.2", strict_ureal_p[assign_a(d)]).full && d == 1.2); //  Good.
-    assert(!parse("-1234", strict_real_p[assign_a(d)]).full);           //  Bad. Strict real
-    assert(parse("123.", strict_real_p[assign_a(d)]).full && d == 123); //  Good.
-    assert(parse("3.E6", strict_real_p[assign_a(d)]).full && d == 3e6); //  Good.
+    BOOST_TEST(!parse("1234", strict_ureal_p[assign_a(d)]).full);           //  Bad. Strict real
+    BOOST_TEST(parse("1.2", strict_ureal_p[assign_a(d)]).full && d == 1.2); //  Good.
+    BOOST_TEST(!parse("-1234", strict_real_p[assign_a(d)]).full);           //  Bad. Strict real
+    BOOST_TEST(parse("123.", strict_real_p[assign_a(d)]).full && d == 123); //  Good.
+    BOOST_TEST(parse("3.E6", strict_real_p[assign_a(d)]).full && d == 3e6); //  Good.
 
-    assert(!parse("1234.", notrdot_real_p[assign_a(d)]).full);          //  Bad trailing dot
-    assert(!parse(".1234", nolddot_real_p[assign_a(d)]).full);          //  Bad leading dot
+    BOOST_TEST(!parse("1234.", notrdot_real_p[assign_a(d)]).full);          //  Bad trailing dot
+    BOOST_TEST(!parse(".1234", nolddot_real_p[assign_a(d)]).full);          //  Bad leading dot
 
 //  Special thousands separated numbers
 
-    assert(parse("123,456,789.01", ts_real_p[assign_a(d)]).full && d == 123456789.01);  //  Good.
-    assert(parse("12,345,678.90", ts_real_p[assign_a(d)]).full && d == 12345678.90);    //  Good.
-    assert(parse("1,234,567.89", ts_real_p[assign_a(d)]).full && d == 1234567.89);      //  Good.
-    assert(!parse("1234,567,890", ts_real_p).full);     //  Bad.
-    assert(!parse("1,234,5678,9", ts_real_p).full);     //  Bad.
-    assert(!parse("1,234,567.89e6", ts_real_p).full);   //  Bad.
-    assert(!parse("1,66", ts_real_p).full);             //  Bad.
+    BOOST_TEST(parse("123,456,789.01", ts_real_p[assign_a(d)]).full && d == 123456789.01);  //  Good.
+    BOOST_TEST(parse("12,345,678.90", ts_real_p[assign_a(d)]).full && d == 12345678.90);    //  Good.
+    BOOST_TEST(parse("1,234,567.89", ts_real_p[assign_a(d)]).full && d == 1234567.89);      //  Good.
+    BOOST_TEST(!parse("1234,567,890", ts_real_p).full);     //  Bad.
+    BOOST_TEST(!parse("1,234,5678,9", ts_real_p).full);     //  Bad.
+    BOOST_TEST(!parse("1,234,567.89e6", ts_real_p).full);   //  Bad.
+    BOOST_TEST(!parse("1,66", ts_real_p).full);             //  Bad.
 
 //  END TESTS.
 
 /////////////////////////////////////////////////////////////////
-    cout << "success!\n";
-    return 0;
+    return boost::report_errors();
 }
Index: libs/spirit/test/operators_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/operators_tests.cpp,v
retrieving revision 1.8
diff -b -d -u -r1.8 operators_tests.cpp
--- libs/spirit/test/operators_tests.cpp	2 Feb 2005 12:10:25 -0000	1.8
+++ libs/spirit/test/operators_tests.cpp	18 Feb 2006 22:55:14 -0000
@@ -7,7 +7,7 @@
     http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
 #include <iostream>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace std;
 
@@ -26,129 +26,129 @@
     parse_info<char const*> pi;
 
     pi = parse("Hello World", str_p("Hello ") >> "World");
-    assert(pi.hit);
-    assert(pi.full);
-    assert(pi.length == 11);
-    assert(*pi.stop == 0);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
+    BOOST_TEST(pi.length == 11);
+    BOOST_TEST(*pi.stop == 0);
 
     pi = parse("Banana", str_p("Banana") | "Pineapple");
-    assert(pi.hit);
-    assert(pi.full);
-    assert(pi.length == 6);
-    assert(*pi.stop == 0);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
+    BOOST_TEST(pi.length == 6);
+    BOOST_TEST(*pi.stop == 0);
 
     pi = parse("Pineapple", str_p("Banana") | "Pineapple");
-    assert(pi.hit);
-    assert(pi.full);
-    assert(pi.length == 9);
-    assert(*pi.stop == 0);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
+    BOOST_TEST(pi.length == 9);
+    BOOST_TEST(*pi.stop == 0);
 
     pi = parse("a.2  ", alpha_p || ('.' >> digit_p));
-    assert(pi.hit);
-    assert(pi.length == 3);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.length == 3);
 
     pi = parse("a  ", alpha_p || ('.' >> digit_p));
-    assert(pi.hit);
-    assert(pi.length == 1);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.length == 1);
 
     pi = parse(".1  ", alpha_p || ('.' >> digit_p));
-    assert(pi.hit);
-    assert(pi.length == 2);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.length == 2);
 
     pi = parse("1.a  ", alpha_p || ('.' >> digit_p));
-    assert(!pi.hit);
+    BOOST_TEST(!pi.hit);
 
     pi = parse("abcdefghij", +xdigit_p & +alpha_p);
-    assert(pi.hit);
-    assert(pi.length == 6);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.length == 6);
 
     pi = parse("abcdefghij", +alpha_p & +xdigit_p);
-    assert(!pi.hit);
+    BOOST_TEST(!pi.hit);
 
     pi = parse("abcdefghij", +digit_p & +alpha_p);
-    assert(!pi.hit);
+    BOOST_TEST(!pi.hit);
 
     pi = parse("abcdefghij", +alpha_p & +digit_p);
-    assert(!pi.hit);
+    BOOST_TEST(!pi.hit);
 
     // Test for bug reported by Yusaku Sugai here:
     // http://article.gmane.org/gmane.comp.parsers.spirit.general/8544
     pi = parse( "foo", (anychar_p & anychar_p), ch_p(' ') );
-    assert(pi.hit);
+    BOOST_TEST(pi.hit);
 
     pi = parse("F", xdigit_p - range_p('5','8'));
-    assert(pi.hit);
-    assert(pi.length == 1);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.length == 1);
 
     pi = parse("0", xdigit_p - range_p('5','8'));
-    assert(pi.hit);
-    assert(pi.length == 1);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.length == 1);
 
     pi = parse("4", xdigit_p - range_p('5','8'));
-    assert(pi.hit);
-    assert(pi.length == 1);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.length == 1);
 
     pi = parse("9", xdigit_p - range_p('5','8'));
-    assert(pi.hit);
-    assert(pi.length == 1);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.length == 1);
 
     pi = parse("5", xdigit_p - range_p('5','8'));
-    assert(!pi.hit);
+    BOOST_TEST(!pi.hit);
 
     pi = parse("7", xdigit_p - range_p('5','8'));
-    assert(!pi.hit);
+    BOOST_TEST(!pi.hit);
 
     pi = parse("x*/", anychar_p - "*/");
-    assert(pi.hit);
-    assert(pi.length == 1);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.length == 1);
 
     pi = parse("*/", anychar_p - "*/");
-    assert(!pi.hit);
+    BOOST_TEST(!pi.hit);
 
     pi = parse("switcher  ", str_p("switcher") - "switch");
-    assert(pi.hit);
-    assert(pi.length == 8);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.length == 8);
 
     pi = parse("Z", alpha_p ^ xdigit_p);
-    assert(pi.hit);
-    assert(pi.length == 1);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.length == 1);
 
     pi = parse("1", alpha_p ^ xdigit_p);
-    assert(pi.hit);
-    assert(pi.length == 1);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.length == 1);
 
     pi = parse("B", alpha_p ^ xdigit_p);
-    assert(!pi.hit);
+    BOOST_TEST(!pi.hit);
 
     pi = parse("B", !alpha_p);
-    assert(pi.hit);
-    assert(pi.length == 1);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.length == 1);
 
     pi = parse("1", !alpha_p);
-    assert(pi.hit);
-    assert(pi.length == 0);
-    assert(*pi.stop == '1');
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.length == 0);
+    BOOST_TEST(*pi.stop == '1');
 
     pi = parse("1234 5678 1234 5678", *(+digit_p >> *space_p));
-    assert(pi.hit);
-    assert(pi.full);
-    assert(pi.length == 19);
-    assert(*pi.stop == 0);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
+    BOOST_TEST(pi.length == 19);
+    BOOST_TEST(*pi.stop == 0);
 
     pi = parse("abcdefghijklmnopqrstuvwxyz123", *alpha_p);
-    assert(pi.hit);
-    assert(pi.length == 26);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.length == 26);
 
     pi = parse("1234+5678*1234/5678", +digit_p % (ch_p('+') | '*' | '/'));
-    assert(pi.hit);
-    assert(pi.full);
-    assert(pi.length == 19);
-    assert(*pi.stop == 0);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
+    BOOST_TEST(pi.length == 19);
+    BOOST_TEST(*pi.stop == 0);
 
     pi = parse("1234+", +digit_p % '+');
-    assert(pi.hit);
-    assert(!pi.full);
-    assert(pi.length == 4);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(!pi.full);
+    BOOST_TEST(pi.length == 4);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -160,7 +160,6 @@
 main()
 {
     operators_tests();
-    cout << "Tests concluded successfully\n";
-    return 0;
+    return boost::report_errors();
 }
 
Index: libs/spirit/test/owi_mt_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/owi_mt_tests.cpp,v
retrieving revision 1.14
diff -b -d -u -r1.14 owi_mt_tests.cpp
--- libs/spirit/test/owi_mt_tests.cpp	30 Apr 2005 00:27:19 -0000	1.14
+++ libs/spirit/test/owi_mt_tests.cpp	18 Feb 2006 22:55:14 -0000
@@ -48,7 +48,7 @@
 #include <boost/thread/xtime.hpp>
 #include <vector>
 #include <algorithm>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 using boost::spirit::impl::object_with_id;
 
@@ -184,9 +184,9 @@
 {
 
 
-    assert(test1.data().size()==test_size);
-    assert(test2.data().size()==test_size);
-    assert(test3.data().size()==test_size);
+    BOOST_TEST(test1.data().size()==test_size);
+    BOOST_TEST(test2.data().size()==test_size);
+    BOOST_TEST(test3.data().size()==test_size);
 }
 
 void local_ordering_and_uniqueness()
Index: libs/spirit/test/owi_st_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/owi_st_tests.cpp,v
retrieving revision 1.8
diff -b -d -u -r1.8 owi_st_tests.cpp
--- libs/spirit/test/owi_st_tests.cpp	9 Jul 2004 08:30:38 -0000	1.8
+++ libs/spirit/test/owi_st_tests.cpp	18 Feb 2006 22:55:14 -0000
@@ -10,7 +10,7 @@
 
 #undef BOOST_SPIRIT_THREADSAFE
 #include <boost/spirit/core/non_terminal/impl/object_with_id.ipp>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 #include <iostream>
 
 using boost::spirit::impl::object_with_id;
@@ -36,51 +36,50 @@
     class1 *c1o3 = new class1;
 
     // test wether the objects have consecutive numbers
-    assert(c1o1->get_object_id()==1);
-    assert(c1o2->get_object_id()==2);
-    assert(c1o3->get_object_id()==3);
+    BOOST_TEST(c1o1->get_object_id()==1);
+    BOOST_TEST(c1o2->get_object_id()==2);
+    BOOST_TEST(c1o3->get_object_id()==3);
 
     // test wether number recycling works
     delete c1o3;
     c1o3 = new class1;
-    assert(c1o3->get_object_id()==3);
+    BOOST_TEST(c1o3->get_object_id()==3);
 
     delete c1o2;
     c1o2 = new class1;
-    assert(c1o2->get_object_id()==2);
+    BOOST_TEST(c1o2->get_object_id()==2);
 
     delete c1o2;
     delete c1o3;
     c1o2 = new class1;
     c1o3 = new class1;
-    assert(c1o3->get_object_id()==3);
-    assert(c1o2->get_object_id()==2);
+    BOOST_TEST(c1o3->get_object_id()==3);
+    BOOST_TEST(c1o2->get_object_id()==2);
 
     // test whether objects of different classes are numbered independently
     class2 *c2o1 = new class2;
     class2 *c2o2 = new class2;
     class2 *c2o3 = new class2;
-    assert(c2o1->get_object_id()==1);
-    assert(c2o2->get_object_id()==2);
-    assert(c2o3->get_object_id()==3);
+    BOOST_TEST(c2o1->get_object_id()==1);
+    BOOST_TEST(c2o2->get_object_id()==2);
+    BOOST_TEST(c2o3->get_object_id()==3);
 
     //
     delete c1o1;
     delete c2o2;
     c2o2 = new class2;
     c1o1 = new class1;
-    assert(c1o1->get_object_id()==1);
-    assert(c2o2->get_object_id()==2);
+    BOOST_TEST(c1o1->get_object_id()==1);
+    BOOST_TEST(c2o2->get_object_id()==2);
 
     // test wether the copy ctor doesn't copy the id
     delete c1o1;
     c1o1 = new class1(*c1o2);
-    assert(c1o1->get_object_id()==1);
+    BOOST_TEST(c1o1->get_object_id()==1);
 
     // test wether the assignment operator doesn't assign the id
     *c1o1 = *c1o2;
-    assert(c1o1->get_object_id()==1);
+    BOOST_TEST(c1o1->get_object_id()==1);
 
-    std::cout << "Test concluded successfully\n";
-    return 0;
+    return boost::report_errors();
 }
Index: libs/spirit/test/parametric_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/parametric_tests.cpp,v
retrieving revision 1.10
diff -b -d -u -r1.10 parametric_tests.cpp
--- libs/spirit/test/parametric_tests.cpp	3 Aug 2004 03:45:18 -0000	1.10
+++ libs/spirit/test/parametric_tests.cpp	18 Feb 2006 22:55:14 -0000
@@ -8,7 +8,7 @@
     http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
 #include <iostream>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 #include <string>
 
 using namespace std;
Index: libs/spirit/test/parser_traits_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/parser_traits_tests.cpp,v
retrieving revision 1.7
diff -b -d -u -r1.7 parser_traits_tests.cpp
--- libs/spirit/test/parser_traits_tests.cpp	9 Jul 2004 08:30:38 -0000	1.7
+++ libs/spirit/test/parser_traits_tests.cpp	18 Feb 2006 22:55:14 -0000
@@ -12,7 +12,7 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 #include <iostream>
 #include <boost/spirit/core.hpp>
 #include <boost/spirit/actor/assign_actor.hpp>
@@ -253,20 +253,20 @@
             >::value));
 
 // parser object extraction functions
-    assert(1 == parse("aaaa", get_unary_subject(*ch_p('a'))).length);
+    BOOST_TEST(1 == parse("aaaa", get_unary_subject(*ch_p('a'))).length);
 
 char c = 'b';
 
-    assert(1 == parse("aaaa", get_action_subject(ch_p('a')[assign(c)])).length);
-    assert(c == 'b');
+    BOOST_TEST(1 == parse("aaaa", get_action_subject(ch_p('a')[assign(c)])).length);
+    BOOST_TEST(c == 'b');
 
-    assert(1 == parse("aaaa",
+    BOOST_TEST(1 == parse("aaaa",
         ch_p('a')[ get_semantic_action(ch_p('b')[assign(c)]) ]).length);
-    assert(c == 'a');
+    BOOST_TEST(c == 'a');
 
-    assert(1 == parse("abab",
+    BOOST_TEST(1 == parse("abab",
         get_binary_left_subject(ch_p('a') >> ch_p('b'))).length);
-    assert(1 == parse("baba",
+    BOOST_TEST(1 == parse("baba",
         get_binary_right_subject(ch_p('a') >> ch_p('b'))).length);
 }
 
@@ -281,7 +281,6 @@
     parser_traits_tests();
     parser_extraction_tests();
 
-    cout << "Tests concluded successfully\n";
-    return 0;
+    return boost::report_errors();
 }
 
Index: libs/spirit/test/position_iterator_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/position_iterator_tests.cpp,v
retrieving revision 1.4
diff -b -d -u -r1.4 position_iterator_tests.cpp
--- libs/spirit/test/position_iterator_tests.cpp	9 Jul 2004 08:30:38 -0000	1.4
+++ libs/spirit/test/position_iterator_tests.cpp	18 Feb 2006 22:55:16 -0000
@@ -7,7 +7,7 @@
     http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
 
-#include <assert.h>
+#include <boost/detail/lightweight_test.hpp>
 #include <iostream>
 #include <vector>
 #include <string>
@@ -82,8 +82,7 @@
     CheckColumnCounting();
     CheckLineExtraction();
 
-    cout << "Test completed successfully" << endl;
-    return 0;
+    return boost::report_errors();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -99,39 +98,39 @@
     IterT iter2(iter);
     IterT iter3 = iter;
 
-    assert(iter != end);
-    assert(iter2 != end);
-    assert(iter3 != end);
-    assert(*iter == '0');
+    BOOST_TEST(iter != end);
+    BOOST_TEST(iter2 != end);
+    BOOST_TEST(iter3 != end);
+    BOOST_TEST(*iter == '0');
 
     ++iter;
     ++iter2;
     ++iter3;
-    assert(iter == iter2);
-    assert(iter == iter3);
-    assert(*iter == *iter2);
-    assert(*iter == *iter3);
-    assert(iter.get_position() == iter2.get_position());
-    assert(iter.get_position() == iter3.get_position());
-    assert(*iter == '1');
+    BOOST_TEST(iter == iter2);
+    BOOST_TEST(iter == iter3);
+    BOOST_TEST(*iter == *iter2);
+    BOOST_TEST(*iter == *iter3);
+    BOOST_TEST(iter.get_position() == iter2.get_position());
+    BOOST_TEST(iter.get_position() == iter3.get_position());
+    BOOST_TEST(*iter == '1');
 
-    assert(*iter++ == '1');
-    assert(*iter2++ == '1');
-    assert(*iter3++ == '1');
-    assert(*iter == *iter2);
-    assert(*iter == *iter3);
-    assert(iter.get_position() == iter2.get_position());
-    assert(iter.get_position() == iter3.get_position());
-    assert(*iter == '2');
+    BOOST_TEST(*iter++ == '1');
+    BOOST_TEST(*iter2++ == '1');
+    BOOST_TEST(*iter3++ == '1');
+    BOOST_TEST(*iter == *iter2);
+    BOOST_TEST(*iter == *iter3);
+    BOOST_TEST(iter.get_position() == iter2.get_position());
+    BOOST_TEST(iter.get_position() == iter3.get_position());
+    BOOST_TEST(*iter == '2');
 
     ++iter; ++iter; ++iter; ++iter; ++iter; ++iter; ++iter;
-    assert(*iter == '9');
+    BOOST_TEST(*iter == '9');
     ++iter;
-    assert(iter == end);
+    BOOST_TEST(iter == end);
 
     // Check that one after end is no more end
     ++iter;
-    assert(iter != end);
+    BOOST_TEST(iter != end);
 }
 
 template <typename IterT>
@@ -139,29 +138,29 @@
 {
     IterT end;
 
-    assert(*iter == '\n' || *iter == '\r');
-    assert(iter.get_position().line == 1);
+    BOOST_TEST(*iter == '\n' || *iter == '\r');
+    BOOST_TEST(iter.get_position().line == 1);
     ++iter; // 0
-    assert(iter.get_position().line == 2);
+    BOOST_TEST(iter.get_position().line == 2);
     ++iter; // 1
     ++iter; // 2
     ++iter; // 3
     ++iter; // newline
-    assert(*iter == '\n' || *iter == '\r');
+    BOOST_TEST(*iter == '\n' || *iter == '\r');
     ++iter; // 4
-    assert(iter.get_position().line == 3);
+    BOOST_TEST(iter.get_position().line == 3);
     ++iter; // 5
     ++iter; // 6
     ++iter; // 7
     ++iter; // newline
-    assert(*iter == '\n' || *iter == '\r');
+    BOOST_TEST(*iter == '\n' || *iter == '\r');
     ++iter; // 8
-    assert(iter.get_position().line == 4);
+    BOOST_TEST(iter.get_position().line == 4);
     ++iter; // 9
     ++iter; // newline
-    assert(*iter == '\n' || *iter == '\r');
+    BOOST_TEST(*iter == '\n' || *iter == '\r');
     ++iter; // end
-    assert(iter == end);
+    BOOST_TEST(iter == end);
 }
 
 template <typename IterT>
@@ -171,31 +170,31 @@
 
     // Don't call set_tabchars() here because
     //  default must be 3.
-    assert(*iter == '\t');
-    assert(iter.get_position().column == 1);
+    BOOST_TEST(*iter == '\t');
+    BOOST_TEST(iter.get_position().column == 1);
     ++iter; // 0
-    assert(iter.get_position().column == 5);
+    BOOST_TEST(iter.get_position().column == 5);
     ++iter; // 1
-    assert(iter.get_position().column == 6);
+    BOOST_TEST(iter.get_position().column == 6);
     ++iter; // 2
-    assert(iter.get_position().column == 7);
+    BOOST_TEST(iter.get_position().column == 7);
     ++iter; // 3
-    assert(iter.get_position().column == 8);
+    BOOST_TEST(iter.get_position().column == 8);
     ++iter; // tab
-    assert(*iter == '\t');
-    assert(iter.get_position().column == 9);
+    BOOST_TEST(*iter == '\t');
+    BOOST_TEST(iter.get_position().column == 9);
     ++iter; // 4
-    assert(iter.get_position().column == 13);
+    BOOST_TEST(iter.get_position().column == 13);
     ++iter; // tab
-    assert(*iter == '\t');
-    assert(iter.get_position().column == 14);
+    BOOST_TEST(*iter == '\t');
+    BOOST_TEST(iter.get_position().column == 14);
     ++iter; // 5
-    assert(iter.get_position().column == 17);
+    BOOST_TEST(iter.get_position().column == 17);
     ++iter; // tab
-    assert(*iter == '\t');
-    assert(iter.get_position().column == 18);
+    BOOST_TEST(*iter == '\t');
+    BOOST_TEST(iter.get_position().column == 18);
     ++iter; // end
-    assert(iter == end);
+    BOOST_TEST(iter == end);
 }
 
 template <typename IterT>
@@ -210,34 +209,34 @@
     IterT iter2(iter);
     IterT iter3; iter3 = iter2;
 
-    assert(*iter == '\t');
-    assert(iter.get_position().column == 1);
+    BOOST_TEST(*iter == '\t');
+    BOOST_TEST(iter.get_position().column == 1);
     ++iter; // 0
     ++iter2; ++iter3;
-    assert(iter.get_position().column == 4);
-    assert(iter2.get_position().column == 4);
-    assert(iter3.get_position().column == 4);
+    BOOST_TEST(iter.get_position().column == 4);
+    BOOST_TEST(iter2.get_position().column == 4);
+    BOOST_TEST(iter3.get_position().column == 4);
     ++iter; // 1
-    assert(iter.get_position().column == 5);
+    BOOST_TEST(iter.get_position().column == 5);
     ++iter; // 2
-    assert(iter.get_position().column == 6);
+    BOOST_TEST(iter.get_position().column == 6);
     ++iter; // 3
-    assert(iter.get_position().column == 7);
+    BOOST_TEST(iter.get_position().column == 7);
     ++iter; // tab
-    assert(*iter == '\t');
-    assert(iter.get_position().column == 8);
+    BOOST_TEST(*iter == '\t');
+    BOOST_TEST(iter.get_position().column == 8);
     ++iter; // 4
-    assert(iter.get_position().column == 10);
+    BOOST_TEST(iter.get_position().column == 10);
     ++iter; // tab
-    assert(*iter == '\t');
-    assert(iter.get_position().column == 11);
+    BOOST_TEST(*iter == '\t');
+    BOOST_TEST(iter.get_position().column == 11);
     ++iter; // 5
-    assert(iter.get_position().column == 13);
+    BOOST_TEST(iter.get_position().column == 13);
     ++iter; // tab
-    assert(*iter == '\t');
-    assert(iter.get_position().column == 14);
+    BOOST_TEST(*iter == '\t');
+    BOOST_TEST(iter.get_position().column == 14);
     ++iter; // end
-    assert(iter == end);
+    BOOST_TEST(iter == end);
 }
 
 const string line1 = "abcd";
@@ -247,7 +246,7 @@
 template <typename IterT>
 void AssertIterString(IterT begin, IterT end, string s)
 {
-    assert(string(begin, end) == s);
+    BOOST_TEST(string(begin, end) == s);
 }
 
 template <typename IterT>
@@ -257,15 +256,15 @@
 
     // At the start, we are on a newline, which is an empty
     //  string
-    assert(iter.get_currentline() == string());
-    assert(
+    BOOST_TEST(iter.get_currentline() == string());
+    BOOST_TEST(
         string(iter.get_currentline_begin(), iter.get_currentline_end())
         == string());
 
     ++iter; // a
     ++iter; // b
     ++iter; // c
-    assert(iter.get_currentline() == line1);
+    BOOST_TEST(iter.get_currentline() == line1);
     AssertIterString(
         iter.get_currentline_begin(),
         iter.get_currentline_end(),
@@ -279,8 +278,8 @@
     //  not interfere with get_currentline
     IterT iter2(iter);
     IterT iter3; iter3 = iter;
-    assert(iter2.get_currentline() == line2);
-    assert(iter3.get_currentline() == line2);
+    BOOST_TEST(iter2.get_currentline() == line2);
+    BOOST_TEST(iter3.get_currentline() == line2);
     AssertIterString(
         iter2.get_currentline_begin(),
         iter2.get_currentline_end(),
@@ -296,14 +295,14 @@
     ++iter; // newline
 
     // Check when the iterator is on a newline
-    assert(iter.get_currentline() == line2);
+    BOOST_TEST(iter.get_currentline() == line2);
     AssertIterString(
         iter.get_currentline_begin(),
         iter.get_currentline_end(),
         line2);
 
     ++iter;
-    assert(iter == end);
+    BOOST_TEST(iter == end);
 }
 
 
@@ -332,9 +331,9 @@
     iter_t iter2(iter);
     iter_t iter3; iter3 = iter;
 
-    assert(iter == iter_t());
-    assert(iter2 == iter_t());
-    assert(iter3 == iter_t());
+    BOOST_TEST(iter == iter_t());
+    BOOST_TEST(iter2 == iter_t());
+    BOOST_TEST(iter3 == iter_t());
 }
 
 template <typename IterC, typename Iter>
@@ -348,31 +347,31 @@
     typedef IterC iterc_t;
     typedef Iter iter_t;
 
-    assert(iterc_t(a,a+20,name).get_position() == posc);
-    assert(iterc_t(a,a+20,name,1).get_position() == posc);
-    assert(iterc_t(a,a+20,name,1,1).get_position() == posc);
-    assert(iterc_t(a,a+20,posc).get_position() == posc);
-    assert(iter_t(a,a+20,name).get_position() == pos);
-    assert(iter_t(a,a+20,name,1).get_position() == pos);
-    assert(iter_t(a,a+20,pos).get_position() == pos);
+    BOOST_TEST(iterc_t(a,a+20,name).get_position() == posc);
+    BOOST_TEST(iterc_t(a,a+20,name,1).get_position() == posc);
+    BOOST_TEST(iterc_t(a,a+20,name,1,1).get_position() == posc);
+    BOOST_TEST(iterc_t(a,a+20,posc).get_position() == posc);
+    BOOST_TEST(iter_t(a,a+20,name).get_position() == pos);
+    BOOST_TEST(iter_t(a,a+20,name,1).get_position() == pos);
+    BOOST_TEST(iter_t(a,a+20,pos).get_position() == pos);
 
     // Check copy constructor and assignment. Notice that we want
     //  an implicit copy constructor.
     iterc_t ic1(a,a+20,name);
     iterc_t ic2 = ic1;
     iterc_t ic3; ic3 = ic1;
-    assert(ic1 == ic2);
-    assert(ic1 == ic3);
-    assert(ic1.get_position() == ic2.get_position());
-    assert(ic1.get_position() == ic3.get_position());
+    BOOST_TEST(ic1 == ic2);
+    BOOST_TEST(ic1 == ic3);
+    BOOST_TEST(ic1.get_position() == ic2.get_position());
+    BOOST_TEST(ic1.get_position() == ic3.get_position());
 
     iter_t i1(a,a+20,name);
     iter_t i2 = i1;
     iter_t i3; i3 = i1;
-    assert(i1 == i2);
-    assert(i1 == i3);
-    assert(i1.get_position() == i2.get_position());
-    assert(i1.get_position() == i3.get_position());
+    BOOST_TEST(i1 == i2);
+    BOOST_TEST(i1 == i3);
+    BOOST_TEST(i1.get_position() == i2.get_position());
+    BOOST_TEST(i1.get_position() == i3.get_position());
 
     // Check construction with an empty sequence
     CheckEmptySequence<iter_t>();
Index: libs/spirit/test/repeat_ast_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/repeat_ast_tests.cpp,v
retrieving revision 1.1
diff -b -d -u -r1.1 repeat_ast_tests.cpp
--- libs/spirit/test/repeat_ast_tests.cpp	10 Jul 2004 08:37:43 -0000	1.1
+++ libs/spirit/test/repeat_ast_tests.cpp	18 Feb 2006 22:55:16 -0000
@@ -10,7 +10,7 @@
 // This test verifies, that reapeat_p et.al. work correctly while using AST's
 
 # include <map>
-# include <cassert>
+# include <boost/detail/lightweight_test.hpp>
 # include <iostream>
 # include <string>
 
@@ -76,7 +76,7 @@
 // case 1
     grammar_fail g_fail;
     tree_parse_info<> info1 = ast_parse(test.c_str(), g_fail, space_p);
-    assert(info1.full);
+    BOOST_TEST(info1.full);
 
     //std::cout << "...Case 1: Using repeat_p\n";
     //tree_to_xml(std::cerr, info1.trees, test, rule_names);
@@ -84,11 +84,12 @@
 // case 2
     grammar_success g_success;
     tree_parse_info<> info2 = ast_parse(test.c_str(), g_success, space_p);
-    assert(info2.full);
+    BOOST_TEST(info2.full);
 
     //std::cout << "...Case 2: No repeat_p\n";
     //tree_to_xml(std::cerr, info2.trees, test, rule_names);
     // could be used for test case instead of printing the xml stuff:
-    assert(info2.trees.begin()->children.size() == 2);
-    assert(info1.trees.begin()->children.size() == 2);
+    BOOST_TEST(info2.trees.begin()->children.size() == 2);
+    BOOST_TEST(info1.trees.begin()->children.size() == 2);
+    return boost::report_errors();
 }
Index: libs/spirit/test/rule_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/rule_tests.cpp,v
retrieving revision 1.10
diff -b -d -u -r1.10 rule_tests.cpp
--- libs/spirit/test/rule_tests.cpp	9 Jul 2004 08:30:38 -0000	1.10
+++ libs/spirit/test/rule_tests.cpp	18 Feb 2006 22:55:16 -0000
@@ -7,7 +7,7 @@
     http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
 #include <iostream>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace std;
 
@@ -46,17 +46,17 @@
 
     start = *(a | b | c);
     pi = parse("abcabcacb", d);
-    assert(pi.hit);
-    assert(pi.full);
-    assert(pi.length == 9);
-    assert(*pi.stop == 0);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
+    BOOST_TEST(pi.length == 9);
+    BOOST_TEST(*pi.stop == 0);
 
     start   = (a | b) >> (start | b);
     pi = parse("aaaabababaaabbb", d);
-    assert(pi.hit);
-    assert(pi.full);
-    assert(pi.length == 15);
-    assert(*pi.stop == 0);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
+    BOOST_TEST(pi.length == 15);
+    BOOST_TEST(*pi.stop == 0);
 }
 
 void
@@ -114,13 +114,13 @@
         typedef scanner_list<scanner<>, phrase_scanner_t> scanners;
 
         rule<scanners>  r = +anychar_p;
-        assert(parse("abcdefghijk", r).full);
-        assert(parse("a b c d e f g h i j k", r, space_p).full);
+        BOOST_TEST(parse("abcdefghijk", r).full);
+        BOOST_TEST(parse("a b c d e f g h i j k", r, space_p).full);
     }
 
     { // 3 scanners
         my_grammar g;
-        assert(parse("abcdef aBc d e f aBc d E f", g, space_p).full);
+        BOOST_TEST(parse("abcdef aBc d e f aBc d E f", g, space_p).full);
     }
 }
 
@@ -142,22 +142,22 @@
     BOOST_SPIRIT_DEBUG_RULE(start);
 
     pi = parse("abcabcacb", start);
-    assert(pi.hit);
-    assert(pi.full);
-    assert(pi.length == 9);
-    assert(*pi.stop == 0);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
+    BOOST_TEST(pi.length == 9);
+    BOOST_TEST(*pi.stop == 0);
 
     start   = (a | b) >> (start | b);
     pi = parse("aaaabababaaabbb", start);
-    assert(pi.hit);
-    assert(pi.full);
-    assert(pi.length == 15);
-    assert(*pi.stop == 0);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
+    BOOST_TEST(pi.length == 15);
+    BOOST_TEST(*pi.stop == 0);
 
     pi = parse("aaaabababaaabba", start);
-    assert(pi.hit);
-    assert(!pi.full);
-    assert(pi.length == 14);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(!pi.full);
+    BOOST_TEST(pi.length == 14);
 }
 
 void
@@ -178,22 +178,22 @@
     BOOST_SPIRIT_DEBUG_RULE(start);
 
     pi = parse("abcabcacb", start);
-    assert(pi.hit);
-    assert(pi.full);
-    assert(pi.length == 9);
-    assert(*pi.stop == 0);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
+    BOOST_TEST(pi.length == 9);
+    BOOST_TEST(*pi.stop == 0);
 
     start   = (a | b) >> (start | b);
     pi = parse("aaaabababaaabbb", start);
-    assert(pi.hit);
-    assert(pi.full);
-    assert(pi.length == 15);
-    assert(*pi.stop == 0);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
+    BOOST_TEST(pi.length == 15);
+    BOOST_TEST(*pi.stop == 0);
 
     pi = parse("aaaabababaaabba", start);
-    assert(pi.hit);
-    assert(!pi.full);
-    assert(pi.length == 14);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(!pi.full);
+    BOOST_TEST(pi.length == 14);
 }
 
 void
@@ -220,10 +220,10 @@
     BOOST_SPIRIT_DEBUG_RULE(start);
 
     pi = parse("abcabcacb", start);
-    assert(pi.hit);
-    assert(pi.full);
-    assert(pi.length == 9);
-    assert(*pi.stop == 0);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
+    BOOST_TEST(pi.length == 9);
+    BOOST_TEST(*pi.stop == 0);
 
     // The FF is the dynamic equivalent of start = (a | b) >> (start | b);
     start = b;
@@ -231,15 +231,15 @@
     start = start.copy() >> (start | b);
 
     pi = parse("aaaabababaaabbb", start);
-    assert(pi.hit);
-    assert(pi.full);
-    assert(pi.length == 15);
-    assert(*pi.stop == 0);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
+    BOOST_TEST(pi.length == 15);
+    BOOST_TEST(*pi.stop == 0);
 
     pi = parse("aaaabababaaabba", start);
-    assert(pi.hit);
-    assert(!pi.full);
-    assert(pi.length == 14);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(!pi.full);
+    BOOST_TEST(pi.length == 14);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -257,7 +257,6 @@
     stored_rule_basic_tests();
     stored_rule_dynamic_tests();
 
-    cout << "Tests concluded successfully\n";
-    return 0;
+    return boost::report_errors();
 }
 
Index: libs/spirit/test/scanner_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/scanner_tests.cpp,v
retrieving revision 1.10
diff -b -d -u -r1.10 scanner_tests.cpp
--- libs/spirit/test/scanner_tests.cpp	3 Aug 2004 03:45:18 -0000	1.10
+++ libs/spirit/test/scanner_tests.cpp	18 Feb 2006 22:55:16 -0000
@@ -7,7 +7,7 @@
     http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
 #include <iostream>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 #include <list>
 
 using namespace std;
@@ -94,7 +94,7 @@
     while (!pp3.at_end())
     {
         cout << *pp3;
-        assert(!test_islower(*pp3));
+        BOOST_TEST(!test_islower(*pp3));
         ++pp3;
     }
     cout << '\n';
@@ -110,7 +110,7 @@
     while (!pp4.at_end())
     {
         cout << *pp4;
-        assert(!test_isspace(*pp4));
+        BOOST_TEST(!test_isspace(*pp4));
         ++pp4;
     }
     cout << '\n';
@@ -119,12 +119,12 @@
     cout << "sizeof(scanner<>) == " << sizeof(scanner<>) << '\n';
 
     parse_info<> pi = parse("12abcdefg12345ABCDEFG789", +digit_p, alpha_p);
-    assert(pi.hit);
-    assert(pi.full);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
 
     pi = parse("abcdefg12345ABCDEFG789", +digit_p, alpha_p);
-    assert(pi.hit);
-    assert(pi.full);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -136,7 +136,6 @@
 main()
 {
     scanner_tests();
-    cout << "Tests concluded successfully\n";
-    return 0;
+    return boost::report_errors();
 }
 
Index: libs/spirit/test/scoped_lock_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/scoped_lock_tests.cpp,v
retrieving revision 1.10
diff -b -d -u -r1.10 scoped_lock_tests.cpp
--- libs/spirit/test/scoped_lock_tests.cpp	9 Aug 2004 04:23:52 -0000	1.10
+++ libs/spirit/test/scoped_lock_tests.cpp	18 Feb 2006 22:55:16 -0000
@@ -36,7 +36,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/spirit/core.hpp>
 #include <boost/spirit/utility/scoped_lock.hpp>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 int
 main()
@@ -52,12 +52,10 @@
     mutex m;
     rule<> r = scoped_lock_d(m)['x'];
     parse_info<> pi = parse("x", r);
-    assert(pi.hit);
-    assert(pi.full);
-
-    std::cout  << "Test concluded successfully\n";
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
 
-    return 0;
+    return boost::report_errors();
 }
 
 #endif // defined(DONT_HAVE_BOOST)
Index: libs/spirit/test/subrule_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/subrule_tests.cpp,v
retrieving revision 1.7
diff -b -d -u -r1.7 subrule_tests.cpp
--- libs/spirit/test/subrule_tests.cpp	9 Jul 2004 08:30:39 -0000	1.7
+++ libs/spirit/test/subrule_tests.cpp	18 Feb 2006 22:55:16 -0000
@@ -7,7 +7,7 @@
     http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
 #include <iostream>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace std;
 
@@ -37,10 +37,10 @@
         )
     );
 
-    assert(pi.hit);
-    assert(pi.full);
-    assert(pi.length == 9);
-    assert(*pi.stop == 0);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
+    BOOST_TEST(pi.length == 9);
+    BOOST_TEST(*pi.stop == 0);
 
     pi = parse("aaaabababaaabbb",
         (
@@ -50,10 +50,10 @@
         )
     );
 
-    assert(pi.hit);
-    assert(pi.full);
-    assert(pi.length == 15);
-    assert(*pi.stop == 0);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
+    BOOST_TEST(pi.length == 15);
+    BOOST_TEST(*pi.stop == 0);
 
     pi = parse("aaaabababaaabba",
         (
@@ -63,9 +63,9 @@
         )
     );
 
-    assert(pi.hit);
-    assert(!pi.full);
-    assert(pi.length == 14);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(!pi.full);
+    BOOST_TEST(pi.length == 14);
 
     pi = parse("aaaabababaaabbb",
 
@@ -73,10 +73,10 @@
         start = (ch_p('a') | 'b') >> (start | 'b')
     );
 
-    assert(pi.hit);
-    assert(pi.full);
-    assert(pi.length == 15);
-    assert(*pi.stop == 0);
+    BOOST_TEST(pi.hit);
+    BOOST_TEST(pi.full);
+    BOOST_TEST(pi.length == 15);
+    BOOST_TEST(*pi.stop == 0);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -88,7 +88,6 @@
 main()
 {
     subrules_tests();
-    cout << "Tests concluded successfully\n";
-    return 0;
+    return boost::report_errors();
 }
 
Index: libs/spirit/test/switch_tests_eps_default.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/switch_tests_eps_default.cpp,v
retrieving revision 1.6
diff -b -d -u -r1.6 switch_tests_eps_default.cpp
--- libs/spirit/test/switch_tests_eps_default.cpp	18 Oct 2005 10:00:15 -0000	1.6
+++ libs/spirit/test/switch_tests_eps_default.cpp	18 Feb 2006 22:55:16 -0000
@@ -7,7 +7,7 @@
     http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
 #include <iostream>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace std;
 
@@ -255,29 +255,29 @@
         {
             GrammarT g;
             
-            assert(parse("a1", g).full);
-            assert(!parse("a,", g).hit);
-            assert(!parse("abcd", g).hit);
+            BOOST_TEST(parse("a1", g).full);
+            BOOST_TEST(!parse("a,", g).hit);
+            BOOST_TEST(!parse("abcd", g).hit);
             
-            assert(parse("a 1", g, space_p).full);
-            assert(!parse("a ,", g, space_p).hit);
-            assert(!parse("a bcd", g, space_p).hit);
+            BOOST_TEST(parse("a 1", g, space_p).full);
+            BOOST_TEST(!parse("a ,", g, space_p).hit);
+            BOOST_TEST(!parse("a bcd", g, space_p).hit);
             
-            assert(!parse("b1", g).hit);
-            assert(parse("b,", g).full);
-            assert(!parse("bbcd", g).hit);
+            BOOST_TEST(!parse("b1", g).hit);
+            BOOST_TEST(parse("b,", g).full);
+            BOOST_TEST(!parse("bbcd", g).hit);
             
-            assert(!parse("b 1", g, space_p).hit);
-            assert(parse("b ,", g, space_p).full);
-            assert(!parse("b bcd", g, space_p).hit);
+            BOOST_TEST(!parse("b 1", g, space_p).hit);
+            BOOST_TEST(parse("b ,", g, space_p).full);
+            BOOST_TEST(!parse("b bcd", g, space_p).hit);
             
-            assert(!parse("c1", g).hit);
-            assert(!parse("c,", g).hit);
-            assert(parse("cbcd", g).full);
+            BOOST_TEST(!parse("c1", g).hit);
+            BOOST_TEST(!parse("c,", g).hit);
+            BOOST_TEST(parse("cbcd", g).full);
             
-            assert(!parse("c 1", g, space_p).hit);
-            assert(!parse("c ,", g, space_p).hit);
-            assert(parse("c bcd", g, space_p).full);
+            BOOST_TEST(!parse("c 1", g, space_p).hit);
+            BOOST_TEST(!parse("c ,", g, space_p).hit);
+            BOOST_TEST(parse("c bcd", g, space_p).full);
         }
     };
 
@@ -290,8 +290,8 @@
         {
             GrammarT g;
             
-            assert(parse("d", g).full);
-            assert(parse(" d", g, space_p).full); // JDG 10-18-2005 removed trailing ' ' to
+            BOOST_TEST(parse("d", g).full);
+            BOOST_TEST(parse(" d", g, space_p).full); // JDG 10-18-2005 removed trailing ' ' to
                                                   // avoid post skip problems
         }
     };
@@ -324,5 +324,5 @@
     boost::mpl::for_each<default_epsilon_list_t>(
         tests::check_grammar_default_plain());
 
-    return 0;
+    return boost::report_errors();
 }
Index: libs/spirit/test/switch_tests_general_def.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/switch_tests_general_def.cpp,v
retrieving revision 1.1
diff -b -d -u -r1.1 switch_tests_general_def.cpp
--- libs/spirit/test/switch_tests_general_def.cpp	13 Sep 2004 09:24:06 -0000	1.1
+++ libs/spirit/test/switch_tests_general_def.cpp	18 Feb 2006 22:55:16 -0000
@@ -7,7 +7,7 @@
     http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
 #include <iostream>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace std;
 
@@ -256,29 +256,29 @@
         {
             GrammarT g;
             
-            assert(parse("a1", g).full);
-            assert(!parse("a,", g).hit);
-            assert(!parse("abcd", g).hit);
+            BOOST_TEST(parse("a1", g).full);
+            BOOST_TEST(!parse("a,", g).hit);
+            BOOST_TEST(!parse("abcd", g).hit);
             
-            assert(parse("a 1", g, space_p).full);
-            assert(!parse("a ,", g, space_p).hit);
-            assert(!parse("a bcd", g, space_p).hit);
+            BOOST_TEST(parse("a 1", g, space_p).full);
+            BOOST_TEST(!parse("a ,", g, space_p).hit);
+            BOOST_TEST(!parse("a bcd", g, space_p).hit);
             
-            assert(!parse("b1", g).hit);
-            assert(parse("b,", g).full);
-            assert(!parse("bbcd", g).hit);
+            BOOST_TEST(!parse("b1", g).hit);
+            BOOST_TEST(parse("b,", g).full);
+            BOOST_TEST(!parse("bbcd", g).hit);
             
-            assert(!parse("b 1", g, space_p).hit);
-            assert(parse("b ,", g, space_p).full);
-            assert(!parse("b bcd", g, space_p).hit);
+            BOOST_TEST(!parse("b 1", g, space_p).hit);
+            BOOST_TEST(parse("b ,", g, space_p).full);
+            BOOST_TEST(!parse("b bcd", g, space_p).hit);
             
-            assert(!parse("c1", g).hit);
-            assert(!parse("c,", g).hit);
-            assert(parse("cbcd", g).full);
+            BOOST_TEST(!parse("c1", g).hit);
+            BOOST_TEST(!parse("c,", g).hit);
+            BOOST_TEST(parse("cbcd", g).full);
             
-            assert(!parse("c 1", g, space_p).hit);
-            assert(!parse("c ,", g, space_p).hit);
-            assert(parse("c bcd", g, space_p).full);
+            BOOST_TEST(!parse("c 1", g, space_p).hit);
+            BOOST_TEST(!parse("c ,", g, space_p).hit);
+            BOOST_TEST(parse("c bcd", g, space_p).full);
         }
     };
 
@@ -290,13 +290,13 @@
         {
             GrammarT g;
             
-            assert(!parse("d1", g).hit);
-            assert(!parse("d,", g).hit);
-            assert(!parse("dbcd", g).hit);
+            BOOST_TEST(!parse("d1", g).hit);
+            BOOST_TEST(!parse("d,", g).hit);
+            BOOST_TEST(!parse("dbcd", g).hit);
 
-            assert(!parse("d 1", g, space_p).hit);
-            assert(!parse("d ,", g, space_p).hit);
-            assert(!parse("d bcd", g, space_p).hit);
+            BOOST_TEST(!parse("d 1", g, space_p).hit);
+            BOOST_TEST(!parse("d ,", g, space_p).hit);
+            BOOST_TEST(!parse("d bcd", g, space_p).hit);
         }
     };
     
@@ -308,8 +308,8 @@
         {
             GrammarT g;
             
-            assert(parse("ddefault", g).full);
-            assert(parse("d default", g, space_p).full);
+            BOOST_TEST(parse("ddefault", g).full);
+            BOOST_TEST(parse("d default", g, space_p).full);
         }
     };
     
@@ -340,5 +340,5 @@
     boost::mpl::for_each<default_list_t>(tests::check_grammar_unknown_default());
     boost::mpl::for_each<default_list_t>(tests::check_grammar_default());
 
-    return 0;
+    return boost::report_errors();
 }
Index: libs/spirit/test/switch_tests_single.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/switch_tests_single.cpp,v
retrieving revision 1.6
diff -b -d -u -r1.6 switch_tests_single.cpp
--- libs/spirit/test/switch_tests_single.cpp	18 Oct 2005 10:00:15 -0000	1.6
+++ libs/spirit/test/switch_tests_single.cpp	18 Feb 2006 22:55:16 -0000
@@ -7,7 +7,7 @@
     http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
 #include <iostream>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace std;
 
@@ -228,29 +228,29 @@
         {
             GrammarT g;
             
-            assert(!parse("a1", g).hit);
-            assert(!parse("a,", g).hit);
-            assert(!parse("abcd", g).hit);
+            BOOST_TEST(!parse("a1", g).hit);
+            BOOST_TEST(!parse("a,", g).hit);
+            BOOST_TEST(!parse("abcd", g).hit);
             
-            assert(!parse("a 1", g, space_p).hit);
-            assert(!parse("a ,", g, space_p).hit);
-            assert(!parse("a bcd", g, space_p).hit);
+            BOOST_TEST(!parse("a 1", g, space_p).hit);
+            BOOST_TEST(!parse("a ,", g, space_p).hit);
+            BOOST_TEST(!parse("a bcd", g, space_p).hit);
             
-            assert(!parse("b1", g).hit);
-            assert(!parse("b,", g).hit);
-            assert(!parse("bbcd", g).hit);
+            BOOST_TEST(!parse("b1", g).hit);
+            BOOST_TEST(!parse("b,", g).hit);
+            BOOST_TEST(!parse("bbcd", g).hit);
             
-            assert(!parse("b 1", g, space_p).hit);
-            assert(!parse("b ,", g, space_p).hit);
-            assert(!parse("b bcd", g, space_p).hit);
+            BOOST_TEST(!parse("b 1", g, space_p).hit);
+            BOOST_TEST(!parse("b ,", g, space_p).hit);
+            BOOST_TEST(!parse("b bcd", g, space_p).hit);
             
-            assert(!parse("c1", g).hit);
-            assert(!parse("c,", g).hit);
-            assert(!parse("cbcd", g).hit);
+            BOOST_TEST(!parse("c1", g).hit);
+            BOOST_TEST(!parse("c,", g).hit);
+            BOOST_TEST(!parse("cbcd", g).hit);
             
-            assert(!parse("c 1", g, space_p).hit);
-            assert(!parse("c ,", g, space_p).hit);
-            assert(!parse("c bcd", g, space_p).hit);
+            BOOST_TEST(!parse("c 1", g, space_p).hit);
+            BOOST_TEST(!parse("c ,", g, space_p).hit);
+            BOOST_TEST(!parse("c bcd", g, space_p).hit);
         }
     };
 
@@ -262,8 +262,8 @@
         {
             GrammarT g;
             
-            assert(parse("ddefault", g).full);
-            assert(parse("d default", g, space_p).full);
+            BOOST_TEST(parse("ddefault", g).full);
+            BOOST_TEST(parse("d default", g, space_p).full);
         }
     };
     
@@ -275,8 +275,8 @@
         {
             GrammarT g;
             
-            assert(parse("d", g).full);
-            assert(parse(" d", g, space_p).full); // JDG 10-18-2005 removed trailing ' ' to
+            BOOST_TEST(parse("d", g).full);
+            BOOST_TEST(parse(" d", g, space_p).full); // JDG 10-18-2005 removed trailing ' ' to
                                                   // avoid post skip problems
         }
     };
@@ -289,29 +289,29 @@
         {
             GrammarT g;
 
-            assert(parse("a1", g).full);
-            assert(!parse("a,", g).hit);
-            assert(!parse("abcd", g).hit);
+            BOOST_TEST(parse("a1", g).full);
+            BOOST_TEST(!parse("a,", g).hit);
+            BOOST_TEST(!parse("abcd", g).hit);
 
-            assert(parse("a 1", g, space_p).full);
-            assert(!parse("a ,", g, space_p).hit);
-            assert(!parse("a bcd", g, space_p).hit);
+            BOOST_TEST(parse("a 1", g, space_p).full);
+            BOOST_TEST(!parse("a ,", g, space_p).hit);
+            BOOST_TEST(!parse("a bcd", g, space_p).hit);
 
-            assert(!parse("b1", g).hit);
-            assert(!parse("b,", g).hit);
-            assert(!parse("bbcd", g).hit);
+            BOOST_TEST(!parse("b1", g).hit);
+            BOOST_TEST(!parse("b,", g).hit);
+            BOOST_TEST(!parse("bbcd", g).hit);
             
-            assert(!parse("b 1", g, space_p).hit);
-            assert(!parse("b ,", g, space_p).hit);
-            assert(!parse("b bcd", g, space_p).hit);
+            BOOST_TEST(!parse("b 1", g, space_p).hit);
+            BOOST_TEST(!parse("b ,", g, space_p).hit);
+            BOOST_TEST(!parse("b bcd", g, space_p).hit);
             
-            assert(!parse("c1", g).hit);
-            assert(!parse("c,", g).hit);
-            assert(!parse("cbcd", g).hit);
+            BOOST_TEST(!parse("c1", g).hit);
+            BOOST_TEST(!parse("c,", g).hit);
+            BOOST_TEST(!parse("cbcd", g).hit);
             
-            assert(!parse("c 1", g, space_p).hit);
-            assert(!parse("c ,", g, space_p).hit);
-            assert(!parse("c bcd", g, space_p).hit);
+            BOOST_TEST(!parse("c 1", g, space_p).hit);
+            BOOST_TEST(!parse("c ,", g, space_p).hit);
+            BOOST_TEST(!parse("c bcd", g, space_p).hit);
         }
     };
     
@@ -347,5 +347,5 @@
     boost::mpl::for_each<default_plain_single_t>(
         tests::check_grammar_default_plain());
     
-    return 0;
+    return boost::report_errors();
 }
Index: libs/spirit/test/switch_tests_wo_default.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/switch_tests_wo_default.cpp,v
retrieving revision 1.7
diff -b -d -u -r1.7 switch_tests_wo_default.cpp
--- libs/spirit/test/switch_tests_wo_default.cpp	18 Oct 2005 10:00:15 -0000	1.7
+++ libs/spirit/test/switch_tests_wo_default.cpp	18 Feb 2006 22:55:16 -0000
@@ -7,7 +7,7 @@
     http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
 #include <iostream>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace std;
 
@@ -120,48 +120,48 @@
         {
             GrammarT g;
             
-            assert(parse("a1", g).full);
-            assert(!parse("a,", g).hit);
-            assert(!parse("abcd", g).hit);
-            assert(!parse("a", g).hit);
+            BOOST_TEST(parse("a1", g).full);
+            BOOST_TEST(!parse("a,", g).hit);
+            BOOST_TEST(!parse("abcd", g).hit);
+            BOOST_TEST(!parse("a", g).hit);
             
-            assert(parse("a 1", g, space_p).full);
-            assert(!parse("a ,", g, space_p).hit);
-            assert(!parse("a bcd", g, space_p).hit);
-            assert(!parse("a ", g, space_p).hit);
+            BOOST_TEST(parse("a 1", g, space_p).full);
+            BOOST_TEST(!parse("a ,", g, space_p).hit);
+            BOOST_TEST(!parse("a bcd", g, space_p).hit);
+            BOOST_TEST(!parse("a ", g, space_p).hit);
             
-            assert(!parse("b1", g).hit);
-            assert(parse("b,", g).full);
-            assert(!parse("bbcd", g).hit);
-            assert(!parse("b", g).hit);
+            BOOST_TEST(!parse("b1", g).hit);
+            BOOST_TEST(parse("b,", g).full);
+            BOOST_TEST(!parse("bbcd", g).hit);
+            BOOST_TEST(!parse("b", g).hit);
             
-            assert(!parse("b 1", g, space_p).hit);
-            assert(parse("b ,", g, space_p).full);
-            assert(!parse("b bcd", g, space_p).hit);
-            assert(!parse("b ", g, space_p).hit);
+            BOOST_TEST(!parse("b 1", g, space_p).hit);
+            BOOST_TEST(parse("b ,", g, space_p).full);
+            BOOST_TEST(!parse("b bcd", g, space_p).hit);
+            BOOST_TEST(!parse("b ", g, space_p).hit);
             
-            assert(!parse("c1", g).hit);
-            assert(!parse("c,", g).hit);
-            assert(parse("cbcd", g).full);
-            assert(!parse("c", g).hit);
+            BOOST_TEST(!parse("c1", g).hit);
+            BOOST_TEST(!parse("c,", g).hit);
+            BOOST_TEST(parse("cbcd", g).full);
+            BOOST_TEST(!parse("c", g).hit);
             
-            assert(!parse("c 1", g, space_p).hit);
-            assert(!parse("c ,", g, space_p).hit);
-            assert(parse("c bcd", g, space_p).full);
-            assert(!parse("c ", g, space_p).hit);
+            BOOST_TEST(!parse("c 1", g, space_p).hit);
+            BOOST_TEST(!parse("c ,", g, space_p).hit);
+            BOOST_TEST(parse("c bcd", g, space_p).full);
+            BOOST_TEST(!parse("c ", g, space_p).hit);
             
-            assert(parse("d1", g).hit);
-            assert(parse("d,", g).hit);
-            assert(parse("dbcd", g).hit);
-            assert(parse("d", g).full);
+            BOOST_TEST(parse("d1", g).hit);
+            BOOST_TEST(parse("d,", g).hit);
+            BOOST_TEST(parse("dbcd", g).hit);
+            BOOST_TEST(parse("d", g).full);
             
-            assert(parse("d 1", g, space_p).hit);
-            assert(parse("d ,", g, space_p).hit);
-            assert(parse("d bcd", g, space_p).hit);
-            assert(parse(" d", g, space_p).full); // JDG 10-18-2005 removed trailing ' ' to
+            BOOST_TEST(parse("d 1", g, space_p).hit);
+            BOOST_TEST(parse("d ,", g, space_p).hit);
+            BOOST_TEST(parse("d bcd", g, space_p).hit);
+            BOOST_TEST(parse(" d", g, space_p).full); // JDG 10-18-2005 removed trailing ' ' to
                                                   // avoid post skip problems
 
-            assert(parse(" a 1 b , c bcd d", *g, space_p).full); 
+            BOOST_TEST(parse(" a 1 b , c bcd d", *g, space_p).full); 
             // JDG 10-18-2005 removed trailing ' ' to avoid post skip problems
         }
     };
@@ -174,13 +174,13 @@
         {
             GrammarT g;
             
-            assert(!parse("x1", g).hit);
-            assert(!parse("x,", g).hit);
-            assert(!parse("xbcd", g).hit);
+            BOOST_TEST(!parse("x1", g).hit);
+            BOOST_TEST(!parse("x,", g).hit);
+            BOOST_TEST(!parse("xbcd", g).hit);
 
-            assert(!parse("x 1", g, space_p).hit);
-            assert(!parse("x ,", g, space_p).hit);
-            assert(!parse("x bcd", g, space_p).hit);
+            BOOST_TEST(!parse("x 1", g, space_p).hit);
+            BOOST_TEST(!parse("x ,", g, space_p).hit);
+            BOOST_TEST(!parse("x bcd", g, space_p).hit);
         }
     };
        
@@ -199,5 +199,5 @@
     boost::mpl::for_each<grammar_list_t>(tests::check_grammar_known());
     boost::mpl::for_each<grammar_list_t>(tests::check_grammar_unknown_default());
 
-    return 0;
+    return boost::report_errors();
 }
Index: libs/spirit/test/symbols_add_null.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/symbols_add_null.cpp,v
retrieving revision 1.3
diff -b -d -u -r1.3 symbols_add_null.cpp
--- libs/spirit/test/symbols_add_null.cpp	23 Mar 2005 12:57:28 -0000	1.3
+++ libs/spirit/test/symbols_add_null.cpp	18 Feb 2006 22:55:16 -0000
@@ -23,7 +23,7 @@
 #include <boost/spirit/symbols/impl/tst.ipp>
 #include <boost/utility/addressof.hpp>
 
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 
 typedef char char_type;
 typedef char const * iterator;
@@ -49,7 +49,7 @@
     {
         // It is not ok to add strings containing the null character.
         symbols_.add(begin, end, (void*) boost::addressof(symbols_));
-        assert(0);
+        BOOST_TEST(0);
     }
     catch (spirit_exception &e)
     {
@@ -59,9 +59,10 @@
     {
         // It is not ok to add strings containing the null character.
         symbols_.add(begin2, end2, (void*) boost::addressof(symbols_));
-        assert(0);
+        BOOST_TEST(0);
     }
     catch (spirit_exception &e)
     {
     }
+    return boost::report_errors();
 }
Index: libs/spirit/test/symbols_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/symbols_tests.cpp,v
retrieving revision 1.10
diff -b -d -u -r1.10 symbols_tests.cpp
--- libs/spirit/test/symbols_tests.cpp	28 Sep 2004 01:33:14 -0000	1.10
+++ libs/spirit/test/symbols_tests.cpp	18 Feb 2006 22:55:16 -0000
@@ -9,7 +9,7 @@
 =============================================================================*/
 #include <iostream>
 #include <string>
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 #include <boost/spirit/core.hpp>
 #include <boost/spirit/symbols/symbols.hpp>
 #include <boost/detail/lightweight_test.hpp>
Index: libs/spirit/test/traverse_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/traverse_tests.cpp,v
retrieving revision 1.8
diff -b -d -u -r1.8 traverse_tests.cpp
--- libs/spirit/test/traverse_tests.cpp	9 Jul 2004 08:30:39 -0000	1.8
+++ libs/spirit/test/traverse_tests.cpp	18 Feb 2006 22:55:16 -0000
@@ -12,7 +12,7 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include <cassert>
+#include <boost/detail/lightweight_test.hpp>
 #include <iostream>
 #include <string>
 #include <vector>
@@ -67,13 +67,13 @@
     ));
 
     //  test (rough) runtime equality
-    assert(
+    BOOST_TEST(
         parse(
             "ab",
             post_order::traverse(identity_transform(), ch_p('a') >> 'b')
         ).full
     );
-    assert(
+    BOOST_TEST(
         !parse(
             "ba",
             post_order::traverse(identity_transform(), ch_p('a') >> 'b')
@@ -81,7 +81,7 @@
     );
 
     ///////////////////////////////////////////////////////////////////////////
-    assert(
+    BOOST_TEST(
         !parse(
             "cba",
             post_order::traverse(
@@ -117,7 +117,7 @@
     ));
 
     c = 0;
-    assert(
+    BOOST_TEST(
         parse(
             "aabcd",
             post_order::traverse(
@@ -126,7 +126,7 @@
             )
         ).full
     );
-    assert(c == 'b');
+    BOOST_TEST(c == 'b');
 
 ///////////////////////////////////////////////////////////////////////////////
 //  test: (a >> (b >> c)) >> d
@@ -150,7 +150,7 @@
     ));
 
     c = 0;
-    assert(
+    BOOST_TEST(
         parse(
             "aabcd",
             post_order::traverse(
@@ -159,7 +159,7 @@
             )
         ).full
     );
-    assert(c == 'b');
+    BOOST_TEST(c == 'b');
 
 ///////////////////////////////////////////////////////////////////////////////
 //  test: a >> (b >> (c >> d))
@@ -183,7 +183,7 @@
     ));
 
     c = 0;
-    assert(
+    BOOST_TEST(
         parse(
             "aabcd",
             post_order::traverse(
@@ -192,7 +192,7 @@
             )
         ).full
     );
-    assert(c == 'b');
+    BOOST_TEST(c == 'b');
 
 ///////////////////////////////////////////////////////////////////////////////
 //  test: a >> ((b >> c) >> d)
@@ -216,7 +216,7 @@
     ));
 
     c = 0;
-    assert(
+    BOOST_TEST(
         parse(
             "aabcd",
             post_order::traverse(
@@ -225,7 +225,7 @@
             )
         ).full
     );
-    assert(c == 'b');
+    BOOST_TEST(c == 'b');
 
 ///////////////////////////////////////////////////////////////////////////////
 //  test: (a >> b) >> (c >> d)
@@ -249,7 +249,7 @@
     ));
 
     c = 0;
-    assert(
+    BOOST_TEST(
         parse(
             "aabcd",
             post_order::traverse(
@@ -258,7 +258,7 @@
             )
         ).full
     );
-    assert(c == 'b');
+    BOOST_TEST(c == 'b');
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -363,13 +363,13 @@
 std::vector<std::string>::const_iterator it = trace_vector.get_output().begin();
 std::vector<std::string>::const_iterator end = trace_vector.get_output().end();
 
-    assert(cnt == trace_vector.get_output().size());
+    BOOST_TEST(cnt == trace_vector.get_output().size());
     for (/**/;  it != end; ++it)
     {
         if (std::find(first, first + cnt, *it) == first + cnt)
             cerr << "node in question: " << *it << endl;
 
-        assert(std::find(first, first + cnt, *it) != first + cnt);
+        BOOST_TEST(std::find(first, first + cnt, *it) != first + cnt);
     }
 
 // re-find all expected strings in the vector of trace strings
@@ -381,7 +381,7 @@
         if (std::find(begin, end, std::string(expected)) == end)
             cerr << "node in question: " << expected << endl;
 
-        assert(std::find(begin, end, std::string(expected)) != end);
+        BOOST_TEST(std::find(begin, end, std::string(expected)) != end);
     }
 }
 
@@ -510,7 +510,6 @@
     traverse_identity_tests();
     traverse_trace_tests();
 
-    cout << "Tests concluded successfully\n";
-    return 0;
+    return boost::report_errors();
 }
 
Index: libs/spirit/test/tree_tests.cpp
===================================================================
RCS file: /cvsroot/boost/boost/libs/spirit/test/tree_tests.cpp,v
retrieving revision 1.5
diff -b -d -u -r1.5 tree_tests.cpp
--- libs/spirit/test/tree_tests.cpp	3 Aug 2004 03:45:18 -0000	1.5
+++ libs/spirit/test/tree_tests.cpp	18 Feb 2006 22:55:16 -0000
@@ -23,7 +23,7 @@
 #include <string>
 
 #include <fstream>
-#include <assert.h>
+#include <boost/detail/lightweight_test.hpp>
 #include "impl/string_length.hpp"
 
 #define DEBUG_DUMP_TREES    (1)
@@ -335,7 +335,7 @@
         tree_parse_info<iterator_t, factory_t> info =
             ast_parse(text_begin, text_end, gram);
 
-        assert(info.full);
+        BOOST_TEST(info.full);
 
         tree_t expected = gram.template expected_tree<tree_t>();
 
@@ -344,7 +344,7 @@
         dump(cout, expected);
 #endif
 
-        assert(equal(info.trees[0], expected));
+        BOOST_TEST(equal(info.trees[0], expected));
     }
 };
 
@@ -357,7 +357,7 @@
     void throw_exception(std::exception const & )
     {
         std::cerr << "Exception caught" << std::endl;
-        assert(0);
+        BOOST_TEST(0);
     }
 }
 
@@ -379,7 +379,5 @@
 
     mpl::for_each<tests_t, mpl::_> (run_test());
 
-    cout << "Test completed successfully" << endl;
-
-    return 0;
+    return boost::report_errors();
 }