[Boost-commit] svn:boost r68857 - in sandbox/opaque/libs/opaque: example test test/new_class

Subject: [Boost-commit] svn:boost r68857 - in sandbox/opaque/libs/opaque: example test test/new_class
From: vicente.botet_at_[hidden]
Date: 2011-02-13 17:38:43

Author: viboes
Date: 2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
New Revision: 68857
URL: http://svn.boost.org/trac/boost/changeset/68857

Log:
Opaque: Move to lightweight_test avoiding kinking with Boost.Test
Text files modified: 
   sandbox/opaque/libs/opaque/example/ex1.cpp                                  |    12 +-                                      
   sandbox/opaque/libs/opaque/example/ex2.cpp                                  |    34 ++++----                                
   sandbox/opaque/libs/opaque/example/ex3.cpp                                  |     9 -                                       
   sandbox/opaque/libs/opaque/example/ex4.cpp                                  |     9 -                                       
   sandbox/opaque/libs/opaque/test/Jamfile.v2                                  |     3                                         
   sandbox/opaque/libs/opaque/test/multi_level_conversion.cpp                  |    10 +-                                      
   sandbox/opaque/libs/opaque/test/new_class/hiding_less_than_fail.cpp         |     2                                         
   sandbox/opaque/libs/opaque/test/new_class/hiding_plus_fail.cpp              |     2                                         
   sandbox/opaque/libs/opaque/test/new_class/plus_fail.cpp                     |     2                                         
   sandbox/opaque/libs/opaque/test/new_class/regular_pass.cpp                  |    34 ++++----                                
   sandbox/opaque/libs/opaque/test/new_class/using_divide_pass.cpp             |    38 ++++-----                               
   sandbox/opaque/libs/opaque/test/new_class/using_equal_pass.cpp              |    40 +++++-----                              
   sandbox/opaque/libs/opaque/test/new_class/using_greater_than_equal_pass.cpp |    42 +++++-----                              
   sandbox/opaque/libs/opaque/test/new_class/using_greater_than_pass.cpp       |    42 +++++-----                              
   sandbox/opaque/libs/opaque/test/new_class/using_less_than_equal_pass.cpp    |    42 +++++-----                              
   sandbox/opaque/libs/opaque/test/new_class/using_less_than_pass.cpp          |    42 +++++-----                              
   sandbox/opaque/libs/opaque/test/new_class/using_minus_assign_pass.cpp       |    38 ++++-----                               
   sandbox/opaque/libs/opaque/test/new_class/using_multiply_assign_pass.cpp    |    38 ++++-----                               
   sandbox/opaque/libs/opaque/test/new_class/using_multiply_pass.cpp           |    38 ++++-----                               
   sandbox/opaque/libs/opaque/test/new_class/using_not_equal_pass.cpp          |    40 +++++-----                              
   sandbox/opaque/libs/opaque/test/new_class/using_plus_assign_pass.cpp        |    39 ++++-----                               
   sandbox/opaque/libs/opaque/test/new_class/using_plus_pass.cpp               |    38 ++++-----                               
   sandbox/opaque/libs/opaque/test/new_class_test.cpp                          |   111 +++++++++++++----------------           
   sandbox/opaque/libs/opaque/test/new_type_test.cpp                           |   114 +++++++++++++-----------------          
   sandbox/opaque/libs/opaque/test/private_opaque_test.cpp                     |   116 +++++++++++++++----------------         
   sandbox/opaque/libs/opaque/test/public_opaque_test.cpp                      |   147 +++++++++++++++++++-------------------- 
   26 files changed, 503 insertions(+), 579 deletions(-)

Modified: sandbox/opaque/libs/opaque/example/ex1.cpp
==============================================================================
--- sandbox/opaque/libs/opaque/example/ex1.cpp	(original)
+++ sandbox/opaque/libs/opaque/example/ex1.cpp	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -10,11 +10,10 @@
 
 #include <boost/opaque/opaque.hpp>
 
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace boost;
 using namespace boost::opaque;
-using namespace boost::unit_test;
 
 #if 0
 typedef int Int;
@@ -40,16 +39,15 @@
 
     
 void t() {
-    BOOST_CHECK(gt(Int(1),Int(0)));
+    BOOST_TEST(gt(Int(1),Int(0)));
 }
 
-test_suite* init_unit_test_suite(int, char*[])
+int main()
 {
-  test_suite* test = BOOST_TEST_SUITE("ex1");
 
-  test->add(BOOST_TEST_CASE(&t));
+  t();
 
-  return test;
+  return boost::report_errors();
 }
 
 

Modified: sandbox/opaque/libs/opaque/example/ex2.cpp
==============================================================================
--- sandbox/opaque/libs/opaque/example/ex2.cpp	(original)
+++ sandbox/opaque/libs/opaque/example/ex2.cpp	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -10,11 +10,10 @@
 
 #include <boost/opaque/opaque.hpp>
 
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace boost;
 using namespace boost::opaque;
-using namespace boost::unit_test;
 
 
 BOOST_OPAQUE_PRIVATE_TYPEDEF(unsigned,game_score);
@@ -33,42 +32,41 @@
 void accumulate_test() {
     game_score gs1(1), gs2(2), res;
     res= accumulate(gs1,gs2);
-    BOOST_CHECK(gs1<gs2);
-    BOOST_CHECK(gs1<=gs2);
-    BOOST_CHECK(gs2>=gs1);
-    BOOST_CHECK(res==game_score(3));
-    BOOST_CHECK(game_score(3)==res);
+    BOOST_TEST(gs1<gs2);
+    BOOST_TEST(gs1<=gs2);
+    BOOST_TEST(gs2>=gs1);
+    BOOST_TEST(res==game_score(3));
+    BOOST_TEST(game_score(3)==res);
 
     game_score res2;
     res2=res+res;
-    BOOST_CHECK(res+res==game_score(6));
+    BOOST_TEST(res+res==game_score(6));
 }
 
 void next_id_test() {
     serial_number sn(1), res;
     res= next_id(sn);
-    BOOST_CHECK(res==serial_number(2));
-    BOOST_CHECK(serial_number(2)==res);
+    BOOST_TEST(res==serial_number(2));
+    BOOST_TEST(serial_number(2)==res);
 
-    BOOST_CHECK(res+res==serial_number(4));
+    BOOST_TEST(res+res==serial_number(4));
 
-    BOOST_CHECK(sn<res);
+    BOOST_TEST(sn<res);
 }
 
 //~ void mix_test_fail() {
     //~ game_score sn(1), res;
     //~ res= next_id(sn);
-    //~ BOOST_CHECK(serial_number(3)==game_score(3));
+    //~ BOOST_TEST(serial_number(3)==game_score(3));
 //~ }
 
 
-test_suite* init_unit_test_suite(int, char*[])
+int main()
 {
-  test_suite* test = BOOST_TEST_SUITE("ex2");
-  test->add(BOOST_TEST_CASE(&accumulate_test));
-  test->add(BOOST_TEST_CASE(&next_id_test));
+  accumulate_test();
+  next_id_test();
 
-  return test;
+  return boost::report_errors();
 }
 
 

Modified: sandbox/opaque/libs/opaque/example/ex3.cpp
==============================================================================
--- sandbox/opaque/libs/opaque/example/ex3.cpp	(original)
+++ sandbox/opaque/libs/opaque/example/ex3.cpp	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -10,11 +10,9 @@
 
 #include <boost/opaque/opaque.hpp>
 
-#include <boost/test/unit_test.hpp>
 
 using namespace boost;
 using namespace boost::opaque;
-using namespace boost::unit_test;
 
 // Listing 7
 #if 1
@@ -43,13 +41,12 @@
 }
 
 
-test_suite* init_unit_test_suite(int, char*[])
+int main()
 {
-  test_suite* test = BOOST_TEST_SUITE("ex3");
-  test->add(BOOST_TEST_CASE(&public_multiple_levels_test));
+  public_multiple_levels_test();
 
 
-  return test;
+  return 0;
 }
 
 

Modified: sandbox/opaque/libs/opaque/example/ex4.cpp
==============================================================================
--- sandbox/opaque/libs/opaque/example/ex4.cpp	(original)
+++ sandbox/opaque/libs/opaque/example/ex4.cpp	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -9,11 +9,9 @@
 //////////////////////////////////////////////////////////////////////////////
 
 #include <boost/opaque/opaque.hpp>
-#include <boost/test/unit_test.hpp>
 
 using namespace boost;
 using namespace boost::opaque;
-using namespace boost::unit_test;
 
 // Listing 1
 // Cartesian 3D coordinate types
@@ -37,12 +35,11 @@
 }
 
 
-test_suite* init_unit_test_suite(int, char*[])
+int main()
 {
-  test_suite* tests = BOOST_TEST_SUITE("ex4");
-  tests->add(BOOST_TEST_CASE(&test));
+  test();
 
-  return tests;
+  return 0;
 }
 
 

Modified: sandbox/opaque/libs/opaque/test/Jamfile.v2
==============================================================================
--- sandbox/opaque/libs/opaque/test/Jamfile.v2	(original)
+++ sandbox/opaque/libs/opaque/test/Jamfile.v2	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -1,6 +1,6 @@
 # Boost Chrono Library test Jamfile
 
-# Copyright Vicente Botet 2010
+# Copyright Vicente Botet 2010-2011
 
 # Distributed under the Boost Software License, Version 1.0.
 # See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt
@@ -18,7 +18,6 @@
 
 project
     : requirements
-        <library>/boost/test//boost_unit_test_framework/<link>static
 
         # uncomment the line above if you build outside the Boost release
         #<include>$(BOOST_ROOT)

