diff --git a/shared_ptr_mt_test.cpp b/shared_ptr_mt_test.cpp
index 185bd99..52828f5 100644
--- a/shared_ptr_mt_test.cpp
+++ b/shared_ptr_mt_test.cpp
@@ -19,9 +19,6 @@
 #include <boost/shared_ptr.hpp>
 #include <boost/bind.hpp>
 
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-
 #include <vector>
 #include <memory>
 #include <stdexcept>
@@ -153,7 +150,7 @@ int const m = 16; // threads
     char const * implementation = "spinlock";
 #endif
 
-int test_main( int, char ** )
+int main()
 {
     std::printf("%s: %s, %d threads, %d iterations: ", title, implementation, m, n);
 
diff --git a/shared_ptr_test.cpp b/shared_ptr_test.cpp
index 883d870..56f6e46 100644
--- a/shared_ptr_test.cpp
+++ b/shared_ptr_test.cpp
@@ -16,8 +16,7 @@
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #include <boost/shared_ptr.hpp>
 #include <boost/weak_ptr.hpp>
@@ -197,7 +196,7 @@ template<class T> void test_is_nonzero(boost::shared_ptr<T> const & p)
     BOOST_TEST(p.get() != 0);
 }
 
-int test_main(int, char * [])
+int main()
 {
     using namespace boost;
 
@@ -369,5 +368,5 @@ int test_main(int, char * [])
 
     BOOST_TEST(cnt == 0);
 
-    return 0;
+    return boost::report_errors();
 }
diff --git a/smart_ptr_test.cpp b/smart_ptr_test.cpp
index 79edf7e..eead369 100644
--- a/smart_ptr_test.cpp
+++ b/smart_ptr_test.cpp
@@ -18,8 +18,7 @@
 #include <boost/shared_ptr.hpp>
 #include <boost/shared_array.hpp>
 
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #include <cstring>
 #include <iostream>
@@ -84,212 +83,214 @@ Incomplete * check_incomplete( shared_ptr<Incomplete>& incomplete,
   cout << incomplete.use_count() << ' ' << incomplete.unique() << '\n';
   return incomplete.get();
 }
-//  main  --------------------------------------------------------------------//
 
 //  This isn't a very systematic test; it just hits some of the basics.
 
