diff --git a/test/optional_test.cpp b/test/optional_test.cpp
index 3591867..017d4ff 100644
--- a/test/optional_test.cpp
+++ b/test/optional_test.cpp
@@ -30,7 +30,7 @@
 
 #include "boost/none.hpp"
 
-#include "boost/test/minimal.hpp"
+#include "boost/core/lightweight_test.hpp"
 
 #include "optional_test_common.cpp"
 
@@ -46,12 +46,12 @@ void test_implicit_construction ( optional<X> opt, X const& v, X const& z )
 
 void test_default_implicit_construction ( double, optional<double> opt )
 {
-  BOOST_CHECK(!opt);
+  BOOST_TEST(!opt);
 }
 
 void test_default_implicit_construction ( X const&, optional<X> opt )
 {
-  BOOST_CHECK(!opt);
+  BOOST_TEST(!opt);
 }
 
 //
@@ -188,65 +188,65 @@ void test_conditional_ctor_and_get_valur_or ( T const* )
   check_value(o1,a,z);
 
   T b = def0.get_value_or(z);
-  BOOST_CHECK( b == z ) ;
+  BOOST_TEST( b == z ) ;
 
   b = get_optional_value_or(def0,z);
-  BOOST_CHECK( b == z ) ;
+  BOOST_TEST( b == z ) ;
 
   b = o0.get_value_or(z);
-  BOOST_CHECK( b == a ) ;
+  BOOST_TEST( b == a ) ;
 
   b = get_optional_value_or(o0,z);
-  BOOST_CHECK( b == a ) ;
+  BOOST_TEST( b == a ) ;
 
 
   T const& crz = z ;
   T&        rz = z ;
 
   T const& crzz = def0.get_value_or(crz);
-  BOOST_CHECK( crzz == crz ) ;
+  BOOST_TEST( crzz == crz ) ;
 
   T& rzz = def0.get_value_or(rz);
-  BOOST_CHECK( rzz == rz ) ;
+  BOOST_TEST( rzz == rz ) ;
 
   T const& crzzz = get_optional_value_or(cdef0,crz);
-  BOOST_CHECK( crzzz == crz ) ;
+  BOOST_TEST( crzzz == crz ) ;
 
   T& rzzz = get_optional_value_or(def0,rz);
-  BOOST_CHECK( rzzz == rz ) ;
+  BOOST_TEST( rzzz == rz ) ;
 
   T const& crb = o0.get_value_or(crz);
-  BOOST_CHECK( crb == a ) ;
+  BOOST_TEST( crb == a ) ;
 
   T& rb = o0.get_value_or(rz);
-  BOOST_CHECK( rb == b ) ;
+  BOOST_TEST( rb == b ) ;
 
   T const& crbb = get_optional_value_or(co0,crz);
-  BOOST_CHECK( crbb == b ) ;
+  BOOST_TEST( crbb == b ) ;
 
   T const& crbbb = get_optional_value_or(o0,crz);
-  BOOST_CHECK( crbbb == b ) ;
+  BOOST_TEST( crbbb == b ) ;
 
   T& rbb = get_optional_value_or(o0,rz);
-  BOOST_CHECK( rbb == b ) ;
+  BOOST_TEST( rbb == b ) ;
 
   T& ra = a ;
 
   optional<T&> defref(false,ra);
-  BOOST_CHECK(!defref);
+  BOOST_TEST(!defref);
 
   optional<T&> ref(true,ra);
-  BOOST_CHECK(!!ref);
+  BOOST_TEST(!!ref);
 
   a = T(432);
 
-  BOOST_CHECK( *ref == a ) ;
+  BOOST_TEST( *ref == a ) ;
 
   T& r1 = defref.get_value_or(z);
-  BOOST_CHECK( r1 == z ) ;
+  BOOST_TEST( r1 == z ) ;
 
   T& r2 = ref.get_value_or(z);