Modified: sandbox/opaque/libs/opaque/test/multi_level_conversion.cpp
==============================================================================
--- sandbox/opaque/libs/opaque/test/multi_level_conversion.cpp	(original)
+++ sandbox/opaque/libs/opaque/test/multi_level_conversion.cpp	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -13,10 +13,9 @@
 #include <boost/type_traits/is_same.hpp>
 #include <boost/mpl/contains.hpp>
 
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace boost;
-using namespace boost::unit_test;
 
 // Listing 7
 BOOST_OPAQUE_PUBLIC_TYPEDEF(double,mass1_leng2_per_time2);
@@ -98,11 +97,10 @@
 }
 
 
-test_suite* init_unit_test_suite(int, char*[])
+int main()
 {
-  test_suite* test = BOOST_TEST_SUITE("public_multiple_levels");
-  test->add(BOOST_TEST_CASE(&public_multiple_levels));
+    public_multiple_levels();
 
-  return test;
+    return boost::report_errors();
 }
 

Modified: sandbox/opaque/libs/opaque/test/new_class/hiding_less_than_fail.cpp
==============================================================================
--- sandbox/opaque/libs/opaque/test/new_class/hiding_less_than_fail.cpp	(original)
+++ sandbox/opaque/libs/opaque/test/new_class/hiding_less_than_fail.cpp	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -11,8 +11,6 @@
 #include <boost/opaque/new_class.hpp>
 #include <boost/opaque/meta_mixin/operators.hpp>
 
-#include <boost/test/unit_test.hpp>
-
 using namespace boost;
 
 typedef int UT;

Modified: sandbox/opaque/libs/opaque/test/new_class/hiding_plus_fail.cpp
==============================================================================
--- sandbox/opaque/libs/opaque/test/new_class/hiding_plus_fail.cpp	(original)
+++ sandbox/opaque/libs/opaque/test/new_class/hiding_plus_fail.cpp	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -11,8 +11,6 @@
 #include <boost/opaque/new_class.hpp>
 #include <boost/opaque/meta_mixin/operators.hpp>
 
-#include <boost/test/unit_test.hpp>
-
 using namespace boost;
 
 typedef int UT;

Modified: sandbox/opaque/libs/opaque/test/new_class/plus_fail.cpp
==============================================================================
--- sandbox/opaque/libs/opaque/test/new_class/plus_fail.cpp	(original)
+++ sandbox/opaque/libs/opaque/test/new_class/plus_fail.cpp	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -10,8 +10,6 @@
 
 #include <boost/opaque/new_class.hpp>
 
-#include <boost/test/unit_test.hpp>
-
 using namespace boost;
 
 typedef int UT;

Modified: sandbox/opaque/libs/opaque/test/new_class/regular_pass.cpp
==============================================================================
--- sandbox/opaque/libs/opaque/test/new_class/regular_pass.cpp	(original)
+++ sandbox/opaque/libs/opaque/test/new_class/regular_pass.cpp	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -10,10 +10,9 @@
 
 #include <boost/opaque/new_class.hpp>
 
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace boost;
-using namespace boost::unit_test;
 
 typedef int UT;
 typedef short UT2;