-int test_main( int, char *[] ) {
+void test()
+{
+    BOOST_TEST( UDT_use_count == 0 );  // reality check
 
-  BOOST_TEST( UDT_use_count == 0 );  // reality check
+    //  test scoped_ptr with a built-in type
+    long * lp = new long;
+    scoped_ptr<long> sp ( lp );
+    BOOST_TEST( sp.get() == lp );
+    BOOST_TEST( lp == sp.get() );
+    BOOST_TEST( &*sp == lp );
 
-  //  test scoped_ptr with a built-in type
-  long * lp = new long;
-  scoped_ptr<long> sp ( lp );
-  BOOST_TEST( sp.get() == lp );
-  BOOST_TEST( lp == sp.get() );
-  BOOST_TEST( &*sp == lp );
+    *sp = 1234568901L;
+    BOOST_TEST( *sp == 1234568901L );
+    BOOST_TEST( *lp == 1234568901L );
+    ck( static_cast<long*>(sp.get()), 1234568901L );
+    ck( lp, *sp );
 
-  *sp = 1234568901L;
-  BOOST_TEST( *sp == 1234568901L );
-  BOOST_TEST( *lp == 1234568901L );
-  ck( static_cast<long*>(sp.get()), 1234568901L );
-  ck( lp, *sp );
+    sp.reset();
+    BOOST_TEST( sp.get() == 0 );
 
-  sp.reset();
-  BOOST_TEST( sp.get() == 0 );
+    //  test scoped_ptr with a user defined type
+    scoped_ptr<UDT> udt_sp ( new UDT( 999888777 ) );
+    BOOST_TEST( udt_sp->value() == 999888777 );
+    udt_sp.reset();
+    udt_sp.reset( new UDT( 111222333 ) );
+    BOOST_TEST( udt_sp->value() == 111222333 );
+    udt_sp.reset( new UDT( 333222111 ) );
+    BOOST_TEST( udt_sp->value() == 333222111 );
 
-  //  test scoped_ptr with a user defined type
-  scoped_ptr<UDT> udt_sp ( new UDT( 999888777 ) );
-  BOOST_TEST( udt_sp->value() == 999888777 );
-  udt_sp.reset();
-  udt_sp.reset( new UDT( 111222333 ) );
-  BOOST_TEST( udt_sp->value() == 111222333 );
-  udt_sp.reset( new UDT( 333222111 ) );
-  BOOST_TEST( udt_sp->value() == 333222111 );
+    //  test scoped_array with a build-in type
+    char * sap = new char [ 100 ];
+    scoped_array<char> sa ( sap );
+    BOOST_TEST( sa.get() == sap );
+    BOOST_TEST( sap == sa.get() );
 
-  //  test scoped_array with a build-in type
-  char * sap = new char [ 100 ];
-  scoped_array<char> sa ( sap );
-  BOOST_TEST( sa.get() == sap );
-  BOOST_TEST( sap == sa.get() );
+    strcpy( sa.get(), "Hot Dog with mustard and relish" );
+    BOOST_TEST( strcmp( sa.get(), "Hot Dog with mustard and relish" ) == 0 );
+    BOOST_TEST( strcmp( sap, "Hot Dog with mustard and relish" ) == 0 );
 
-  strcpy( sa.get(), "Hot Dog with mustard and relish" );
-  BOOST_TEST( strcmp( sa.get(), "Hot Dog with mustard and relish" ) == 0 );
-  BOOST_TEST( strcmp( sap, "Hot Dog with mustard and relish" ) == 0 );
+    BOOST_TEST( sa[0] == 'H' );
+    BOOST_TEST( sa[30] == 'h' );
 
-  BOOST_TEST( sa[0] == 'H' );
-  BOOST_TEST( sa[30] == 'h' );
+    sa[0] = 'N';
+    sa[4] = 'd';
+    BOOST_TEST( strcmp( sap, "Not dog with mustard and relish" ) == 0 );
 
-  sa[0] = 'N';
-  sa[4] = 'd';
-  BOOST_TEST( strcmp( sap, "Not dog with mustard and relish" ) == 0 );
+    sa.reset();
+    BOOST_TEST( sa.get() == 0 );
 
-  sa.reset();
-  BOOST_TEST( sa.get() == 0 );
+    //  test shared_ptr with a built-in type
+    int * ip = new int;
+    shared_ptr<int> cp ( ip );
+    BOOST_TEST( ip == cp.get() );
+    BOOST_TEST( cp.use_count() == 1 );
 
-  //  test shared_ptr with a built-in type
-  int * ip = new int;
-  shared_ptr<int> cp ( ip );
-  BOOST_TEST( ip == cp.get() );
-  BOOST_TEST( cp.use_count() == 1 );
+    *cp = 54321;
+    BOOST_TEST( *cp == 54321 );
+    BOOST_TEST( *ip == 54321 );
+    ck( static_cast<int*>(cp.get()), 54321 );
+    ck( static_cast<int*>(ip), *cp );
 
-  *cp = 54321;
-  BOOST_TEST( *cp == 54321 );
-  BOOST_TEST( *ip == 54321 );
-  ck( static_cast<int*>(cp.get()), 54321 );
-  ck( static_cast<int*>(ip), *cp );
+    shared_ptr<int> cp2 ( cp );
+    BOOST_TEST( ip == cp2.get() );
+    BOOST_TEST( cp.use_count() == 2 );
+    BOOST_TEST( cp2.use_count() == 2 );
 
-  shared_ptr<int> cp2 ( cp );
-  BOOST_TEST( ip == cp2.get() );
-  BOOST_TEST( cp.use_count() == 2 );
-  BOOST_TEST( cp2.use_count() == 2 );
+    BOOST_TEST( *cp == 54321 );
+    BOOST_TEST( *cp2 == 54321 );
+    ck( static_cast<int*>(cp2.get()), 54321 );
+    ck( static_cast<int*>(ip), *cp2 );
 
-  BOOST_TEST( *cp == 54321 );
-  BOOST_TEST( *cp2 == 54321 );
-  ck( static_cast<int*>(cp2.get()), 54321 );
-  ck( static_cast<int*>(ip), *cp2 );
-  
-  shared_ptr<int> cp3 ( cp );
-  BOOST_TEST( cp.use_count() == 3 );
-  BOOST_TEST( cp2.use_count() == 3 );
-  BOOST_TEST( cp3.use_count() == 3 );
-  cp.reset();
-  BOOST_TEST( cp2.use_count() == 2 );
-  BOOST_TEST( cp3.use_count() == 2 );
-  BOOST_TEST( cp.use_count() == 1 );
-  cp.reset( new int );
-  *cp =  98765;
-  BOOST_TEST( *cp == 98765 );
-  *cp3 = 87654;
-  BOOST_TEST( *cp3 == 87654 );
-  BOOST_TEST( *cp2 == 87654 );
-  cp.swap( cp3 );
-  BOOST_TEST( *cp == 87654 );
-  BOOST_TEST( *cp2 == 87654 );
-  BOOST_TEST( *cp3 == 98765 );
-  cp.swap( cp3 );
-  BOOST_TEST( *cp == 98765 );
-  BOOST_TEST( *cp2 == 87654 );
-  BOOST_TEST( *cp3 == 87654 );
-  cp2 = cp2;
-  BOOST_TEST( cp2.use_count() == 2 );
-  BOOST_TEST( *cp2 == 87654 );
-  cp = cp2;
-  BOOST_TEST( cp2.use_count() == 3 );
-  BOOST_TEST( *cp2 == 87654 );
-  BOOST_TEST( cp.use_count() == 3 );
-  BOOST_TEST( *cp == 87654 );
-  
-  shared_ptr<int> cp4;
-  swap( cp2, cp4 );
-  BOOST_TEST( cp4.use_count() == 3 );
-  BOOST_TEST( *cp4 == 87654 );
-  BOOST_TEST( cp2.get() == 0 );
-  
-  set< shared_ptr<int> > scp;
-  scp.insert(cp4);
-  BOOST_TEST( scp.find(cp4) != scp.end() );
-  BOOST_TEST( scp.find(cp4) == scp.find( shared_ptr<int>(cp4) ) );
+    shared_ptr<int> cp3 ( cp );
+    BOOST_TEST( cp.use_count() == 3 );
+    BOOST_TEST( cp2.use_count() == 3 );
+    BOOST_TEST( cp3.use_count() == 3 );
+    cp.reset();
+    BOOST_TEST( cp2.use_count() == 2 );
+    BOOST_TEST( cp3.use_count() == 2 );
+    BOOST_TEST( cp.use_count() == 1 );
+    cp.reset( new int );
+    *cp =  98765;
+    BOOST_TEST( *cp == 98765 );
+    *cp3 = 87654;
+    BOOST_TEST( *cp3 == 87654 );
+    BOOST_TEST( *cp2 == 87654 );
+    cp.swap( cp3 );
+    BOOST_TEST( *cp == 87654 );
+    BOOST_TEST( *cp2 == 87654 );
+    BOOST_TEST( *cp3 == 98765 );
+    cp.swap( cp3 );
+    BOOST_TEST( *cp == 98765 );
+    BOOST_TEST( *cp2 == 87654 );
+    BOOST_TEST( *cp3 == 87654 );
+    cp2 = cp2;
+    BOOST_TEST( cp2.use_count() == 2 );
+    BOOST_TEST( *cp2 == 87654 );
+    cp = cp2;
+    BOOST_TEST( cp2.use_count() == 3 );
+    BOOST_TEST( *cp2 == 87654 );
+    BOOST_TEST( cp.use_count() == 3 );
+    BOOST_TEST( *cp == 87654 );
 
-  //  test shared_array with a built-in type
-  char * cap = new char [ 100 ];
-  shared_array<char> ca ( cap );
-  BOOST_TEST( ca.get() == cap );
-  BOOST_TEST( cap == ca.get() );
-  BOOST_TEST( &ca[0] == cap );
+    shared_ptr<int> cp4;
+    swap( cp2, cp4 );
+    BOOST_TEST( cp4.use_count() == 3 );
+    BOOST_TEST( *cp4 == 87654 );
+    BOOST_TEST( cp2.get() == 0 );
 
-  strcpy( ca.get(), "Hot Dog with mustard and relish" );
-  BOOST_TEST( strcmp( ca.get(), "Hot Dog with mustard and relish" ) == 0 );
-  BOOST_TEST( strcmp( cap, "Hot Dog with mustard and relish" ) == 0 );
+    set< shared_ptr<int> > scp;
+    scp.insert(cp4);
+    BOOST_TEST( scp.find(cp4) != scp.end() );
+    BOOST_TEST( scp.find(cp4) == scp.find( shared_ptr<int>(cp4) ) );
 
-  BOOST_TEST( ca[0] == 'H' );
-  BOOST_TEST( ca[30] == 'h' );
-  
-  shared_array<char> ca2 ( ca );
-  shared_array<char> ca3 ( ca2 );
+    //  test shared_array with a built-in type
+    char * cap = new char [ 100 ];
+    shared_array<char> ca ( cap );
+    BOOST_TEST( ca.get() == cap );
+    BOOST_TEST( cap == ca.get() );
+    BOOST_TEST( &ca[0] == cap );
 
-  ca[0] = 'N';
-  ca[4] = 'd';
-  BOOST_TEST( strcmp( ca.get(), "Not dog with mustard and relish" ) == 0 );
-  BOOST_TEST( strcmp( ca2.get(), "Not dog with mustard and relish" ) == 0 );
-  BOOST_TEST( strcmp( ca3.get(), "Not dog with mustard and relish" ) == 0 );
-  BOOST_TEST( ca.use_count() == 3 );
-  BOOST_TEST( ca2.use_count() == 3 );
-  BOOST_TEST( ca3.use_count() == 3 );
-  ca2.reset();
-  BOOST_TEST( ca.use_count() == 2 );
-  BOOST_TEST( ca3.use_count() == 2 );
-  BOOST_TEST( ca2.use_count() == 1 );
+    strcpy( ca.get(), "Hot Dog with mustard and relish" );
+    BOOST_TEST( strcmp( ca.get(), "Hot Dog with mustard and relish" ) == 0 );
+    BOOST_TEST( strcmp( cap, "Hot Dog with mustard and relish" ) == 0 );
 
-  ca.reset();
-  BOOST_TEST( ca.get() == 0 );
+    BOOST_TEST( ca[0] == 'H' );
+    BOOST_TEST( ca[30] == 'h' );
 
-  shared_array<char> ca4;
-  swap( ca3, ca4 );
-  BOOST_TEST( ca4.use_count() == 1 );
-  BOOST_TEST( strcmp( ca4.get(), "Not dog with mustard and relish" ) == 0 );
-  BOOST_TEST( ca3.get() == 0 );
-  
-  set< shared_array<char> > sca;
-  sca.insert(ca4);
-  BOOST_TEST( sca.find(ca4) != sca.end() );
-  BOOST_TEST( sca.find(ca4) == sca.find( shared_array<char>(ca4) ) );
+    shared_array<char> ca2 ( ca );
+    shared_array<char> ca3 ( ca2 );
 
-  //  test shared_array with user defined type
-  shared_array<UDT> udta ( new UDT[3] );
+    ca[0] = 'N';
+    ca[4] = 'd';
+    BOOST_TEST( strcmp( ca.get(), "Not dog with mustard and relish" ) == 0 );
+    BOOST_TEST( strcmp( ca2.get(), "Not dog with mustard and relish" ) == 0 );
+    BOOST_TEST( strcmp( ca3.get(), "Not dog with mustard and relish" ) == 0 );
+    BOOST_TEST( ca.use_count() == 3 );
+    BOOST_TEST( ca2.use_count() == 3 );
+    BOOST_TEST( ca3.use_count() == 3 );
+    ca2.reset();
+    BOOST_TEST( ca.use_count() == 2 );
+    BOOST_TEST( ca3.use_count() == 2 );
+    BOOST_TEST( ca2.use_count() == 1 );
 
-  udta[0].value( 111 );
-  udta[1].value( 222 );
-  udta[2].value( 333 );
-  shared_array<UDT> udta2 ( udta );
+    ca.reset();
+    BOOST_TEST( ca.get() == 0 );
 
-  BOOST_TEST( udta[0].value() == 111 );
-  BOOST_TEST( udta[1].value() == 222 );
-  BOOST_TEST( udta[2].value() == 333 );
-  BOOST_TEST( udta2[0].value() == 111 );
-  BOOST_TEST( udta2[1].value() == 222 );
-  BOOST_TEST( udta2[2].value() == 333 );
-  udta2.reset();
-  BOOST_TEST( udta2.get() == 0 );
-  BOOST_TEST( udta.use_count() == 1 );
-  BOOST_TEST( udta2.use_count() == 1 );
+    shared_array<char> ca4;
+    swap( ca3, ca4 );
+    BOOST_TEST( ca4.use_count() == 1 );
+    BOOST_TEST( strcmp( ca4.get(), "Not dog with mustard and relish" ) == 0 );
+    BOOST_TEST( ca3.get() == 0 );
 
-  BOOST_TEST( UDT_use_count == 4 );  // reality check
+    set< shared_array<char> > sca;
+    sca.insert(ca4);
+    BOOST_TEST( sca.find(ca4) != sca.end() );
+    BOOST_TEST( sca.find(ca4) == sca.find( shared_array<char>(ca4) ) );
 
-  //  test shared_ptr with a user defined type
-  UDT * up = new UDT;
-  shared_ptr<UDT> sup ( up );
-  BOOST_TEST( up == sup.get() );
-  BOOST_TEST( sup.use_count() == 1 );
+    //  test shared_array with user defined type
+    shared_array<UDT> udta ( new UDT[3] );
 
-  sup->value( 54321 ) ;
-  BOOST_TEST( sup->value() == 54321 );
-  BOOST_TEST( up->value() == 54321 );
+    udta[0].value( 111 );
+    udta[1].value( 222 );
+    udta[2].value( 333 );
+    shared_array<UDT> udta2 ( udta );
 
-  shared_ptr<UDT> sup2;
-  sup2 = sup;
-  BOOST_TEST( sup2->value() == 54321 );
-  BOOST_TEST( sup.use_count() == 2 );
-  BOOST_TEST( sup2.use_count() == 2 );
-  sup2 = sup2;
-  BOOST_TEST( sup2->value() == 54321 );
-  BOOST_TEST( sup.use_count() == 2 );
-  BOOST_TEST( sup2.use_count() == 2 );
+    BOOST_TEST( udta[0].value() == 111 );
+    BOOST_TEST( udta[1].value() == 222 );
+    BOOST_TEST( udta[2].value() == 333 );
+    BOOST_TEST( udta2[0].value() == 111 );
+    BOOST_TEST( udta2[1].value() == 222 );
+    BOOST_TEST( udta2[2].value() == 333 );
+    udta2.reset();
+    BOOST_TEST( udta2.get() == 0 );
+    BOOST_TEST( udta.use_count() == 1 );
+    BOOST_TEST( udta2.use_count() == 1 );
 
-  cout << "OK\n";
+    BOOST_TEST( UDT_use_count == 4 );  // reality check
 
-  new char[12345]; // deliberate memory leak to verify leaks detected
+    //  test shared_ptr with a user defined type
+    UDT * up = new UDT;
+    shared_ptr<UDT> sup ( up );
+    BOOST_TEST( up == sup.get() );
+    BOOST_TEST( sup.use_count() == 1 );
 
-  return 0;
-  } // main
+    sup->value( 54321 ) ;
+    BOOST_TEST( sup->value() == 54321 );
+    BOOST_TEST( up->value() == 54321 );
 
+    shared_ptr<UDT> sup2;
+    sup2 = sup;
+    BOOST_TEST( sup2->value() == 54321 );
+    BOOST_TEST( sup.use_count() == 2 );
+    BOOST_TEST( sup2.use_count() == 2 );
+    sup2 = sup2;
+    BOOST_TEST( sup2->value() == 54321 );
+    BOOST_TEST( sup.use_count() == 2 );
+    BOOST_TEST( sup2.use_count() == 2 );
+
+    cout << "OK\n";
+
+    new char[12345]; // deliberate memory leak to verify leaks detected
+}
+
+int main()
+{
+    test();
+    return boost::report_errors();
+}