-  BOOST_CHECK( r2 == a ) ;
+  BOOST_TEST( r2 == a ) ;
 }
 
 //
@@ -262,18 +262,18 @@ void test_direct_value_manip( T const* )
   optional<T> const c_opt0(x) ;
   optional<T>         opt0(x);
 
-  BOOST_CHECK( c_opt0.get().V() == x.V() ) ;
-  BOOST_CHECK(   opt0.get().V() == x.V() ) ;
+  BOOST_TEST( c_opt0.get().V() == x.V() ) ;
+  BOOST_TEST(   opt0.get().V() == x.V() ) ;
 
-  BOOST_CHECK( c_opt0->V() == x.V() ) ;
-  BOOST_CHECK(   opt0->V() == x.V() ) ;
+  BOOST_TEST( c_opt0->V() == x.V() ) ;
+  BOOST_TEST(   opt0->V() == x.V() ) ;
 
-  BOOST_CHECK( (*c_opt0).V() == x.V() ) ;
-  BOOST_CHECK( (*  opt0).V() == x.V() ) ;
+  BOOST_TEST( (*c_opt0).V() == x.V() ) ;
+  BOOST_TEST( (*  opt0).V() == x.V() ) ;
 
   T y(4);
   opt0 = y ;
-  BOOST_CHECK( get(opt0).V() == y.V() ) ;
+  BOOST_TEST( get(opt0).V() == y.V() ) ;
 }
 
 //
@@ -295,7 +295,7 @@ void test_uninitialized_access( T const* )
     passed = true ;
   }
   catch (...) {}
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
 
   passed = false ;
   try
@@ -306,7 +306,7 @@ void test_uninitialized_access( T const* )
     passed = true ;
   }
   catch (...) {}
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
 
   passed = false ;
   try
@@ -318,7 +318,7 @@ void test_uninitialized_access( T const* )
     passed = true ;
   }
   catch (...) {}
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
 
   passed = false ;
   try
@@ -329,7 +329,7 @@ void test_uninitialized_access( T const* )
     passed = true ;
   }
   catch (...) {}
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
 }
 
 #if BOOST_WORKAROUND( BOOST_INTEL_CXX_VERSION, <= 700) // Intel C++ 7.0
@@ -374,7 +374,7 @@ void test_throwing_direct_init( T const* )
   }
   catch ( ... ){}
 
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
   check_is_not_pending_copy( ARG(T) );
   check_instance_count(count, ARG(T) );
 
@@ -410,7 +410,7 @@ void test_throwing_val_assign_on_uninitialized( T const* )
   }
   catch ( ... ) {}
 
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
 
   check_is_not_pending_copy( ARG(T) );
   check_instance_count(count, ARG(T) );
@@ -456,7 +456,7 @@ void test_throwing_val_assign_on_initialized( T const* )
   }
   catch ( ... ) {}
 
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
 
   check_is_not_pending_assign( ARG(T) );
   check_instance_count(count, ARG(T) );
@@ -495,7 +495,7 @@ void test_throwing_copy_initialization( T const* )
   }
   catch ( ... ) {}
 
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
 
   check_is_not_pending_copy( ARG(T) );
   check_instance_count(count, ARG(T) );
@@ -538,7 +538,7 @@ void test_throwing_assign_to_uninitialized( T const* )
   }
   catch ( ... ) {}
 
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
 
   check_is_not_pending_copy( ARG(T) );
   check_instance_count(count, ARG(T) );
@@ -581,7 +581,7 @@ void test_throwing_assign_to_initialized( T const* )
   }
   catch ( ... ) {}
 
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
 
   // opt0 was left uninitialized
   check_is_not_pending_assign( ARG(T) );
@@ -661,7 +661,7 @@ void test_throwing_swap( T const* )
   }
   catch ( ... ) {}
 
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
 
   // optional's swap doesn't affect the initialized states of the arguments. Therefore,
   // the following must hold:
@@ -692,7 +692,7 @@ void test_throwing_swap( T const* )
   }
   catch ( ... ) {}
 
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
 
   check_uninitialized(opt0);
   check_initialized(opt1);
@@ -720,69 +720,69 @@ void test_relops( T const* )
   optional<T> opt2(v2);
 
   // Check identity
-  BOOST_CHECK ( def0 == def0 ) ;
-  BOOST_CHECK ( opt0 == opt0 ) ;
-  BOOST_CHECK ( !(def0 != def0) ) ;
-  BOOST_CHECK ( !(opt0 != opt0) ) ;
+  BOOST_TEST ( def0 == def0 ) ;
+  BOOST_TEST ( opt0 == opt0 ) ;
+  BOOST_TEST ( !(def0 != def0) ) ;
+  BOOST_TEST ( !(opt0 != opt0) ) ;
 
   // Check when both are uininitalized.
-  BOOST_CHECK (   def0 == def1  ) ; // both uninitialized compare equal
-  BOOST_CHECK ( !(def0 <  def1) ) ; // uninitialized is never less    than uninitialized
-  BOOST_CHECK ( !(def0 >  def1) ) ; // uninitialized is never greater than uninitialized
-  BOOST_CHECK ( !(def0 != def1) ) ;
-  BOOST_CHECK (   def0 <= def1  ) ;
-  BOOST_CHECK (   def0 >= def1  ) ;
+  BOOST_TEST (   def0 == def1  ) ; // both uninitialized compare equal
+  BOOST_TEST ( !(def0 <  def1) ) ; // uninitialized is never less    than uninitialized
+  BOOST_TEST ( !(def0 >  def1) ) ; // uninitialized is never greater than uninitialized
+  BOOST_TEST ( !(def0 != def1) ) ;
+  BOOST_TEST (   def0 <= def1  ) ;
+  BOOST_TEST (   def0 >= def1  ) ;
 
   // Check when only lhs is uninitialized.
-  BOOST_CHECK (   def0 != opt0  ) ; // uninitialized is never equal to initialized
-  BOOST_CHECK ( !(def0 == opt0) ) ;
-  BOOST_CHECK (   def0 <  opt0  ) ; // uninitialized is always less than initialized
-  BOOST_CHECK ( !(def0 >  opt0) ) ;
-  BOOST_CHECK (   def0 <= opt0  ) ;
-  BOOST_CHECK ( !(def0 >= opt0) ) ;
+  BOOST_TEST (   def0 != opt0  ) ; // uninitialized is never equal to initialized
+  BOOST_TEST ( !(def0 == opt0) ) ;
+  BOOST_TEST (   def0 <  opt0  ) ; // uninitialized is always less than initialized
+  BOOST_TEST ( !(def0 >  opt0) ) ;
+  BOOST_TEST (   def0 <= opt0  ) ;
+  BOOST_TEST ( !(def0 >= opt0) ) ;
 
   // Check when only rhs is uninitialized.
-  BOOST_CHECK (   opt0 != def0  ) ; // initialized is never equal to uninitialized
-  BOOST_CHECK ( !(opt0 == def0) ) ;
-  BOOST_CHECK ( !(opt0 <  def0) ) ; // initialized is never less than uninitialized
-  BOOST_CHECK (   opt0 >  def0  ) ;
-  BOOST_CHECK ( !(opt0 <= def0) ) ;
-  BOOST_CHECK (   opt0 >= opt0  ) ;
+  BOOST_TEST (   opt0 != def0  ) ; // initialized is never equal to uninitialized
+  BOOST_TEST ( !(opt0 == def0) ) ;
+  BOOST_TEST ( !(opt0 <  def0) ) ; // initialized is never less than uninitialized
+  BOOST_TEST (   opt0 >  def0  ) ;
+  BOOST_TEST ( !(opt0 <= def0) ) ;
+  BOOST_TEST (   opt0 >= opt0  ) ;
 
   // If both are initialized, values are compared