@@ -39,7 +38,7 @@
 
 
 void size_test() {
-    BOOST_CHECK(sizeof(NT)==sizeof(UT));
+    BOOST_TEST(sizeof(NT)==sizeof(UT));
 }
 
 void default_constructor_test() {
@@ -48,43 +47,42 @@
 void copy_from_ut_test() {
         UT ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_from_ut2_test() {
         UT2 ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_constructor_test() {
         NT a(1);
         NT b(a);
-    BOOST_CHECK(a.underlying()==b.underlying());
+    BOOST_TEST(a.underlying()==b.underlying());
 }
 
 void assign_test() {
         NT a1, a2(2);
     a1=a2; // OK
-    BOOST_CHECK(a1.underlying()==a2.underlying());
+    BOOST_TEST(a1.underlying()==a2.underlying());
 }
 
 void opaque_static_cast_test() {
         NT a(1);
     UT2 i;
     i=opaque::opaque_static_cast<UT2>(a);
-    BOOST_CHECK(i==a.underlying());
+    BOOST_TEST(i==a.underlying());
 }
 
-test_suite* init_unit_test_suite(int, char*[])
+int main()
 {
-  test_suite* test = BOOST_TEST_SUITE("new_class.regular_pass");
 
-  test->add(BOOST_TEST_CASE(&size_test));
-  test->add(BOOST_TEST_CASE(&default_constructor_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut2_test));
-  test->add(BOOST_TEST_CASE(&copy_constructor_test));
-  test->add(BOOST_TEST_CASE(&assign_test));
-  test->add(BOOST_TEST_CASE(&opaque_static_cast_test));
+  size_test();
+  default_constructor_test();
+  copy_from_ut_test();
+  copy_from_ut2_test();
+  copy_constructor_test();
+  assign_test();
+  opaque_static_cast_test();
 
-  return test;
+  return boost::report_errors();
 }

Modified: sandbox/opaque/libs/opaque/test/new_class/using_divide_pass.cpp
==============================================================================
--- sandbox/opaque/libs/opaque/test/new_class/using_divide_pass.cpp	(original)
+++ sandbox/opaque/libs/opaque/test/new_class/using_divide_pass.cpp	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -11,10 +11,9 @@
 #include <boost/opaque/new_class.hpp>
 #include <boost/opaque/meta_mixin/operators.hpp>
 
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace boost;
-using namespace boost::unit_test;
 
 typedef int UT;
 typedef short UT2;
@@ -48,7 +47,7 @@
 
 
 void size_test() {
-    BOOST_CHECK(sizeof(NT)==sizeof(UT));
+    BOOST_TEST(sizeof(NT)==sizeof(UT));
 }
 #if 0
 void default_constructor_test() {
@@ -57,52 +56,51 @@
 void copy_from_ut_test() {
         UT ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_from_ut2_test() {
         UT2 ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_constructor_test() {
         NT a(1);
         NT b(a);
-    BOOST_CHECK(a.underlying()==b.underlying());
+    BOOST_TEST(a.underlying()==b.underlying());
 }
 
 void assign_test() {
         NT a1, a2(2);
     a1=a2; // OK
-    BOOST_CHECK(a1.underlying()==a2.underlying());
+    BOOST_TEST(a1.underlying()==a2.underlying());
 }
 
 void opaque_static_cast_test() {
         NT a(1);
     UT2 i;
     i=opaque_static_cast<UT2>(a);
-    BOOST_CHECK(i==a.underlying());
+    BOOST_TEST(i==a.underlying());
 }
 #endif
 void divide_test() {
     NT a2(2), b3(3), c6(6);
     a2 = c6 / b3;
-    BOOST_CHECK(a2.underlying()=2);
+    BOOST_TEST(a2.underlying()=2);
 }
 
-test_suite* init_unit_test_suite(int, char*[])
+int main()
 {
-  test_suite* test = BOOST_TEST_SUITE("new_class.using_devide_pass");
 
-  test->add(BOOST_TEST_CASE(&size_test));
+  size_test();
 #if 0
-  test->add(BOOST_TEST_CASE(&default_constructor_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut2_test));
-  test->add(BOOST_TEST_CASE(&copy_constructor_test));
-  test->add(BOOST_TEST_CASE(&assign_test));
-  test->add(BOOST_TEST_CASE(&opaque_static_cast_test));
+  default_constructor_test();
+  copy_from_ut_test();
+  copy_from_ut2_test();
+  copy_constructor_test();
+  assign_test();
+  opaque_static_cast_test();
 #endif  
-  test->add(BOOST_TEST_CASE(&divide_test));
+  divide_test();
 
-  return test;
+  return boost::report_errors();
 }

Modified: sandbox/opaque/libs/opaque/test/new_class/using_equal_pass.cpp
==============================================================================
--- sandbox/opaque/libs/opaque/test/new_class/using_equal_pass.cpp	(original)
+++ sandbox/opaque/libs/opaque/test/new_class/using_equal_pass.cpp	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -11,10 +11,9 @@
 #include <boost/opaque/new_class.hpp>
 #include <boost/opaque/meta_mixin/operators.hpp>
 
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace boost;
-using namespace boost::unit_test;
 
 typedef int UT;
 typedef short UT2;
@@ -48,7 +47,7 @@
 
 
 void size_test() {
-    BOOST_CHECK(sizeof(NT)==sizeof(UT));
+    BOOST_TEST(sizeof(NT)==sizeof(UT));
 }
 #if 0
 void default_constructor_test() {
@@ -57,52 +56,51 @@
 void copy_from_ut_test() {
         UT ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_from_ut2_test() {
         UT2 ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_constructor_test() {
         NT a(1);
         NT b(a);
-    BOOST_CHECK(a.underlying()==b.underlying());
+    BOOST_TEST(a.underlying()==b.underlying());
 }
 
 void assign_test() {
         NT a1, a2(2);
     a1=a2; // OK
-    BOOST_CHECK(a1.underlying()==a2.underlying());
+    BOOST_TEST(a1.underlying()==a2.underlying());
 }
 
 void opaque_static_cast_test() {
         NT a(1);
     UT2 i;
     i=opaque_static_cast<UT2>(a);
-    BOOST_CHECK(i==a.underlying());
+    BOOST_TEST(i==a.underlying());
 }
 #endif
 void equal_test() {
     NT a1(1), b2(2), c2(2);
-    BOOST_CHECK(b2==c2);
-    BOOST_CHECK((b2==a1)==false);
+    BOOST_TEST(b2==c2);
+    BOOST_TEST((b2==a1)==false);
 }
 
-test_suite* init_unit_test_suite(int, char*[])
+int main()
 {
-  test_suite* test = BOOST_TEST_SUITE("new_class.equal_pass");
 
-  test->add(BOOST_TEST_CASE(&size_test));
+  size_test();
 #if 0
-  test->add(BOOST_TEST_CASE(&default_constructor_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut2_test));
-  test->add(BOOST_TEST_CASE(&copy_constructor_test));
-  test->add(BOOST_TEST_CASE(&assign_test));
-  test->add(BOOST_TEST_CASE(&opaque_static_cast_test));
+  default_constructor_test();
+  copy_from_ut_test();
+  copy_from_ut2_test();
+  copy_constructor_test();
+  assign_test();
+  opaque_static_cast_test();
 #endif  
-  test->add(BOOST_TEST_CASE(&equal_test));
+  equal_test();
 
-  return test;
+  return boost::report_errors();
 }

Modified: sandbox/opaque/libs/opaque/test/new_class/using_greater_than_equal_pass.cpp
==============================================================================
--- sandbox/opaque/libs/opaque/test/new_class/using_greater_than_equal_pass.cpp	(original)
+++ sandbox/opaque/libs/opaque/test/new_class/using_greater_than_equal_pass.cpp	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -11,10 +11,9 @@
 #include <boost/opaque/new_class.hpp>
 #include <boost/opaque/meta_mixin/operators.hpp>
 
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace boost;
-using namespace boost::unit_test;
 
 typedef int UT;
 typedef short UT2;
@@ -48,7 +47,7 @@
 
 
 void size_test() {
-    BOOST_CHECK(sizeof(NT)==sizeof(UT));
+    BOOST_TEST(sizeof(NT)==sizeof(UT));
 }
 #if 0
 void default_constructor_test() {
@@ -57,53 +56,52 @@
 void copy_from_ut_test() {
         UT ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_from_ut2_test() {
         UT2 ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_constructor_test() {
         NT a(1);
         NT b(a);
-    BOOST_CHECK(a.underlying()==b.underlying());
+    BOOST_TEST(a.underlying()==b.underlying());
 }
 
 void assign_test() {
         NT a1, a2(2);
     a1=a2; // OK
-    BOOST_CHECK(a1.underlying()==a2.underlying());
+    BOOST_TEST(a1.underlying()==a2.underlying());
 }
 
 void opaque_static_cast_test() {
         NT a(1);
     UT2 i;
     i=opaque_static_cast<UT2>(a);
-    BOOST_CHECK(i==a.underlying());
+    BOOST_TEST(i==a.underlying());
 }
 #endif
 void greater_than_equal_test() {
     NT a1(1), b2(2), c2(2);
-    BOOST_CHECK(b2>=a1);
-    BOOST_CHECK((a1>=b2)==false);
-    BOOST_CHECK(b2>=c2);
+    BOOST_TEST(b2>=a1);
+    BOOST_TEST((a1>=b2)==false);
+    BOOST_TEST(b2>=c2);
 }
 
-test_suite* init_unit_test_suite(int, char*[])
+int main()
 {
-  test_suite* test = BOOST_TEST_SUITE("new_class.greater_than_equal_pass");
 
-  test->add(BOOST_TEST_CASE(&size_test));
+  size_test();
 #if 0
-  test->add(BOOST_TEST_CASE(&default_constructor_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut2_test));
-  test->add(BOOST_TEST_CASE(&copy_constructor_test));
-  test->add(BOOST_TEST_CASE(&assign_test));
-  test->add(BOOST_TEST_CASE(&opaque_static_cast_test));
+  default_constructor_test();
+  copy_from_ut_test();
+  copy_from_ut2_test();
+  copy_constructor_test();
+  assign_test();
+  opaque_static_cast_test();
 #endif  
-  test->add(BOOST_TEST_CASE(&greater_than_equal_test));
+  greater_than_equal_test();
 
-  return test;
+  return boost::report_errors();
 }

Modified: sandbox/opaque/libs/opaque/test/new_class/using_greater_than_pass.cpp
==============================================================================
--- sandbox/opaque/libs/opaque/test/new_class/using_greater_than_pass.cpp	(original)
+++ sandbox/opaque/libs/opaque/test/new_class/using_greater_than_pass.cpp	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -11,10 +11,9 @@
 #include <boost/opaque/new_class.hpp>
 #include <boost/opaque/meta_mixin/operators.hpp>
 
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace boost;
-using namespace boost::unit_test;
 
 typedef int UT;
 typedef short UT2;
@@ -48,7 +47,7 @@
 
 
 void size_test() {
-    BOOST_CHECK(sizeof(NT)==sizeof(UT));
+    BOOST_TEST(sizeof(NT)==sizeof(UT));
 }
 #if 0
 void default_constructor_test() {
@@ -57,53 +56,52 @@
 void copy_from_ut_test() {
         UT ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_from_ut2_test() {
         UT2 ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_constructor_test() {
         NT a(1);
         NT b(a);
-    BOOST_CHECK(a.underlying()==b.underlying());
+    BOOST_TEST(a.underlying()==b.underlying());
 }
 
 void assign_test() {
         NT a1, a2(2);
     a1=a2; // OK
-    BOOST_CHECK(a1.underlying()==a2.underlying());
+    BOOST_TEST(a1.underlying()==a2.underlying());
 }
 
 void opaque_static_cast_test() {
         NT a(1);
     UT2 i;
     i=opaque_static_cast<UT2>(a);
-    BOOST_CHECK(i==a.underlying());
+    BOOST_TEST(i==a.underlying());
 }
 #endif
 void greater_than_test() {
     NT a1(1), b2(2), c2(2);
-    BOOST_CHECK(b2>a1);
-    BOOST_CHECK((a1>b2)==false);
-    BOOST_CHECK((b2>c2)==false);
+    BOOST_TEST(b2>a1);
+    BOOST_TEST((a1>b2)==false);
+    BOOST_TEST((b2>c2)==false);
 }
 
-test_suite* init_unit_test_suite(int, char*[])
+int main()
 {
-  test_suite* test = BOOST_TEST_SUITE("new_class.greater_than_pass");
 
-  test->add(BOOST_TEST_CASE(&size_test));
+  size_test();
 #if 0
-  test->add(BOOST_TEST_CASE(&default_constructor_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut2_test));
-  test->add(BOOST_TEST_CASE(&copy_constructor_test));
-  test->add(BOOST_TEST_CASE(&assign_test));
-  test->add(BOOST_TEST_CASE(&opaque_static_cast_test));
+  default_constructor_test);
+  copy_from_ut_test();
+  copy_from_ut2_test();
+  copy_constructor_test();
+  assign_test();
+  opaque_static_cast_test();
 #endif  
-  test->add(BOOST_TEST_CASE(&greater_than_test));
+  greater_than_test();
 
-  return test;
+  return boost::report_errors();
 }

Modified: sandbox/opaque/libs/opaque/test/new_class/using_less_than_equal_pass.cpp
==============================================================================
--- sandbox/opaque/libs/opaque/test/new_class/using_less_than_equal_pass.cpp	(original)
+++ sandbox/opaque/libs/opaque/test/new_class/using_less_than_equal_pass.cpp	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -11,10 +11,9 @@
 #include <boost/opaque/new_class.hpp>
 #include <boost/opaque/meta_mixin/operators.hpp>
 
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace boost;
-using namespace boost::unit_test;
 
 typedef int UT;
 typedef short UT2;
@@ -48,7 +47,7 @@
 
 
 void size_test() {
-    BOOST_CHECK(sizeof(NT)==sizeof(UT));
+    BOOST_TEST(sizeof(NT)==sizeof(UT));
 }
 #if 0
 void default_constructor_test() {
@@ -57,53 +56,52 @@
 void copy_from_ut_test() {
         UT ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_from_ut2_test() {
         UT2 ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_constructor_test() {
         NT a(1);
         NT b(a);
-    BOOST_CHECK(a.underlying()==b.underlying());
+    BOOST_TEST(a.underlying()==b.underlying());
 }
 
 void assign_test() {
         NT a1, a2(2);
     a1=a2; // OK
-    BOOST_CHECK(a1.underlying()==a2.underlying());
+    BOOST_TEST(a1.underlying()==a2.underlying());
 }
 
 void opaque_static_cast_test() {
         NT a(1);
     UT2 i;
     i=opaque_static_cast<UT2>(a);
-    BOOST_CHECK(i==a.underlying());
+    BOOST_TEST(i==a.underlying());
 }
 #endif
 void less_than_equal_test() {
     NT a1(1), b2(2), c2(2);
-    BOOST_CHECK(a1<=b2);
-    BOOST_CHECK((b2<=a1)==false);
-    BOOST_CHECK(b2<=c2);
+    BOOST_TEST(a1<=b2);
+    BOOST_TEST((b2<=a1)==false);
+    BOOST_TEST(b2<=c2);
 }
 
-test_suite* init_unit_test_suite(int, char*[])
+int main()
 {
-  test_suite* test = BOOST_TEST_SUITE("new_class.less_than_equal_pass");
 
-  test->add(BOOST_TEST_CASE(&size_test));
+  size_test();
 #if 0
-  test->add(BOOST_TEST_CASE(&default_constructor_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut2_test));
-  test->add(BOOST_TEST_CASE(&copy_constructor_test));
-  test->add(BOOST_TEST_CASE(&assign_test));
-  test->add(BOOST_TEST_CASE(&opaque_static_cast_test));
+  default_constructor_test();
+  copy_from_ut_test();
+  copy_from_ut2_test();
+  copy_constructor_test();
+  assign_test();
+  opaque_static_cast_test();
 #endif  
-  test->add(BOOST_TEST_CASE(&less_than_equal_test));
+  less_than_equal_test();
 
-  return test;
+  return boost::report_errors();
 }

Modified: sandbox/opaque/libs/opaque/test/new_class/using_less_than_pass.cpp
==============================================================================
--- sandbox/opaque/libs/opaque/test/new_class/using_less_than_pass.cpp	(original)
+++ sandbox/opaque/libs/opaque/test/new_class/using_less_than_pass.cpp	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -11,10 +11,9 @@
 #include <boost/opaque/new_class.hpp>
 #include <boost/opaque/meta_mixin/operators.hpp>
 
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace boost;
-using namespace boost::unit_test;
 
 typedef int UT;
 typedef short UT2;
@@ -48,7 +47,7 @@
 
 
 void size_test() {
-    BOOST_CHECK(sizeof(NT)==sizeof(UT));
+    BOOST_TEST(sizeof(NT)==sizeof(UT));
 }
 #if 0
 void default_constructor_test() {
@@ -57,53 +56,52 @@
 void copy_from_ut_test() {
         UT ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_from_ut2_test() {
         UT2 ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_constructor_test() {
         NT a(1);
         NT b(a);
-    BOOST_CHECK(a.underlying()==b.underlying());
+    BOOST_TEST(a.underlying()==b.underlying());
 }
 
 void assign_test() {
         NT a1, a2(2);
     a1=a2; // OK
-    BOOST_CHECK(a1.underlying()==a2.underlying());
+    BOOST_TEST(a1.underlying()==a2.underlying());
 }
 
 void opaque_static_cast_test() {
         NT a(1);
     UT2 i;
     i=opaque_static_cast<UT2>(a);
-    BOOST_CHECK(i==a.underlying());
+    BOOST_TEST(i==a.underlying());
 }
 #endif
 void less_than_test() {
     NT a1(1), b2(2), c2(2);
-    BOOST_CHECK(a1<b2);
-    BOOST_CHECK((b2<a1)==false);
-    BOOST_CHECK((b2<c2)==false);
+    BOOST_TEST(a1<b2);
+    BOOST_TEST((b2<a1)==false);
+    BOOST_TEST((b2<c2)==false);
 }
 
-test_suite* init_unit_test_suite(int, char*[])
+int main()
 {
-  test_suite* test = BOOST_TEST_SUITE("new_class.less_than_pass");
 
-  test->add(BOOST_TEST_CASE(&size_test));
+  size_test();
 #if 0
-  test->add(BOOST_TEST_CASE(&default_constructor_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut2_test));
-  test->add(BOOST_TEST_CASE(&copy_constructor_test));
-  test->add(BOOST_TEST_CASE(&assign_test));
-  test->add(BOOST_TEST_CASE(&opaque_static_cast_test));
+  default_constructor_test();
+  copy_from_ut_test();
+  copy_from_ut2_test();
+  copy_constructor_test();
+  assign_test();
+  opaque_static_cast_test();
 #endif  
-  test->add(BOOST_TEST_CASE(&less_than_test));
+  less_than_test();
 
-  return test;
+  return boost::report_errors();
 }

Modified: sandbox/opaque/libs/opaque/test/new_class/using_minus_assign_pass.cpp
==============================================================================
--- sandbox/opaque/libs/opaque/test/new_class/using_minus_assign_pass.cpp	(original)
+++ sandbox/opaque/libs/opaque/test/new_class/using_minus_assign_pass.cpp	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -11,10 +11,9 @@
 #include <boost/opaque/new_class.hpp>
 #include <boost/opaque/meta_mixin/operators.hpp>
 
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace boost;
-using namespace boost::unit_test;
 
 typedef int UT;
 typedef short UT2;
@@ -48,7 +47,7 @@
 
 
 void size_test() {
-    BOOST_CHECK(sizeof(NT)==sizeof(UT));
+    BOOST_TEST(sizeof(NT)==sizeof(UT));
 }
 #if 0
 void default_constructor_test() {
@@ -57,53 +56,52 @@
 void copy_from_ut_test() {
         UT ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_from_ut2_test() {
         UT2 ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_constructor_test() {
         NT a(1);
         NT b(a);
-    BOOST_CHECK(a.underlying()==b.underlying());
+    BOOST_TEST(a.underlying()==b.underlying());
 }
 
 void assign_test() {
         NT a1, a2(2);
     a1=a2; // OK
-    BOOST_CHECK(a1.underlying()==a2.underlying());
+    BOOST_TEST(a1.underlying()==a2.underlying());
 }
 
 void opaque_static_cast_test() {
         NT a(1);
     UT2 i;
     i=opaque_static_cast<UT2>(a);
-    BOOST_CHECK(i==a.underlying());
+    BOOST_TEST(i==a.underlying());
 }
 #endif
 void minus_assign_test() {
     NT a1(1), b2(2), c2(2);
     a1-=b2;
-    BOOST_CHECK(a1.underlying()=3);
+    BOOST_TEST(a1.underlying()=3);
 }
 
-test_suite* init_unit_test_suite(int, char*[])
+int main()
 {
-  test_suite* test = BOOST_TEST_SUITE("new_class.using_minus_assign_pass");
 
-  test->add(BOOST_TEST_CASE(&size_test));
+  size_test();
 #if 0
-  test->add(BOOST_TEST_CASE(&default_constructor_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut2_test));
-  test->add(BOOST_TEST_CASE(&copy_constructor_test));
-  test->add(BOOST_TEST_CASE(&assign_test));
-  test->add(BOOST_TEST_CASE(&opaque_static_cast_test));
+  default_constructor_test();
+  copy_from_ut_test();
+  copy_from_ut2_test();
+  copy_constructor_test();
+  assign_test();
+  opaque_static_cast_test();
 #endif  
   
-  test->add(BOOST_TEST_CASE(&minus_assign_test));
+  minus_assign_test();
 
-  return test;
+  return boost::report_errors();
 }

Modified: sandbox/opaque/libs/opaque/test/new_class/using_multiply_assign_pass.cpp
==============================================================================
--- sandbox/opaque/libs/opaque/test/new_class/using_multiply_assign_pass.cpp	(original)
+++ sandbox/opaque/libs/opaque/test/new_class/using_multiply_assign_pass.cpp	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -11,10 +11,9 @@
 #include <boost/opaque/new_class.hpp>
 #include <boost/opaque/meta_mixin/operators.hpp>
 
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace boost;
-using namespace boost::unit_test;
 
 typedef int UT;
 typedef short UT2;
@@ -48,7 +47,7 @@
 
 
 void size_test() {
-    BOOST_CHECK(sizeof(NT)==sizeof(UT));
+    BOOST_TEST(sizeof(NT)==sizeof(UT));
 }
 #if 0
 void default_constructor_test() {
@@ -57,52 +56,51 @@
 void copy_from_ut_test() {
         UT ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_from_ut2_test() {
         UT2 ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_constructor_test() {
         NT a(1);
         NT b(a);
-    BOOST_CHECK(a.underlying()==b.underlying());
+    BOOST_TEST(a.underlying()==b.underlying());
 }
 
 void assign_test() {
         NT a1, a2(2);
     a1=a2; // OK
-    BOOST_CHECK(a1.underlying()==a2.underlying());
+    BOOST_TEST(a1.underlying()==a2.underlying());
 }
 
 void opaque_static_cast_test() {
         NT a(1);
     UT2 i;
     i=opaque_static_cast<UT2>(a);
-    BOOST_CHECK(i==a.underlying());
+    BOOST_TEST(i==a.underlying());
 }
 #endif
 void multiply_assign_test() {
     NT a1(2), b2(3);
     a1 *= b2;
-    BOOST_CHECK(a1.underlying()=6);
+    BOOST_TEST(a1.underlying()=6);
 }
 
-test_suite* init_unit_test_suite(int, char*[])
+int main()
 {
-  test_suite* test = BOOST_TEST_SUITE("new_class.using_multiply_assign_pass");
 
-  test->add(BOOST_TEST_CASE(&size_test));
+  size_test();
 #if 0
-  test->add(BOOST_TEST_CASE(&default_constructor_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut2_test));
-  test->add(BOOST_TEST_CASE(&copy_constructor_test));
-  test->add(BOOST_TEST_CASE(&assign_test));
-  test->add(BOOST_TEST_CASE(&opaque_static_cast_test));
+  default_constructor_test();
+  copy_from_ut_test();
+  copy_from_ut2_test();
+  copy_constructor_test();
+  assign_test();
+  opaque_static_cast_test();
 #endif  
-  test->add(BOOST_TEST_CASE(&multiply_assign_test));
+  multiply_assign_test();
 
-  return test;
+  return boost::report_errors();
 }

Modified: sandbox/opaque/libs/opaque/test/new_class/using_multiply_pass.cpp
==============================================================================
--- sandbox/opaque/libs/opaque/test/new_class/using_multiply_pass.cpp	(original)
+++ sandbox/opaque/libs/opaque/test/new_class/using_multiply_pass.cpp	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -11,10 +11,9 @@
 #include <boost/opaque/new_class.hpp>
 #include <boost/opaque/meta_mixin/operators.hpp>
 
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace boost;
-using namespace boost::unit_test;
 
 typedef int UT;
 typedef short UT2;
@@ -48,7 +47,7 @@
 
 
 void size_test() {
-    BOOST_CHECK(sizeof(NT)==sizeof(UT));
+    BOOST_TEST(sizeof(NT)==sizeof(UT));
 }
 #if 0
 void default_constructor_test() {
@@ -57,52 +56,51 @@
 void copy_from_ut_test() {
         UT ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_from_ut2_test() {
         UT2 ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_constructor_test() {
         NT a(1);
         NT b(a);
-    BOOST_CHECK(a.underlying()==b.underlying());
+    BOOST_TEST(a.underlying()==b.underlying());
 }
 
 void assign_test() {
         NT a1, a2(2);
     a1=a2; // OK
-    BOOST_CHECK(a1.underlying()==a2.underlying());
+    BOOST_TEST(a1.underlying()==a2.underlying());
 }
 
 void opaque_static_cast_test() {
         NT a(1);
     UT2 i;
     i=opaque_static_cast<UT2>(a);
-    BOOST_CHECK(i==a.underlying());
+    BOOST_TEST(i==a.underlying());
 }
 #endif
 void multiply_test() {
     NT a2(2), b3(3), c6(2);
     c6 = a2 * b3;
-    BOOST_CHECK(c6.underlying()=6);
+    BOOST_TEST(c6.underlying()=6);
 }
 
-test_suite* init_unit_test_suite(int, char*[])
+int main()
 {
-  test_suite* test = BOOST_TEST_SUITE("new_class.using_multiply_pass");
 
-  test->add(BOOST_TEST_CASE(&size_test));
+  size_test();
 #if 0
-  test->add(BOOST_TEST_CASE(&default_constructor_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut2_test));
-  test->add(BOOST_TEST_CASE(&copy_constructor_test));
-  test->add(BOOST_TEST_CASE(&assign_test));
-  test->add(BOOST_TEST_CASE(&opaque_static_cast_test));
+  default_constructor_test();
+  copy_from_ut_test();
+  copy_from_ut2_test();
+  copy_constructor_test();
+  assign_test();
+  opaque_static_cast_test();
 #endif  
-  test->add(BOOST_TEST_CASE(&multiply_test));
+  multiply_test();
 
-  return test;
+  return boost::report_errors();
 }

Modified: sandbox/opaque/libs/opaque/test/new_class/using_not_equal_pass.cpp
==============================================================================
--- sandbox/opaque/libs/opaque/test/new_class/using_not_equal_pass.cpp	(original)
+++ sandbox/opaque/libs/opaque/test/new_class/using_not_equal_pass.cpp	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -11,10 +11,9 @@
 #include <boost/opaque/new_class.hpp>
 #include <boost/opaque/meta_mixin/operators.hpp>
 
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace boost;
-using namespace boost::unit_test;
 
 typedef int UT;
 typedef short UT2;
@@ -48,7 +47,7 @@
 
 
 void size_test() {
-    BOOST_CHECK(sizeof(NT)==sizeof(UT));
+    BOOST_TEST(sizeof(NT)==sizeof(UT));
 }
 #if 0
 void default_constructor_test() {
@@ -57,52 +56,51 @@
 void copy_from_ut_test() {
         UT ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_from_ut2_test() {
         UT2 ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_constructor_test() {
         NT a(1);
         NT b(a);
-    BOOST_CHECK(a.underlying()==b.underlying());
+    BOOST_TEST(a.underlying()==b.underlying());
 }
 
 void assign_test() {
         NT a1, a2(2);
     a1=a2; // OK
-    BOOST_CHECK(a1.underlying()==a2.underlying());
+    BOOST_TEST(a1.underlying()==a2.underlying());
 }
 
 void opaque_static_cast_test() {
         NT a(1);
     UT2 i;
     i=opaque_static_cast<UT2>(a);
-    BOOST_CHECK(i==a.underlying());
+    BOOST_TEST(i==a.underlying());
 }
 #endif
 void not_equal_test() {
     NT a1(1), b2(2), c2(2);
-    BOOST_CHECK(a1!=c2);
-    BOOST_CHECK((b2!=c2)==false);
+    BOOST_TEST(a1!=c2);
+    BOOST_TEST((b2!=c2)==false);
 }
 
-test_suite* init_unit_test_suite(int, char*[])
+int main()
 {
-  test_suite* test = BOOST_TEST_SUITE("new_class.not_equal_pass");
 
-  test->add(BOOST_TEST_CASE(&size_test));
+  size_test();
 #if 0
-  test->add(BOOST_TEST_CASE(&default_constructor_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut2_test));
-  test->add(BOOST_TEST_CASE(&copy_constructor_test));
-  test->add(BOOST_TEST_CASE(&assign_test));
-  test->add(BOOST_TEST_CASE(&opaque_static_cast_test));
+  default_constructor_test();
+  copy_from_ut_test();
+  copy_from_ut2_test();
+  copy_constructor_test();
+  assign_test();
+  opaque_static_cast_test();
 #endif  
-  test->add(BOOST_TEST_CASE(&not_equal_test));
+  not_equal_test();
 
-  return test;
+  return boost::report_errors();
 }

Modified: sandbox/opaque/libs/opaque/test/new_class/using_plus_assign_pass.cpp
==============================================================================
--- sandbox/opaque/libs/opaque/test/new_class/using_plus_assign_pass.cpp	(original)
+++ sandbox/opaque/libs/opaque/test/new_class/using_plus_assign_pass.cpp	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -11,10 +11,9 @@
 #include <boost/opaque/new_class.hpp>
 #include <boost/opaque/meta_mixin/operators.hpp>
 
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace boost;
-using namespace boost::unit_test;
 
 typedef int UT;
 typedef short UT2;
@@ -48,7 +47,7 @@
 
 
 void size_test() {
-    BOOST_CHECK(sizeof(NT)==sizeof(UT));
+    BOOST_TEST(sizeof(NT)==sizeof(UT));
 }
 #if 0
 void default_constructor_test() {
@@ -57,52 +56,50 @@
 void copy_from_ut_test() {
         UT ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_from_ut2_test() {
         UT2 ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_constructor_test() {
         NT a(1);
         NT b(a);
-    BOOST_CHECK(a.underlying()==b.underlying());
+    BOOST_TEST(a.underlying()==b.underlying());
 }
 
 void assign_test() {
         NT a1, a2(2);
     a1=a2; // OK
-    BOOST_CHECK(a1.underlying()==a2.underlying());
+    BOOST_TEST(a1.underlying()==a2.underlying());
 }
 
 void opaque_static_cast_test() {
         NT a(1);
     UT2 i;
     i=opaque_static_cast<UT2>(a);
-    BOOST_CHECK(i==a.underlying());
+    BOOST_TEST(i==a.underlying());
 }
 #endif
 void plus_assign_test() {
     NT a1(1), b2(2), c2(2);
     a1+=b2;
-    BOOST_CHECK(a1.underlying()=3);
+    BOOST_TEST(a1.underlying()=3);
 }
 
-test_suite* init_unit_test_suite(int, char*[])
+int main()
 {
-  test_suite* test = BOOST_TEST_SUITE("new_class.using_plus_assign_pass");
-
-  test->add(BOOST_TEST_CASE(&size_test));
+  size_test();
 #if 0
-  test->add(BOOST_TEST_CASE(&default_constructor_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut2_test));
-  test->add(BOOST_TEST_CASE(&copy_constructor_test));
-  test->add(BOOST_TEST_CASE(&assign_test));
-  test->add(BOOST_TEST_CASE(&opaque_static_cast_test));
+  default_constructor_test();
+  copy_from_ut_test();
+  copy_from_ut2_test();
+  copy_constructor_test();
+  assign_test();
+  opaque_static_cast_test();
 #endif  
-  test->add(BOOST_TEST_CASE(&plus_assign_test));
+  plus_assign_test();
 
-  return test;
+  return boost::report_errors();
 }

Modified: sandbox/opaque/libs/opaque/test/new_class/using_plus_pass.cpp
==============================================================================
--- sandbox/opaque/libs/opaque/test/new_class/using_plus_pass.cpp	(original)
+++ sandbox/opaque/libs/opaque/test/new_class/using_plus_pass.cpp	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -11,10 +11,9 @@
 #include <boost/opaque/new_class.hpp>
 #include <boost/opaque/meta_mixin/operators.hpp>
 
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace boost;
-using namespace boost::unit_test;
 
 typedef int UT;
 typedef short UT2;
@@ -48,7 +47,7 @@
 
 
 void size_test() {
-    BOOST_CHECK(sizeof(NT)==sizeof(UT));
+    BOOST_TEST(sizeof(NT)==sizeof(UT));
 }
 #if 0
 void default_constructor_test() {
@@ -57,52 +56,51 @@
 void copy_from_ut_test() {
         UT ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_from_ut2_test() {
         UT2 ut(1);
         NT a(ut);
-    BOOST_CHECK(a.underlying()==ut);
+    BOOST_TEST(a.underlying()==ut);
 }
 void copy_constructor_test() {
         NT a(1);
         NT b(a);
-    BOOST_CHECK(a.underlying()==b.underlying());
+    BOOST_TEST(a.underlying()==b.underlying());
 }
 
 void assign_test() {
         NT a1, a2(2);
     a1=a2; // OK
-    BOOST_CHECK(a1.underlying()==a2.underlying());
+    BOOST_TEST(a1.underlying()==a2.underlying());
 }
 
 void opaque_static_cast_test() {
         NT a(1);
     UT2 i;
     i=opaque_static_cast<UT2>(a);
-    BOOST_CHECK(i==a.underlying());
+    BOOST_TEST(i==a.underlying());
 }
 #endif
 void plus_test() {
     NT a2, b3(3), c6(6);
     a2 = c6 + b3;
-    BOOST_CHECK(a2.underlying()=9);
+    BOOST_TEST(a2.underlying()=9);
 }
 
-test_suite* init_unit_test_suite(int, char*[])
+int main()
 {
-  test_suite* test = BOOST_TEST_SUITE("new_class.using_plus_pass");
 
-  test->add(BOOST_TEST_CASE(&size_test));
+  size_test();
 #if 0
-  test->add(BOOST_TEST_CASE(&default_constructor_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut_test));
-  test->add(BOOST_TEST_CASE(&copy_from_ut2_test));
-  test->add(BOOST_TEST_CASE(&copy_constructor_test));
-  test->add(BOOST_TEST_CASE(&assign_test));
-  test->add(BOOST_TEST_CASE(&opaque_static_cast_test));
+  default_constructor_test();
+  copy_from_ut_test();
+  copy_from_ut2_test();
+  copy_constructor_test();
+  assign_test();
+  opaque_static_cast_test();
 #endif  
-  test->add(BOOST_TEST_CASE(&plus_test));
+  plus_test();
 
-  return test;
+  return boost::report_errors();
 }

Modified: sandbox/opaque/libs/opaque/test/new_class_test.cpp
==============================================================================
--- sandbox/opaque/libs/opaque/test/new_class_test.cpp	(original)
+++ sandbox/opaque/libs/opaque/test/new_class_test.cpp	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -10,10 +10,9 @@
 
 #include <boost/opaque/opaque.hpp>
 
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace boost;
-using namespace boost::unit_test;
 
 
 struct private_unsigned : 
@@ -57,8 +56,8 @@
 
 void size_test() {
 
-    BOOST_CHECK(sizeof(private_unsigned)==sizeof(unsigned));
-    BOOST_CHECK(sizeof(private_unsigned2)==sizeof(unsigned));
+    BOOST_TEST(sizeof(private_unsigned)==sizeof(unsigned));
+    BOOST_TEST(sizeof(private_unsigned2)==sizeof(unsigned));
 }
 
 void private_assign_test() {
@@ -78,105 +77,93 @@
 
 void private_eq_test() {
     private_unsigned a(1), b(2), c(2);
-    BOOST_CHECK(b==c);
-    BOOST_CHECK((a==b)==false);
+    BOOST_TEST(b==c);
+    BOOST_TEST((a==b)==false);
 }
 void private_neq_test() {
     private_unsigned a(1), b(2), c(2);
-    BOOST_CHECK(a!=b);
-    BOOST_CHECK((b!=c)==false);
+    BOOST_TEST(a!=b);
+    BOOST_TEST((b!=c)==false);
 }
 //~ void private_lt_test() {
     //~ private_unsigned a(1), b(2), c(2);
-    //~ BOOST_CHECK(a<b);
-    //~ BOOST_CHECK((b<a)==false);
-    //~ BOOST_CHECK((b<c)==false);
+    //~ BOOST_TEST(a<b);
+    //~ BOOST_TEST((b<a)==false);
+    //~ BOOST_TEST((b<c)==false);
 //~ }
 #if 0
 
 void private_gt_test() {
     private_unsigned a(1), b(2), c(2);
-    BOOST_CHECK(b>a);
-    BOOST_CHECK((a>b)==false);
-    BOOST_CHECK((b>c)==false);
+    BOOST_TEST(b>a);
+    BOOST_TEST((a>b)==false);
+    BOOST_TEST((b>c)==false);
 }
 
 void private_le_test() {
     private_unsigned a(1), b(2), c(2);
-    BOOST_CHECK(a<=b);
-    BOOST_CHECK((b<=a)==false);
-    BOOST_CHECK(b<=c);
+    BOOST_TEST(a<=b);
+    BOOST_TEST((b<=a)==false);
+    BOOST_TEST(b<=c);
 }
 void private_ge_test() {
     private_unsigned a(1), b(2), c(2);
-    BOOST_CHECK(b>=a);
-    BOOST_CHECK((a>=b)==false);
-    BOOST_CHECK(b>=c);
+    BOOST_TEST(b>=a);
+    BOOST_TEST((a>=b)==false);
+    BOOST_TEST(b>=c);
 }
 
 void private_add_test() {
     private_unsigned a(1), b(2), c(3),d(4);
-    BOOST_CHECK(a+b==c);
-    BOOST_CHECK(c==a+b);
-    BOOST_CHECK((a+b==d)==false);
-    BOOST_CHECK((d==a+b)==false);
+    BOOST_TEST(a+b==c);
+    BOOST_TEST(c==a+b);
+    BOOST_TEST((a+b==d)==false);
+    BOOST_TEST((d==a+b)==false);
 
     private_unsigned2 x;
     //~ a=a+x; // error
 
     //~ unsigned u=3,v=0;
-    //~ BOOST_CHECK(a+b==3u);
-    //~ BOOST_CHECK(u==a+b);
-    //~ BOOST_CHECK(a+b==u);
-    //~ BOOST_CHECK((a+b==v)==false);
-    //~ BOOST_CHECK((v==a+b)==false);
+    //~ BOOST_TEST(a+b==3u);
+    //~ BOOST_TEST(u==a+b);
+    //~ BOOST_TEST(a+b==u);
+    //~ BOOST_TEST((a+b==v)==false);
+    //~ BOOST_TEST((v==a+b)==false);
 
 }
 
 void private_substract_test() {
     private_unsigned a(1), b(2), c(3),d(4);
-    BOOST_CHECK(c-b==a);
-    BOOST_CHECK(a==c-b);
-    BOOST_CHECK((c-b==d)==false);
-    BOOST_CHECK((d==c-b)==false);
+    BOOST_TEST(c-b==a);
+    BOOST_TEST(a==c-b);
+    BOOST_TEST((c-b==d)==false);
+    BOOST_TEST((d==c-b)==false);
 
     //~ unsigned u=1,v=0;
-    //~ BOOST_CHECK(c-b==1u);
-    //~ BOOST_CHECK(u==c-b);
-    //~ BOOST_CHECK(c-b==u);
-    //~ BOOST_CHECK((c-b==v)==false);
-    //~ BOOST_CHECK((v==c-b)==false);
+    //~ BOOST_TEST(c-b==1u);
+    //~ BOOST_TEST(u==c-b);
+    //~ BOOST_TEST(c-b==u);
+    //~ BOOST_TEST((c-b==v)==false);
+    //~ BOOST_TEST((v==c-b)==false);
 
 }
 
-test_suite* init_unit_test_suite(int, char*[])
-{
-  test_suite* test = BOOST_TEST_SUITE("private");
-
-
-  test->add(BOOST_TEST_CASE(&size_test));
-  test->add(BOOST_TEST_CASE(&private_assign_test));
-  test->add(BOOST_TEST_CASE(&private_eq_test));
-  test->add(BOOST_TEST_CASE(&private_lt_test));
-  test->add(BOOST_TEST_CASE(&private_gt_test));
-  test->add(BOOST_TEST_CASE(&private_le_test));
-  test->add(BOOST_TEST_CASE(&private_ge_test));
-  test->add(BOOST_TEST_CASE(&private_add_test));
-  test->add(BOOST_TEST_CASE(&private_substract_test));
-
-  return test;
-}
 
 #endif
 
-test_suite* init_unit_test_suite(int, char*[])
+int main()
 {
-  test_suite* test = BOOST_TEST_SUITE("new");
-
 
-  test->add(BOOST_TEST_CASE(&private_assign_test));
-  test->add(BOOST_TEST_CASE(&private_eq_test));
-  test->add(BOOST_TEST_CASE(&private_neq_test));
+  //~ size_test();
+  private_assign_test();
+  private_eq_test();
+  private_neq_test();
+  //~ private_lt_test();
+  //~ private_gt_test();
+  //~ private_le_test();
+  //~ private_ge_test();
+  //~ private_add_test();
+  //~ private_substract_test();
 
-  return test;
+  return boost::report_errors();
 }

Modified: sandbox/opaque/libs/opaque/test/new_type_test.cpp
==============================================================================
--- sandbox/opaque/libs/opaque/test/new_type_test.cpp	(original)
+++ sandbox/opaque/libs/opaque/test/new_type_test.cpp	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -10,10 +10,9 @@
 
 #include <boost/opaque/opaque.hpp>
 
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace boost;
-using namespace boost::unit_test;
 
 
 struct private_unsigned_tag;
@@ -24,8 +23,8 @@
 
 void size_test() {
 
-    BOOST_CHECK(sizeof(private_unsigned)==sizeof(unsigned));
-    BOOST_CHECK(sizeof(private_unsigned2)==sizeof(unsigned));
+    BOOST_TEST(sizeof(private_unsigned)==sizeof(unsigned));
+    BOOST_TEST(sizeof(private_unsigned2)==sizeof(unsigned));
 }
 
 void private_assign_test() {
@@ -45,105 +44,94 @@
 
 void private_eq_test() {
     private_unsigned a(1), b(2), c(2);
-    BOOST_CHECK(b==c);
-    BOOST_CHECK((a==b)==false);
+    BOOST_TEST(b==c);
+    BOOST_TEST((a==b)==false);
 }
 void private_neq_test() {
     private_unsigned a(1), b(2), c(2);
-    BOOST_CHECK(a!=b);
-    BOOST_CHECK((b!=c)==false);
+    BOOST_TEST(a!=b);
+    BOOST_TEST((b!=c)==false);
 }
 //~ void private_lt_test() {
     //~ private_unsigned a(1), b(2), c(2);
-    //~ BOOST_CHECK(a<b);
-    //~ BOOST_CHECK((b<a)==false);
-    //~ BOOST_CHECK((b<c)==false);
+    //~ BOOST_TEST(a<b);
+    //~ BOOST_TEST((b<a)==false);
+    //~ BOOST_TEST((b<c)==false);
 //~ }
 #if 0
 
 void private_gt_test() {
     private_unsigned a(1), b(2), c(2);
-    BOOST_CHECK(b>a);
-    BOOST_CHECK((a>b)==false);
-    BOOST_CHECK((b>c)==false);
+    BOOST_TEST(b>a);
+    BOOST_TEST((a>b)==false);
+    BOOST_TEST((b>c)==false);
 }
 
 void private_le_test() {
     private_unsigned a(1), b(2), c(2);
-    BOOST_CHECK(a<=b);
-    BOOST_CHECK((b<=a)==false);
-    BOOST_CHECK(b<=c);
+    BOOST_TEST(a<=b);
+    BOOST_TEST((b<=a)==false);
+    BOOST_TEST(b<=c);
 }
 void private_ge_test() {
     private_unsigned a(1), b(2), c(2);
-    BOOST_CHECK(b>=a);
-    BOOST_CHECK((a>=b)==false);
-    BOOST_CHECK(b>=c);
+    BOOST_TEST(b>=a);
+    BOOST_TEST((a>=b)==false);
+    BOOST_TEST(b>=c);
 }
 
 void private_add_test() {
     private_unsigned a(1), b(2), c(3),d(4);
-    BOOST_CHECK(a+b==c);
-    BOOST_CHECK(c==a+b);
-    BOOST_CHECK((a+b==d)==false);
-    BOOST_CHECK((d==a+b)==false);
+    BOOST_TEST(a+b==c);
+    BOOST_TEST(c==a+b);
+    BOOST_TEST((a+b==d)==false);
+    BOOST_TEST((d==a+b)==false);
 
     private_unsigned2 x;
     //~ a=a+x; // error
 
     //~ unsigned u=3,v=0;
-    //~ BOOST_CHECK(a+b==3u);
-    //~ BOOST_CHECK(u==a+b);
-    //~ BOOST_CHECK(a+b==u);
-    //~ BOOST_CHECK((a+b==v)==false);
-    //~ BOOST_CHECK((v==a+b)==false);
+    //~ BOOST_TEST(a+b==3u);
+    //~ BOOST_TEST(u==a+b);
+    //~ BOOST_TEST(a+b==u);
+    //~ BOOST_TEST((a+b==v)==false);
+    //~ BOOST_TEST((v==a+b)==false);
 
 }
 
 void private_substract_test() {
     private_unsigned a(1), b(2), c(3),d(4);
-    BOOST_CHECK(c-b==a);
-    BOOST_CHECK(a==c-b);
-    BOOST_CHECK((c-b==d)==false);
-    BOOST_CHECK((d==c-b)==false);
+    BOOST_TEST(c-b==a);
+    BOOST_TEST(a==c-b);
+    BOOST_TEST((c-b==d)==false);
+    BOOST_TEST((d==c-b)==false);
 
     //~ unsigned u=1,v=0;
-    //~ BOOST_CHECK(c-b==1u);
-    //~ BOOST_CHECK(u==c-b);
-    //~ BOOST_CHECK(c-b==u);
-    //~ BOOST_CHECK((c-b==v)==false);
-    //~ BOOST_CHECK((v==c-b)==false);
+    //~ BOOST_TEST(c-b==1u);
+    //~ BOOST_TEST(u==c-b);
+    //~ BOOST_TEST(c-b==u);
+    //~ BOOST_TEST((c-b==v)==false);
+    //~ BOOST_TEST((v==c-b)==false);
 
 }
 
-test_suite* init_unit_test_suite(int, char*[])
-{
-  test_suite* test = BOOST_TEST_SUITE("private");
-
-
-  test->add(BOOST_TEST_CASE(&size_test));
-  test->add(BOOST_TEST_CASE(&private_assign_test));
-  test->add(BOOST_TEST_CASE(&private_eq_test));
-  test->add(BOOST_TEST_CASE(&private_lt_test));
-  test->add(BOOST_TEST_CASE(&private_gt_test));
-  test->add(BOOST_TEST_CASE(&private_le_test));
-  test->add(BOOST_TEST_CASE(&private_ge_test));
-  test->add(BOOST_TEST_CASE(&private_add_test));
-  test->add(BOOST_TEST_CASE(&private_substract_test));
-
-  return test;
-}
-
 #endif
 
-test_suite* init_unit_test_suite(int, char*[])
+int main()
 {
-  test_suite* test = BOOST_TEST_SUITE("new");
-
 
-  test->add(BOOST_TEST_CASE(&private_assign_test));
-  test->add(BOOST_TEST_CASE(&private_eq_test));
-  test->add(BOOST_TEST_CASE(&private_neq_test));
 
-  return test;
+  private_assign_test();
+  private_eq_test();
+  private_neq_test();
+
+  //~ size_test();
+  //~ private_lt_test();
+  //~ private_gt_test();
+  //~ private_le_test();
+  //~ private_ge_test();
+  //~ private_add_test();
+  //~ private_substract_test();
+	
+  return boost::report_errors();
 }

Modified: sandbox/opaque/libs/opaque/test/private_opaque_test.cpp
==============================================================================
--- sandbox/opaque/libs/opaque/test/private_opaque_test.cpp	(original)
+++ sandbox/opaque/libs/opaque/test/private_opaque_test.cpp	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -10,10 +10,9 @@
 
 #include <boost/opaque/opaque.hpp>
 
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace boost;
-using namespace boost::unit_test;
 
 
 
@@ -22,7 +21,7 @@
 
 void size_test() {
 
-    BOOST_CHECK(sizeof(private_unsigned)==sizeof(unsigned));
+    BOOST_TEST(sizeof(private_unsigned)==sizeof(unsigned));
 }
 
 void assign_test() {
@@ -44,120 +43,119 @@
 
 void eq_test() {
     private_unsigned a(1), b(2), c(2);
-    BOOST_CHECK(b==c);
-    BOOST_CHECK((a==b)==false);
+    BOOST_TEST(b==c);
+    BOOST_TEST((a==b)==false);
 }
 
 void neq_test() {
     private_unsigned a(1), b(2), c(2);
-    BOOST_CHECK(a!=b);
-    BOOST_CHECK((b!=c)==false);
+    BOOST_TEST(a!=b);
+    BOOST_TEST((b!=c)==false);
 }
 
 void lt_test() {
     private_unsigned a(1), b(2), c(2);
-    BOOST_CHECK(a<b);
-    BOOST_CHECK((b<a)==false);
-    BOOST_CHECK((b<c)==false);
+    BOOST_TEST(a<b);
+    BOOST_TEST((b<a)==false);
+    BOOST_TEST((b<c)==false);
 }
 
 void gt_test() {
     private_unsigned a(1), b(2), c(2);
-    BOOST_CHECK(b>a);
-    BOOST_CHECK((a>b)==false);
-    BOOST_CHECK((b>c)==false);
+    BOOST_TEST(b>a);
+    BOOST_TEST((a>b)==false);
+    BOOST_TEST((b>c)==false);
 }
 
 void le_test() {
     private_unsigned a(1), b(2), c(2);
-    BOOST_CHECK(a<=b);
-    BOOST_CHECK((b<=a)==false);
-    BOOST_CHECK(b<=c);
+    BOOST_TEST(a<=b);
+    BOOST_TEST((b<=a)==false);
+    BOOST_TEST(b<=c);
 }
 void ge_test() {
     private_unsigned a(1), b(2), c(2);
-    BOOST_CHECK(b>=a);
-    BOOST_CHECK((a>=b)==false);
-    BOOST_CHECK(b>=c);
+    BOOST_TEST(b>=a);
+    BOOST_TEST((a>=b)==false);
+    BOOST_TEST(b>=c);
 }
 
 void add_test() {
     private_unsigned a(1), b(2), c(3),d(4);
-    BOOST_CHECK(a+b==c);
-    BOOST_CHECK(c==a+b);
-    BOOST_CHECK((a+b==d)==false);
-    BOOST_CHECK((d==a+b)==false);
+    BOOST_TEST(a+b==c);
+    BOOST_TEST(c==a+b);
+    BOOST_TEST((a+b==d)==false);
+    BOOST_TEST((d==a+b)==false);
 }
 
 void substract_test() {
     private_unsigned a(1), b(2), c(3),d(4);
-    BOOST_CHECK(c-b==a);
-    BOOST_CHECK(a==c-b);
-    BOOST_CHECK((c-b==d)==false);
-    BOOST_CHECK((d==c-b)==false);
+    BOOST_TEST(c-b==a);
+    BOOST_TEST(a==c-b);
+    BOOST_TEST((c-b==d)==false);
+    BOOST_TEST((d==c-b)==false);
 }
 
 void multiply_test() {
     private_unsigned a(1), b(2), c(3),d(6);
-    BOOST_CHECK(b*c==d);
-    BOOST_CHECK(b==a*b);
-    BOOST_CHECK((b*c==a)==false);
-    BOOST_CHECK((d==a*b)==false);
+    BOOST_TEST(b*c==d);
+    BOOST_TEST(b==a*b);
+    BOOST_TEST((b*c==a)==false);
+    BOOST_TEST((d==a*b)==false);
 }
 
 void divide_test() {
     private_unsigned a(1), b(2), c(3),d(6);
-    BOOST_CHECK(d/c==b);
-    BOOST_CHECK(b==d/c);
-    BOOST_CHECK((d/c==a)==false);
-    BOOST_CHECK((a==d/c)==false);
+    BOOST_TEST(d/c==b);
+    BOOST_TEST(b==d/c);
+    BOOST_TEST((d/c==a)==false);
+    BOOST_TEST((a==d/c)==false);
 }
 
 
 void unariy_plus_test() {
     private_unsigned a(1);
-    BOOST_CHECK(+a==a);
+    BOOST_TEST(+a==a);
 }
 
 void unariy_minus_test() {
     private_unsigned a(1);
-    BOOST_CHECK(-a==private_unsigned(-1));
+    BOOST_TEST(-a==private_unsigned(-1));
 }
 
 void pre_increment_test() {
     private_unsigned a(1);
     private_unsigned b(2);
-    BOOST_CHECK(++a==b);
+    BOOST_TEST(++a==b);
 }
 
 void post_increment_test() {
     private_unsigned a(1);
     private_unsigned b(1);
-    BOOST_CHECK(a++==b);
-    BOOST_CHECK(a==private_unsigned(2));
+    BOOST_TEST(a++==b);
+    BOOST_TEST(a==private_unsigned(2));
 }
 
 
-test_suite* init_unit_test_suite(int, char*[])
+int main()
 {
-  test_suite* test = BOOST_TEST_SUITE("private");
 
-  test->add(BOOST_TEST_CASE(&size_test));
-  test->add(BOOST_TEST_CASE(&assign_test));
-  test->add(BOOST_TEST_CASE(&eq_test));
-  test->add(BOOST_TEST_CASE(&neq_test));
-  test->add(BOOST_TEST_CASE(&lt_test));
-  test->add(BOOST_TEST_CASE(&gt_test));
-  test->add(BOOST_TEST_CASE(&le_test));
-  test->add(BOOST_TEST_CASE(&ge_test));
-  test->add(BOOST_TEST_CASE(&add_test));
-  test->add(BOOST_TEST_CASE(&substract_test));
-  test->add(BOOST_TEST_CASE(&multiply_test));
-  test->add(BOOST_TEST_CASE(&divide_test));
-  test->add(BOOST_TEST_CASE(&unariy_plus_test));
-  test->add(BOOST_TEST_CASE(&unariy_minus_test));
-  test->add(BOOST_TEST_CASE(&pre_increment_test));
-  test->add(BOOST_TEST_CASE(&post_increment_test));
+  size_test();
+  assign_test();
+  eq_test();
+  neq_test();
+  lt_test();
+  gt_test();
+  le_test();
+  ge_test();
+  add_test();
+  substract_test();
+  multiply_test();
+  divide_test();
+  unariy_plus_test();
+  unariy_minus_test();
+  pre_increment_test();
+  post_increment_test();
 
-  return test;
+  return boost::report_errors();
 }

Modified: sandbox/opaque/libs/opaque/test/public_opaque_test.cpp
==============================================================================
--- sandbox/opaque/libs/opaque/test/public_opaque_test.cpp	(original)
+++ sandbox/opaque/libs/opaque/test/public_opaque_test.cpp	2011-02-13 17:38:40 EST (Sun, 13 Feb 2011)
@@ -9,17 +9,16 @@
 //////////////////////////////////////////////////////////////////////////////
 
 #include <boost/opaque/opaque.hpp>
-#include <boost/test/unit_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using namespace boost;
-using namespace boost::unit_test;
 
 BOOST_OPAQUE_PUBLIC_TYPEDEF(unsigned,public_unsigned);
 BOOST_OPAQUE_PUBLIC_TYPEDEF(unsigned,public_unsigned2);
 
 void size_test() {
 
-    BOOST_CHECK(sizeof(public_unsigned)==sizeof(unsigned));
+    BOOST_TEST(sizeof(public_unsigned)==sizeof(unsigned));
 }
 
 void assign_test() {
@@ -39,146 +38,144 @@
 
 void eq_test() {
     public_unsigned a(1), b(2), c(2);
-    BOOST_CHECK(b==c);
-    BOOST_CHECK((a==b)==false);
+    BOOST_TEST(b==c);
+    BOOST_TEST((a==b)==false);
 
     unsigned u=1,v=2;
-    BOOST_CHECK(a==1u);
-    BOOST_CHECK(u==a);
-    BOOST_CHECK(a==u);
-    BOOST_CHECK((a==v)==false);
-    BOOST_CHECK((v==a)==false);
+    BOOST_TEST(a==1u);
+    BOOST_TEST(u==a);
+    BOOST_TEST(a==u);
+    BOOST_TEST((a==v)==false);
+    BOOST_TEST((v==a)==false);
 }
 
 void neq_test() {
     public_unsigned a(1), b(2), c(2);
-    BOOST_CHECK(a!=b);
-    BOOST_CHECK((b!=c)==false);
+    BOOST_TEST(a!=b);
+    BOOST_TEST((b!=c)==false);
 }
 
 
 void lt_test() {
     public_unsigned a(1), b(2), c(2);
-    BOOST_CHECK(a<b);
-    BOOST_CHECK((b<a)==false);
-    BOOST_CHECK((b<c)==false);
+    BOOST_TEST(a<b);
+    BOOST_TEST((b<a)==false);
+    BOOST_TEST((b<c)==false);
 }
 
 void gt_test() {
     public_unsigned a(1), b(2), c(2);
-    BOOST_CHECK(b>a);
-    BOOST_CHECK((a>b)==false);
-    BOOST_CHECK((b>c)==false);
+    BOOST_TEST(b>a);
+    BOOST_TEST((a>b)==false);
+    BOOST_TEST((b>c)==false);
 }
 
 void le_test() {
     public_unsigned a(1), b(2), c(2);
-    BOOST_CHECK(a<=b);
-    BOOST_CHECK((b<=a)==false);
-    BOOST_CHECK(b<=c);
+    BOOST_TEST(a<=b);
+    BOOST_TEST((b<=a)==false);
+    BOOST_TEST(b<=c);
 }
 void ge_test() {
     public_unsigned a(1), b(2), c(2);
-    BOOST_CHECK(b>=a);
-    BOOST_CHECK((a>=b)==false);
-    BOOST_CHECK(b>=c);
+    BOOST_TEST(b>=a);
+    BOOST_TEST((a>=b)==false);
+    BOOST_TEST(b>=c);
 }
 
 void add_test() {
     public_unsigned a(1), b(2), c(3),d(4);
-    BOOST_CHECK(a+b==c);
-    BOOST_CHECK(c==a+b);
-    BOOST_CHECK((a+b==d)==false);
-    BOOST_CHECK((d==a+b)==false);
+    BOOST_TEST(a+b==c);
+    BOOST_TEST(c==a+b);
+    BOOST_TEST((a+b==d)==false);
+    BOOST_TEST((d==a+b)==false);
 
     //~ public_unsigned2 x;
     //~ a=a+x; // error
 
     unsigned u=3,v=0;
-    BOOST_CHECK(a+b==3u);
-    BOOST_CHECK(u==a+b);
-    BOOST_CHECK(a+b==u);
-    BOOST_CHECK((a+b==v)==false);
-    BOOST_CHECK((v==a+b)==false);
+    BOOST_TEST(a+b==3u);
+    BOOST_TEST(u==a+b);
+    BOOST_TEST(a+b==u);
+    BOOST_TEST((a+b==v)==false);
+    BOOST_TEST((v==a+b)==false);
 
 }
 
 void substract_test() {
     public_unsigned a(1), b(2), c(3),d(4);
-    BOOST_CHECK(c-b==a);
-    BOOST_CHECK(a==c-b);
-    BOOST_CHECK((c-b==d)==false);
-    BOOST_CHECK((d==c-b)==false);
+    BOOST_TEST(c-b==a);
+    BOOST_TEST(a==c-b);
+    BOOST_TEST((c-b==d)==false);
+    BOOST_TEST((d==c-b)==false);
 
     unsigned u=1,v=0;
-    BOOST_CHECK(c-b==1u);
-    BOOST_CHECK(u==c-b);
-    BOOST_CHECK(c-b==u);
-    BOOST_CHECK((c-b==v)==false);
-    BOOST_CHECK((v==c-b)==false);
+    BOOST_TEST(c-b==1u);
+    BOOST_TEST(u==c-b);
+    BOOST_TEST(c-b==u);
+    BOOST_TEST((c-b==v)==false);
+    BOOST_TEST((v==c-b)==false);
 
 }
 
 void multiply_test() {
     public_unsigned a(1), b(2), c(3),d(6);
-    BOOST_CHECK(b*c==d);
-    BOOST_CHECK(b==a*b);
-    BOOST_CHECK((b*c==a)==false);
-    BOOST_CHECK((d==a*b)==false);
+    BOOST_TEST(b*c==d);
+    BOOST_TEST(b==a*b);
+    BOOST_TEST((b*c==a)==false);
+    BOOST_TEST((d==a*b)==false);
 }
 
 void divide_test() {
     public_unsigned a(1), b(2), c(3),d(6);
-    BOOST_CHECK(d/c==b);
-    BOOST_CHECK(b==d/c);
-    BOOST_CHECK((d/c==a)==false);
-    BOOST_CHECK((a==d/c)==false);
+    BOOST_TEST(d/c==b);
+    BOOST_TEST(b==d/c);
+    BOOST_TEST((d/c==a)==false);
+    BOOST_TEST((a==d/c)==false);
 }
 
 
 void unariy_plus_test() {
     public_unsigned a(1);
-    BOOST_CHECK(+a==a);
+    BOOST_TEST(+a==a);
 }
 
 void unariy_minus_test() {
     public_unsigned a(1);
-    BOOST_CHECK(-a==public_unsigned(-1));
+    BOOST_TEST(-a==public_unsigned(-1));
 }
 
 void pre_increment_test() {
     public_unsigned a(1);
     public_unsigned b(2);
-    BOOST_CHECK(++a==b);
+    BOOST_TEST(++a==b);
 }
 
 void post_increment_test() {
     public_unsigned a(1);
     public_unsigned b(1);
-    BOOST_CHECK(a++==b);
-    BOOST_CHECK(a==public_unsigned(2));
+    BOOST_TEST(a++==b);
+    BOOST_TEST(a==public_unsigned(2));
 }
 
-test_suite* init_unit_test_suite(int, char*[])
+int main()
 {
-  test_suite* test = BOOST_TEST_SUITE("public");
+  size_test();
+  assign_test();
+  eq_test();
+  neq_test();
+  lt_test();
+  gt_test();
+  le_test();
+  ge_test();
+  add_test();
+  substract_test();
+  multiply_test();
+  divide_test();
+  unariy_plus_test();
+  unariy_minus_test();
+  pre_increment_test();
+  post_increment_test();
 
-  test->add(BOOST_TEST_CASE(&size_test));
-  test->add(BOOST_TEST_CASE(&assign_test));
-  test->add(BOOST_TEST_CASE(&eq_test));
-  test->add(BOOST_TEST_CASE(&neq_test));
-  test->add(BOOST_TEST_CASE(&lt_test));
-  test->add(BOOST_TEST_CASE(&gt_test));
-  test->add(BOOST_TEST_CASE(&le_test));
-  test->add(BOOST_TEST_CASE(&ge_test));
-  test->add(BOOST_TEST_CASE(&add_test));
-  test->add(BOOST_TEST_CASE(&substract_test));
-  test->add(BOOST_TEST_CASE(&multiply_test));
-  test->add(BOOST_TEST_CASE(&divide_test));
-  test->add(BOOST_TEST_CASE(&unariy_plus_test));
-  test->add(BOOST_TEST_CASE(&unariy_minus_test));
-  test->add(BOOST_TEST_CASE(&pre_increment_test));
-  test->add(BOOST_TEST_CASE(&post_increment_test));
-
-  return test;
+  return boost::report_errors();
 }