-  BOOST_CHECK ( opt0 != opt1 ) ;
-  BOOST_CHECK ( opt1 == opt2 ) ;
-  BOOST_CHECK ( opt0 <  opt1 ) ;
-  BOOST_CHECK ( opt1 >  opt0 ) ;
-  BOOST_CHECK ( opt1 <= opt2 ) ;
-  BOOST_CHECK ( opt1 >= opt0 ) ;
+  BOOST_TEST ( opt0 != opt1 ) ;
+  BOOST_TEST ( opt1 == opt2 ) ;
+  BOOST_TEST ( opt0 <  opt1 ) ;
+  BOOST_TEST ( opt1 >  opt0 ) ;
+  BOOST_TEST ( opt1 <= opt2 ) ;
+  BOOST_TEST ( opt1 >= opt0 ) ;
 
   // Compare against a value directly
-  BOOST_CHECK ( opt0 == v0 ) ;
-  BOOST_CHECK ( opt0 != v1 ) ;
-  BOOST_CHECK ( opt1 == v2 ) ;
-  BOOST_CHECK ( opt0 <  v1 ) ;
-  BOOST_CHECK ( opt1 >  v0 ) ;
-  BOOST_CHECK ( opt1 <= v2 ) ;
-  BOOST_CHECK ( opt1 >= v0 ) ;
-  BOOST_CHECK ( v0 != opt1 ) ;
-  BOOST_CHECK ( v1 == opt2 ) ;
-  BOOST_CHECK ( v0 <  opt1 ) ;
-  BOOST_CHECK ( v1 >  opt0 ) ;
-  BOOST_CHECK ( v1 <= opt2 ) ;
-  BOOST_CHECK ( v1 >= opt0 ) ;
-  BOOST_CHECK (   def0 != v0  ) ;
-  BOOST_CHECK ( !(def0 == v0) ) ;
-  BOOST_CHECK (   def0 <  v0  ) ;
-  BOOST_CHECK ( !(def0 >  v0) ) ;
-  BOOST_CHECK (   def0 <= v0  ) ;
-  BOOST_CHECK ( !(def0 >= v0) ) ;
-  BOOST_CHECK (   v0 != def0  ) ;
-  BOOST_CHECK ( !(v0 == def0) ) ;
-  BOOST_CHECK ( !(v0 <  def0) ) ;
-  BOOST_CHECK (   v0 >  def0  ) ;
-  BOOST_CHECK ( !(v0 <= def0) ) ;
-  BOOST_CHECK (   v0 >= opt0  ) ;
+  BOOST_TEST ( opt0 == v0 ) ;
+  BOOST_TEST ( opt0 != v1 ) ;
+  BOOST_TEST ( opt1 == v2 ) ;
+  BOOST_TEST ( opt0 <  v1 ) ;
+  BOOST_TEST ( opt1 >  v0 ) ;
+  BOOST_TEST ( opt1 <= v2 ) ;
+  BOOST_TEST ( opt1 >= v0 ) ;
+  BOOST_TEST ( v0 != opt1 ) ;
+  BOOST_TEST ( v1 == opt2 ) ;
+  BOOST_TEST ( v0 <  opt1 ) ;
+  BOOST_TEST ( v1 >  opt0 ) ;
+  BOOST_TEST ( v1 <= opt2 ) ;
+  BOOST_TEST ( v1 >= opt0 ) ;
+  BOOST_TEST (   def0 != v0  ) ;
+  BOOST_TEST ( !(def0 == v0) ) ;
+  BOOST_TEST (   def0 <  v0  ) ;
+  BOOST_TEST ( !(def0 >  v0) ) ;
+  BOOST_TEST (   def0 <= v0  ) ;
+  BOOST_TEST ( !(def0 >= v0) ) ;
+  BOOST_TEST (   v0 != def0  ) ;
+  BOOST_TEST ( !(v0 == def0) ) ;
+  BOOST_TEST ( !(v0 <  def0) ) ;
+  BOOST_TEST (   v0 >  def0  ) ;
+  BOOST_TEST ( !(v0 <= def0) ) ;
+  BOOST_TEST (   v0 >= opt0  ) ;
 }
 
 template<class T>
@@ -796,16 +796,16 @@ void test_none( T const* )
   optional<T> def1(none) ;
   optional<T> non_def( T(1234) ) ;
 
-  BOOST_CHECK ( def0    == none ) ;
-  BOOST_CHECK ( non_def != none ) ;
-  BOOST_CHECK ( !def1           ) ;
-  BOOST_CHECK ( !(non_def <  none) ) ;
-  BOOST_CHECK (   non_def >  none  ) ;
-  BOOST_CHECK ( !(non_def <= none) ) ;
-  BOOST_CHECK (   non_def >= none  ) ;
+  BOOST_TEST ( def0    == none ) ;
+  BOOST_TEST ( non_def != none ) ;
+  BOOST_TEST ( !def1           ) ;
+  BOOST_TEST ( !(non_def <  none) ) ;
+  BOOST_TEST (   non_def >  none  ) ;
+  BOOST_TEST ( !(non_def <= none) ) ;
+  BOOST_TEST (   non_def >= none  ) ;
 
   non_def = none ;
-  BOOST_CHECK ( !non_def ) ;
+  BOOST_TEST ( !non_def ) ;
 
   test_default_implicit_construction(T(1),none);
 }
@@ -820,12 +820,12 @@ void test_arrow( T const* )
   optional<T>        oa(a) ;
   optional<T> const coa(a) ;
 
-  BOOST_CHECK ( coa->V() == 1234 ) ;
+  BOOST_TEST ( coa->V() == 1234 ) ;
 
   oa->V() = 4321 ;
 
-  BOOST_CHECK (     a.V() = 1234 ) ;
-  BOOST_CHECK ( (*oa).V() = 4321 ) ;
+  BOOST_TEST (     a.V() = 1234 ) ;
+  BOOST_TEST ( (*oa).V() = 4321 ) ;
 }
 
 void test_with_builtin_types()
@@ -869,7 +869,7 @@ void test_with_class_type()
   test_relops( ARG(X) ) ;
   test_none( ARG(X) ) ;
   test_arrow( ARG(X) ) ;
-  BOOST_CHECK ( X::count == 0 ) ;
+  BOOST_TEST ( X::count == 0 ) ;
 }
 
 int eat ( bool ) { return 1 ; }
@@ -888,7 +888,7 @@ void test_no_implicit_conversions_impl( T const& )
   TRACE( std::endl << BOOST_CURRENT_FUNCTION   );
 
   optional<T> def ;
-  BOOST_CHECK ( eat(def) == 0 ) ;
+  BOOST_TEST ( eat(def) == 0 ) ;
 }
 
 void test_no_implicit_conversions()
@@ -908,7 +908,7 @@ void test_no_implicit_conversions()
 
 
 // Test for support for classes with overridden operator&
-class CustomAddressOfClass
+class CustomAddressOfClass  
 {
     int n;
 
@@ -923,18 +923,18 @@ public:
 void test_custom_addressof_operator()
 {
     boost::optional< CustomAddressOfClass > o1(CustomAddressOfClass(10));
-    BOOST_CHECK(!!o1);
-    BOOST_CHECK(o1.get() == CustomAddressOfClass(10));
+    BOOST_TEST(!!o1);
+    BOOST_TEST(o1.get() == CustomAddressOfClass(10));
 
     o1 = CustomAddressOfClass(20);
-    BOOST_CHECK(!!o1);
-    BOOST_CHECK(o1.get() == CustomAddressOfClass(20));
+    BOOST_TEST(!!o1);
+    BOOST_TEST(o1.get() == CustomAddressOfClass(20));
 
     o1 = boost::none;
-    BOOST_CHECK(!o1);
+    BOOST_TEST(!o1);
 }
 
-int test_main( int, char* [] )
+int main()
 {
   try
   {
@@ -948,7 +948,7 @@ int test_main( int, char* [] )
     BOOST_ERROR("Unexpected Exception caught!");
   }
 
-  return 0;
+  return boost::report_errors();
 }
 
 
diff --git a/test/optional_test_common.cpp b/test/optional_test_common.cpp
index a527bd7..ff197bd 100644
--- a/test/optional_test_common.cpp
+++ b/test/optional_test_common.cpp
@@ -159,13 +159,13 @@ inline void set_throw_on_copy          ( X const* x ) { X::throw_on_copy = true
 inline void set_throw_on_assign        ( X const* x ) { X::throw_on_assign = true  ; }
 inline void reset_throw_on_copy        ( X const* x ) { X::throw_on_copy = false ; }
 inline void reset_throw_on_assign      ( X const* x ) { X::throw_on_assign = false ; }
-inline void check_is_pending_copy      ( X const* x ) { BOOST_CHECK( X::pending_copy ) ; }
-inline void check_is_pending_dtor      ( X const* x ) { BOOST_CHECK( X::pending_dtor ) ; }
-inline void check_is_pending_assign    ( X const* x ) { BOOST_CHECK( X::pending_assign ) ; }
-inline void check_is_not_pending_copy  ( X const* x ) { BOOST_CHECK( !X::pending_copy ) ; }
-inline void check_is_not_pending_dtor  ( X const* x ) { BOOST_CHECK( !X::pending_dtor ) ; }
-inline void check_is_not_pending_assign( X const* x ) { BOOST_CHECK( !X::pending_assign ) ; }
-inline void check_instance_count       ( int c, X const* x ) { BOOST_CHECK( X::count == c ) ; }
+inline void check_is_pending_copy      ( X const* x ) { BOOST_TEST( X::pending_copy ) ; }
+inline void check_is_pending_dtor      ( X const* x ) { BOOST_TEST( X::pending_dtor ) ; }
+inline void check_is_pending_assign    ( X const* x ) { BOOST_TEST( X::pending_assign ) ; }
+inline void check_is_not_pending_copy  ( X const* x ) { BOOST_TEST( !X::pending_copy ) ; }
+inline void check_is_not_pending_dtor  ( X const* x ) { BOOST_TEST( !X::pending_dtor ) ; }
+inline void check_is_not_pending_assign( X const* x ) { BOOST_TEST( !X::pending_assign ) ; }
+inline void check_instance_count       ( int c, X const* x ) { BOOST_TEST( X::count == c ) ; }
 inline int  get_instance_count         ( X const* x ) { return X::count ; }
 
 inline void set_pending_copy           (...) {}
@@ -189,21 +189,21 @@ template<class T>
 inline void check_uninitialized_const ( optional<T> const& opt )
 {
 #ifndef BOOST_OPTIONAL_NO_NULL_COMPARE
-  BOOST_CHECK( opt == 0 ) ;
+  BOOST_TEST( opt == 0 ) ;
 #endif
-  BOOST_CHECK( !opt ) ;
-  BOOST_CHECK( !get_pointer(opt) ) ;
-  BOOST_CHECK( !opt.get_ptr() ) ;
+  BOOST_TEST( !opt ) ;
+  BOOST_TEST( !get_pointer(opt) ) ;
+  BOOST_TEST( !opt.get_ptr() ) ;
 }
 template<class T>
 inline void check_uninitialized ( optional<T>& opt )
 {
 #ifndef BOOST_OPTIONAL_NO_NULL_COMPARE
-  BOOST_CHECK( opt == 0 ) ;
+  BOOST_TEST( opt == 0 ) ;
 #endif
-  BOOST_CHECK( !opt ) ;
-  BOOST_CHECK( !get_pointer(opt) ) ;
-  BOOST_CHECK( !opt.get_ptr() ) ;
+  BOOST_TEST( !opt ) ;
+  BOOST_TEST( !get_pointer(opt) ) ;
+  BOOST_TEST( !opt.get_ptr() ) ;
 
   check_uninitialized_const(opt);
 }
@@ -211,29 +211,29 @@ inline void check_uninitialized ( optional<T>& opt )
 template<class T>
 inline void check_initialized_const ( optional<T> const& opt )
 {
-  BOOST_CHECK( opt ) ;
+  BOOST_TEST( opt ) ;
 
 #ifndef BOOST_OPTIONAL_NO_NULL_COMPARE
-  BOOST_CHECK( opt != 0 ) ;
+  BOOST_TEST( opt != 0 ) ;
 #endif
 
-  BOOST_CHECK ( !!opt ) ;
-  BOOST_CHECK ( get_pointer(opt) ) ;
-  BOOST_CHECK ( opt.get_ptr() ) ;
+  BOOST_TEST ( !!opt ) ;
+  BOOST_TEST ( get_pointer(opt) ) ;
+  BOOST_TEST ( opt.get_ptr() ) ;
 }
 
 template<class T>
 inline void check_initialized ( optional<T>& opt )
 {
-  BOOST_CHECK( opt ) ;
+  BOOST_TEST( opt ) ;
 
 #ifndef BOOST_OPTIONAL_NO_NULL_COMPARE
-  BOOST_CHECK( opt != 0 ) ;
+  BOOST_TEST( opt != 0 ) ;
 #endif
 
-  BOOST_CHECK ( !!opt ) ;
-  BOOST_CHECK ( get_pointer(opt) ) ;
-  BOOST_CHECK ( opt.get_ptr() ) ;
+  BOOST_TEST ( !!opt ) ;
+  BOOST_TEST ( get_pointer(opt) ) ;
+  BOOST_TEST ( opt.get_ptr() ) ;
 
   check_initialized_const(opt);
 }
@@ -241,12 +241,12 @@ inline void check_initialized ( optional<T>& opt )
 template<class T>
 inline void check_value_const ( optional<T> const& opt, T const& v, T const& z )
 {
-  BOOST_CHECK( *opt == v ) ;
-  BOOST_CHECK( *opt != z ) ;
-  BOOST_CHECK( opt.get() == v ) ;
-  BOOST_CHECK( opt.get() != z ) ;
-  BOOST_CHECK( (*(opt.operator->()) == v) ) ;
-  BOOST_CHECK( *get_pointer(opt) == v ) ;
+  BOOST_TEST( *opt == v ) ;
+  BOOST_TEST( *opt != z ) ;
+  BOOST_TEST( opt.get() == v ) ;
+  BOOST_TEST( opt.get() != z ) ;
+  BOOST_TEST( (*(opt.operator->()) == v) ) ;
+  BOOST_TEST( *get_pointer(opt) == v ) ;
 }
 
 template<class T>
@@ -258,12 +258,12 @@ inline void check_value ( optional<T>& opt, T const& v, T const& z )
   reset_throw_on_copy( ARG(T) ) ;
 #endif
 
-  BOOST_CHECK( *opt == v ) ;
-  BOOST_CHECK( *opt != z ) ;
-  BOOST_CHECK( opt.get() == v ) ;
-  BOOST_CHECK( opt.get() != z ) ;
-  BOOST_CHECK( (*(opt.operator->()) == v) ) ;
-  BOOST_CHECK( *get_pointer(opt) == v ) ;
+  BOOST_TEST( *opt == v ) ;
+  BOOST_TEST( *opt != z ) ;
+  BOOST_TEST( opt.get() == v ) ;
+  BOOST_TEST( opt.get() != z ) ;
+  BOOST_TEST( (*(opt.operator->()) == v) ) ;
+  BOOST_TEST( *get_pointer(opt) == v ) ;
 
   check_value_const(opt,v,z);
 }