[Boost-commit] svn:boost r49096 - in sandbox/SOC/2006/tree/trunk: boost/tree libs/tree/test

Subject: [Boost-commit] svn:boost r49096 - in sandbox/SOC/2006/tree/trunk: boost/tree libs/tree/test
From: ockham_at_[hidden]
Date: 2008-10-01 15:38:18

Author: bernhard.reiter
Date: 2008-10-01 15:38:16 EDT (Wed, 01 Oct 2008)
New Revision: 49096
URL: http://svn.boost.org/trac/boost/changeset/49096

Log:
Test cleanup continued.
Removed:
   sandbox/SOC/2006/tree/trunk/libs/tree/test/subtree_algorithms_checks.hpp
Text files modified: 
   sandbox/SOC/2006/tree/trunk/boost/tree/forest_tree.hpp                          |     5 --                                      
   sandbox/SOC/2006/tree/trunk/libs/tree/test/binary_tree_search_test.cpp          |     8 +-                                      
   sandbox/SOC/2006/tree/trunk/libs/tree/test/binary_tree_test.cpp                 |     3                                         
   sandbox/SOC/2006/tree/trunk/libs/tree/test/cursor_algorithm_test.cpp            |    56 ++++++++++++++++++++---                 
   sandbox/SOC/2006/tree/trunk/libs/tree/test/forest_tree_test.cpp                 |    10 +--                                     
   sandbox/SOC/2006/tree/trunk/libs/tree/test/graph_test.cpp                       |     8 +-                                      
   sandbox/SOC/2006/tree/trunk/libs/tree/test/interval_search_binary_tree_test.cpp |    16 +-----                                  
   sandbox/SOC/2006/tree/trunk/libs/tree/test/iterator_algorithm_test.cpp          |    93 ++++++++++++++++++++++++--------------- 
   sandbox/SOC/2006/tree/trunk/libs/tree/test/key_search_binary_tree_test.cpp      |    16 ++----                                  
   sandbox/SOC/2006/tree/trunk/libs/tree/test/multiway_tree_test.cpp               |    14 ++---                                   
   sandbox/SOC/2006/tree/trunk/libs/tree/test/nary_tree_test.cpp                   |    14 +----                                   
   sandbox/SOC/2006/tree/trunk/libs/tree/test/range_helpers_test.cpp               |     9 +--                                     
   sandbox/SOC/2006/tree/trunk/libs/tree/test/rank_search_binary_tree_test.cpp     |    12 ----                                    
   sandbox/SOC/2006/tree/trunk/libs/tree/test/red_black_tree_test.cpp              |    16 ++----                                  
   sandbox/SOC/2006/tree/trunk/libs/tree/test/rotate_binary_tree_test.cpp          |    13 +---                                    
   sandbox/SOC/2006/tree/trunk/libs/tree/test/search_ordered_vector_test.cpp       |    18 ++-----                                 
   sandbox/SOC/2006/tree/trunk/libs/tree/test/string_search_binary_tree_test.cpp   |     8 +-                                      
   sandbox/SOC/2006/tree/trunk/libs/tree/test/treap_test.cpp                       |    17 ++-----                                 
   sandbox/SOC/2006/tree/trunk/libs/tree/test/unbalanced_binary_tree_test.cpp      |    19 +------                                 
   19 files changed, 167 insertions(+), 188 deletions(-)

Modified: sandbox/SOC/2006/tree/trunk/boost/tree/forest_tree.hpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/boost/tree/forest_tree.hpp	(original)
+++ sandbox/SOC/2006/tree/trunk/boost/tree/forest_tree.hpp	2008-10-01 15:38:16 EDT (Wed, 01 Oct 2008)
@@ -9,17 +9,12 @@
  * Binary tree based forest implementation
  */
 
-
 #ifndef BOOST_TREE_FOREST_TREE_HPP
 #define BOOST_TREE_FOREST_TREE_HPP
 
-
 #include <boost/tree/detail/cursor/forest.hpp>
 #include <boost/tree/binary_tree.hpp>
 
-#include <boost/test/minimal.hpp>
-
-
 namespace boost {
 namespace tree {
 

Modified: sandbox/SOC/2006/tree/trunk/libs/tree/test/binary_tree_search_test.cpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/libs/tree/test/binary_tree_search_test.cpp	(original)
+++ sandbox/SOC/2006/tree/trunk/libs/tree/test/binary_tree_search_test.cpp	2008-10-01 15:38:16 EDT (Wed, 01 Oct 2008)
@@ -10,7 +10,9 @@
 #include <boost/tree/iterator.hpp>
 #include <boost/tree/algorithm.hpp>
 
-#include <boost/test/minimal.hpp>
+#define BOOST_TEST_MODULE binary_tree test
+//#define BOOST_TEST_DYN_LINK
+#include <boost/test/included/unit_test.hpp>
 
 #include <list>
 #include <algorithm>
@@ -31,7 +33,7 @@
     //BOOST_CHECK(inorder::next(c) == d);
 }
 
-int test_main(int, char* [])
+BOOST_AUTO_TEST_CASE( binary_tree_search_test )
 {
     binary_tree<int> test_tree;
     create_test_data_tree(test_tree);
@@ -62,6 +64,4 @@
     
     *c.to_parent() = 6;
     validate_test_data_tree(test_tree);
-    
-    return 0;
 }

Modified: sandbox/SOC/2006/tree/trunk/libs/tree/test/binary_tree_test.cpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/libs/tree/test/binary_tree_test.cpp	(original)
+++ sandbox/SOC/2006/tree/trunk/libs/tree/test/binary_tree_test.cpp	2008-10-01 15:38:16 EDT (Wed, 01 Oct 2008)
@@ -155,8 +155,7 @@
     // test with allocator 
 }
 
-//int test_main(int, char* [])
-BOOST_AUTO_TEST_CASE( old_test )
+BOOST_AUTO_TEST_CASE( binary_tree_test )
 {
     typedef binary_tree<int> tree_t;
     tree_t tree1, tree2;

Modified: sandbox/SOC/2006/tree/trunk/libs/tree/test/cursor_algorithm_test.cpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/libs/tree/test/cursor_algorithm_test.cpp	(original)
+++ sandbox/SOC/2006/tree/trunk/libs/tree/test/cursor_algorithm_test.cpp	2008-10-01 15:38:16 EDT (Wed, 01 Oct 2008)
@@ -4,12 +4,12 @@
 //  (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 
-
 #include <boost/tree/binary_tree.hpp>
-
 #include <boost/tree/iterator.hpp>
 #include <boost/tree/algorithm.hpp>
 
+#include <boost/lambda/bind.hpp>
+
 #include <list>
 #include <algorithm>
 #include <iterator>
@@ -24,17 +24,57 @@
 
 using namespace boost::tree;
 
-// Some macro magic, to save us from all too tedious redundant calls
-// to each of the three types of order algorithms and checks.
+template <class Order, class Cursor, class Container>
+void test_for_each(Order, Cursor c, Container& cont)
+{
+    boost::tree::for_each(
+        Order(),
+        c, 
+        boost::lambda::bind(&Container::push_back, &cont, boost::lambda::_1)
+    );
+    test_traversal(Order(), cont.begin(), cont.end());
+}
+
+template <class Order, class Cursor, class OutCursor, class Container>
+void test_copy(Order, Cursor c, OutCursor& o, Container& cont)
+{    
+    boost::tree::copy(Order(), c, o);
+    test_traversal(Order(), cont.begin(), cont.end());
+}
+
+template <class Order, class Cursor, class OutCursor, class Container>
+void test_transform(Order, Cursor c, Cursor d, OutCursor& o, Container& cont)
+{
+    // First copy test_tree to test_tree2, by adding 1 to each element,
+    // then copy test_tree2 to test_list, by subtracting 1 - so 
+    // test_list should hold test_tree's original elements in ORDER.
+    boost::tree::transform(Order(), c, d, std::bind2nd(std::plus<int>(),1));
+    boost::tree::transform(Order(), d, o, std::bind2nd(std::minus<int>(),1));
+    test_traversal(Order(), cont.begin(), cont.end());
+}
 
-#include "subtree_algorithms_checks.hpp"
+template <class Order, class Cursor>
+void algorithms(Order, Cursor c, Cursor d)
+{
+    std::list<int> test_list;
+    typedef std::back_insert_iterator< std::list<int> > back_insert_iter_list_int;
+    typedef output_cursor_iterator_wrapper<back_insert_iter_list_int> oc_bi_lst_type;
+    back_insert_iter_list_int it_test_list = std::back_inserter(test_list);
+    oc_bi_lst_type oc_test_list = oc_bi_lst_type(it_test_list);
+    
+    test_for_each(Order(), c, test_list);
+    
+    test_list.clear();
+    test_copy(Order(), c, oc_test_list, test_list);
+    
+    test_list.clear();
+    test_transform(Order(), c, d, oc_test_list, test_list);
+}
 
 typedef boost::mpl::list<preorder,inorder,postorder> orders;
 
 BOOST_AUTO_TEST_CASE_TEMPLATE( test_algorithms, Order, orders )
 {
-    using boost::forward_traversal_tag;
-    
     binary_tree<int> test_tree, test_tree2;
     create_test_data_tree(test_tree);
     create_test_data_tree(test_tree2);
@@ -50,5 +90,5 @@
     BOOST_CHECK(test_tree != test_tree2);
     d = test_tree2.root();
 
-    test::algorithms(Order(), test_tree.root(), test_tree2.root());
+    algorithms(Order(), test_tree.root(), test_tree2.root());
 }

Modified: sandbox/SOC/2006/tree/trunk/libs/tree/test/forest_tree_test.cpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/libs/tree/test/forest_tree_test.cpp	(original)
+++ sandbox/SOC/2006/tree/trunk/libs/tree/test/forest_tree_test.cpp	2008-10-01 15:38:16 EDT (Wed, 01 Oct 2008)
@@ -11,12 +11,12 @@
 
 #include <list>
 
-#include <boost/test/minimal.hpp>
+#define BOOST_TEST_MODULE binary_tree test
+//#define BOOST_TEST_DYN_LINK
+#include <boost/test/included/unit_test.hpp>
 
 #include "test_tree_traversal_data.hpp"
 
-#include "subtree_algorithms_checks.hpp"
-
 //TODO: Make this a test suite.
 
 void test_forest_tree()
@@ -103,10 +103,8 @@
     BOOST_CHECK(test_list.size() == 11);
 }
 
-int test_main(int, char* [])
+BOOST_AUTO_TEST_CASE( forest_tree_test )
 {
     test_forest_tree();
     test_natural_correspondence();
-
-    return 0;
 }

Modified: sandbox/SOC/2006/tree/trunk/libs/tree/test/graph_test.cpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/libs/tree/test/graph_test.cpp	(original)
+++ sandbox/SOC/2006/tree/trunk/libs/tree/test/graph_test.cpp	2008-10-01 15:38:16 EDT (Wed, 01 Oct 2008)
@@ -9,7 +9,9 @@
 #include <boost/graph/depth_first_search.hpp>
 #include <boost/graph/visitors.hpp>
 
-#include <boost/test/minimal.hpp>
+#define BOOST_TEST_MODULE binary_tree test
+//#define BOOST_TEST_DYN_LINK
+#include <boost/test/included/unit_test.hpp>
 
 #include <list>
 #include <iterator>
@@ -17,7 +19,7 @@
 #include "helpers.hpp"
 #include "test_tree_traversal_data.hpp"
 
-int test_main(int, char* [])
+BOOST_AUTO_TEST_CASE( graph_test )
 {
     using namespace boost;
     using boost::tree::binary_tree;
@@ -113,6 +115,4 @@
     
     // Output test_tree using write_graphviz. This might require copying
     // the IncidenceGraph to a VertexListGraph (using copy_component) 
-    
-    return 0;
 }

Modified: sandbox/SOC/2006/tree/trunk/libs/tree/test/interval_search_binary_tree_test.cpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/libs/tree/test/interval_search_binary_tree_test.cpp	(original)
+++ sandbox/SOC/2006/tree/trunk/libs/tree/test/interval_search_binary_tree_test.cpp	2008-10-01 15:38:16 EDT (Wed, 01 Oct 2008)
@@ -11,10 +11,9 @@
 //#include <boost/numeric/interval/compare/lexicographic.hpp>
 #include <boost/multi_index/identity.hpp>
 
-
-#include <boost/test/minimal.hpp>
-
-//TODO: Make this a test suite.
+#define BOOST_TEST_MODULE binary_tree test
+//#define BOOST_TEST_DYN_LINK
+#include <boost/test/included/unit_test.hpp>
 
 //TODO: add real tests. (what is where?)
 // test overlaps stuff.
@@ -35,7 +34,7 @@
     }
 };
 
-void test_interval_search_binary_tree()
+BOOST_AUTO_TEST_CASE( interval_search_binary_tree_test )
 {
     using boost::tree::searcher;
     using boost::tree::binary_tree;
@@ -61,10 +60,3 @@
 //    BOOST_CHECK(ci == my_tree.end());
     
 }
-
-
-int test_main(int, char* [])
-{
-    test_interval_search_binary_tree();
-    return 0;
-}

Modified: sandbox/SOC/2006/tree/trunk/libs/tree/test/iterator_algorithm_test.cpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/libs/tree/test/iterator_algorithm_test.cpp	(original)
+++ sandbox/SOC/2006/tree/trunk/libs/tree/test/iterator_algorithm_test.cpp	2008-10-01 15:38:16 EDT (Wed, 01 Oct 2008)
@@ -4,18 +4,9 @@
 //  (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 
-//TODO: Make this a test suite.
-//        Add iterator traversal tests - check if proper overloads (if present)
-//        are used.
-
-// TODO: get timings. that makes that no testcase anymore, right?
-//does boost have timers? what does the austern et al one look like?
-
 #include <boost/tree/binary_tree.hpp>
-
 #include <boost/tree/iterator.hpp>
 #include <boost/tree/algorithm.hpp>
-
 #include <boost/tree/ascending_cursor.hpp>
 #include <boost/tree/root_tracking_cursor.hpp>
 
@@ -32,10 +23,38 @@
 
 using namespace boost::tree;
 
-// Some macro magic, to save us from all too tedious redundant calls
-// to each of the three types of order algorithms and checks.
+template <class Order, class Cursor>
+void compare_cursor_to_iterator_traversal(Order, Cursor cur) {    
+    std::list<int> test_list;
+    typedef std::back_insert_iterator< std::list<int> > back_insert_iter_list_int;
+    typedef output_cursor_iterator_wrapper<back_insert_iter_list_int> oc_bi_lst_type;
+    back_insert_iter_list_int it_test_list = std::back_inserter(test_list);
+    oc_bi_lst_type oc_test_list = oc_bi_lst_type(it_test_list);
+    
+    boost::tree::copy(Order(), cur, oc_test_list);
+    
+    // Are the elements accessed in the correct order?
+    BOOST_CHECK(std::equal( boost::tree::begin(Order(), cur),
+                            boost::tree::end(Order(), cur),
+                            test_list.begin()
+                            ));
+
+    // Does end() mark the right element? 
+    BOOST_CHECK(std::distance(boost::tree::begin(Order(), cur),
+                              boost::tree::end(Order(), cur)) == 
+                std::distance(test_list.begin(), test_list.end()));
+
+    // Reverse order.
+    BOOST_CHECK(std::equal(    boost::tree::rbegin(Order(), cur),
+                            boost::tree::rend(Order(), cur),
+                            test_list.rbegin()
+                            ));
+
+    BOOST_CHECK(std::distance(boost::tree::rbegin(Order(), cur),
+                              boost::tree::rend(Order(), cur)) == 
+                std::distance(test_list.rbegin(), test_list.rend()));                    
 
-#include "subtree_algorithms_checks.hpp"
+}
 
 template <class Cursor, class Op>
 void underefed_for_each_recursive(Cursor s, Op& f)
@@ -65,12 +84,12 @@
 
 template <class Order>
 void comparisons_using_ac(binary_tree<int>::cursor c) {
-    test::compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(make_ascending_cursor(c)));
+    compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(make_ascending_cursor(c)));
 }
 
 template <class Order>
 void comparisons_using_rtc(binary_tree<int>::cursor c) {
-    test::compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(c));
+    compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(c));
 }
 
 typedef boost::mpl::list<preorder,inorder,postorder> orders;
@@ -85,54 +104,54 @@
  * "explicit stack"-based cursors also.
  */ 
 //void compare_cursor_to_iterator_traversal() {
-BOOST_AUTO_TEST_CASE_TEMPLATE( compare_cursor_to_iterator_traversal, Order, orders )
+BOOST_AUTO_TEST_CASE_TEMPLATE( compare_cursor_to_iterator_traversal_test, Order, orders )
 {
     binary_tree<int> test_tree2;
     //test::compare_cursor_to_iterator_traversal(Order(), test_tree2.root());
 
     binary_tree<int>::cursor c = test_tree2.insert(test_tree2.root(), 8);
-    test::compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(test_tree2.root()));
-    test::compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(make_ascending_cursor(test_tree2.root())));
+    compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(test_tree2.root()));
+    compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(make_ascending_cursor(test_tree2.root())));
 
     c = test_tree2.insert(c, 3);
-    test::compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(test_tree2.root()));
-    test::compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(make_ascending_cursor(test_tree2.root())));
+    compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(test_tree2.root()));
+    compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(make_ascending_cursor(test_tree2.root())));
         
     test_tree2.insert(c, 1);
-    test::compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(test_tree2.root()));
-    test::compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(make_ascending_cursor(test_tree2.root())));
+    compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(test_tree2.root()));
+    compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(make_ascending_cursor(test_tree2.root())));
     
     c = test_tree2.insert(++c, 6);
-    test::compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(test_tree2.root()));
-    test::compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(make_ascending_cursor(test_tree2.root())));
+    compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(test_tree2.root()));
+    compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(make_ascending_cursor(test_tree2.root())));
     
     test_tree2.insert(c, 4);
-    test::compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(test_tree2.root()));
-    test::compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(make_ascending_cursor(test_tree2.root())));
+    compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(test_tree2.root()));
+    compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(make_ascending_cursor(test_tree2.root())));
     
     test_tree2.insert(++c, 7);    
-    test::compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(test_tree2.root()));
-    test::compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(make_ascending_cursor(test_tree2.root())));
+    compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(test_tree2.root()));
+    compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(make_ascending_cursor(test_tree2.root())));
     
     c = test_tree2.insert(test_tree2.root().end(), 10);
-    test::compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(test_tree2.root()));
-    test::compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(make_ascending_cursor(test_tree2.root())));
+    compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(test_tree2.root()));
+    compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(make_ascending_cursor(test_tree2.root())));
     
     c = test_tree2.insert(test_tree2.root().end().end(), 14);    
-    test::compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(test_tree2.root()));
-    test::compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(make_ascending_cursor(test_tree2.root())));
+    compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(test_tree2.root()));
+    compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(make_ascending_cursor(test_tree2.root())));
     
     c = test_tree2.insert(c, 13);
-    test::compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(test_tree2.root()));
-    test::compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(make_ascending_cursor(test_tree2.root())));
+    compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(test_tree2.root()));
+    compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(make_ascending_cursor(test_tree2.root())));
     
     c = test_tree2.insert(c, 11);
-    test::compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(test_tree2.root()));
-    test::compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(make_ascending_cursor(test_tree2.root())));
+    compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(test_tree2.root()));
+    compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(make_ascending_cursor(test_tree2.root())));
     
     c = test_tree2.insert(++c, 12);
-    test::compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(test_tree2.root()));
-    test::compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(make_ascending_cursor(test_tree2.root())));
+    compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(test_tree2.root()));
+    compare_cursor_to_iterator_traversal(Order(), make_root_tracking_cursor(make_ascending_cursor(test_tree2.root())));
     
     underefed_for_each(test_tree2.root(), comparisons_using_ac<Order>);
     underefed_for_each(test_tree2.root(), comparisons_using_rtc<Order>);

Modified: sandbox/SOC/2006/tree/trunk/libs/tree/test/key_search_binary_tree_test.cpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/libs/tree/test/key_search_binary_tree_test.cpp	(original)
+++ sandbox/SOC/2006/tree/trunk/libs/tree/test/key_search_binary_tree_test.cpp	2008-10-01 15:38:16 EDT (Wed, 01 Oct 2008)
@@ -4,20 +4,21 @@
 //  (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 
-//#include <boost/test/unit_test.hpp>
-#include <boost/test/minimal.hpp>
-
 #include <boost/tree/binary_tree.hpp>
 #include <boost/tree/balancers/unbalanced.hpp>
 
 #include <boost/tree/searcher.hpp>
 #include <boost/tree/algorithm.hpp>
 
+#define BOOST_TEST_MODULE binary_tree test
+//#define BOOST_TEST_DYN_LINK
+#include <boost/test/included/unit_test.hpp>
+
 #include "helpers.hpp"
 
 //TODO: Make this a test suite.
 
-void test_key_search_binary_tree()
+BOOST_AUTO_TEST_CASE( key_search_binary_tree_test )
 {
     using namespace boost::tree;
     
@@ -181,10 +182,3 @@
 //
 //    return key_search_test;
 //}
-
-int test_main(int, char* [])
-{
-    test_key_search_binary_tree();
-
-    return 0;
-}

Modified: sandbox/SOC/2006/tree/trunk/libs/tree/test/multiway_tree_test.cpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/libs/tree/test/multiway_tree_test.cpp	(original)
+++ sandbox/SOC/2006/tree/trunk/libs/tree/test/multiway_tree_test.cpp	2008-10-01 15:38:16 EDT (Wed, 01 Oct 2008)
@@ -6,11 +6,13 @@
 
 #include <boost/tree/multiway_tree.hpp>
 
-#include <boost/test/minimal.hpp>
+#define BOOST_TEST_MODULE binary_tree test
+//#define BOOST_TEST_DYN_LINK
+#include <boost/test/included/unit_test.hpp>
 
 //TODO: Make this a test suite.
 
-void test_multiway_tree()
+BOOST_AUTO_TEST_CASE( multiway_tree_test )
 {
     using namespace boost::tree;
     
@@ -19,10 +21,4 @@
 
     //tree_type::cursor c = 
     //mytree.insert(mytree.root(), 3);
-}
-
-int test_main(int, char* [])
-{
-    test_multiway_tree();
-    return 0;
-}
+}
\ No newline at end of file

Modified: sandbox/SOC/2006/tree/trunk/libs/tree/test/nary_tree_test.cpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/libs/tree/test/nary_tree_test.cpp	(original)
+++ sandbox/SOC/2006/tree/trunk/libs/tree/test/nary_tree_test.cpp	2008-10-01 15:38:16 EDT (Wed, 01 Oct 2008)
@@ -6,11 +6,11 @@
 
 #include <boost/tree/nary_tree.hpp>
 
-#include <boost/test/minimal.hpp>
+#define BOOST_TEST_MODULE binary_tree test
+//#define BOOST_TEST_DYN_LINK
+#include <boost/test/included/unit_test.hpp>
 
-//TODO: Make this a test suite.
-
-void test_nary_tree()
+BOOST_AUTO_TEST_CASE( nary_tree_test )
 {
     using namespace boost::tree;
     
@@ -40,9 +40,3 @@
     BOOST_CHECK(c == c.begin().parent());
 
 }
-
-int test_main(int, char* [])
-{
-    test_nary_tree();
-    return 0;
-}

Modified: sandbox/SOC/2006/tree/trunk/libs/tree/test/range_helpers_test.cpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/libs/tree/test/range_helpers_test.cpp	(original)
+++ sandbox/SOC/2006/tree/trunk/libs/tree/test/range_helpers_test.cpp	2008-10-01 15:38:16 EDT (Wed, 01 Oct 2008)
@@ -6,12 +6,12 @@
 
 #include <boost/tree/detail/range_helpers.hpp>
 
-#include <boost/test/minimal.hpp>
+#define BOOST_TEST_MODULE binary_tree test
+//#define BOOST_TEST_DYN_LINK
+#include <boost/test/included/unit_test.hpp>
 
 #include <vector>
 
-//TODO: Make this a test suite.
-
 void test_binary_lower_bound()
 {
     using boost::tree::binary_lower_bound;
@@ -89,12 +89,11 @@
     BOOST_CHECK(ci == vec().end());
 }
 
-int test_main(int, char* [])
+BOOST_AUTO_TEST_CASE( range_helpers_test )
 {
     test_binary_lower_bound();
     test_binary_upper_bound();
     
     test_linear_lower_bound();
     test_linear_upper_bound();
-    return 0;
 }

Modified: sandbox/SOC/2006/tree/trunk/libs/tree/test/rank_search_binary_tree_test.cpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/libs/tree/test/rank_search_binary_tree_test.cpp	(original)
+++ sandbox/SOC/2006/tree/trunk/libs/tree/test/rank_search_binary_tree_test.cpp	2008-10-01 15:38:16 EDT (Wed, 01 Oct 2008)
@@ -4,9 +4,6 @@
 //  (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 
-//#include <boost/test/unit_test.hpp>
-#include <boost/test/minimal.hpp>
-
 #include <boost/tree/binary_tree.hpp>
 #include <boost/tree/balancers/unbalanced.hpp>
 #include <boost/tree/augmentors/rank.hpp>
@@ -19,7 +16,7 @@
 //TODO: Make this a test suite.
 
 
-void test_rank_search_binary_tree()
+BOOST_AUTO_TEST_CASE( rank_search_binary_tree_test )
 {
     using namespace boost::tree;
 //    
@@ -55,10 +52,3 @@
 //
 //    return rank_search_test;
 //}
-
-int test_main(int, char* [])
-{
-    test_rank_search_binary_tree();
-
-    return 0;
-}

Modified: sandbox/SOC/2006/tree/trunk/libs/tree/test/red_black_tree_test.cpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/libs/tree/test/red_black_tree_test.cpp	(original)
+++ sandbox/SOC/2006/tree/trunk/libs/tree/test/red_black_tree_test.cpp	2008-10-01 15:38:16 EDT (Wed, 01 Oct 2008)
@@ -8,20 +8,20 @@
 #include <boost/tree/balancers/red_black.hpp>
 #include <boost/tree/augmentors/unaugmented.hpp>
 
-//#include <boost/tree/searcher.hpp>
-
 #include <vector>
 #include <algorithm>
 
-#include "helpers.hpp"
+#define BOOST_TEST_MODULE binary_tree test
+//#define BOOST_TEST_DYN_LINK
+#include <boost/test/included/unit_test.hpp>
 
-#include <boost/test/minimal.hpp>
+#include "helpers.hpp"
 
 using boost::tree::binary_tree;
 
 //TODO: Make this a test suite.
 
-void test_red_black_tree()
+BOOST_AUTO_TEST_CASE( red_black_tree_test )
 {
     using namespace boost::tree;
     
@@ -147,9 +147,3 @@
         
 }
 
-
-int test_main(int, char* [])
-{
-    test_red_black_tree();
-    return 0;
-}

Modified: sandbox/SOC/2006/tree/trunk/libs/tree/test/rotate_binary_tree_test.cpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/libs/tree/test/rotate_binary_tree_test.cpp	(original)
+++ sandbox/SOC/2006/tree/trunk/libs/tree/test/rotate_binary_tree_test.cpp	2008-10-01 15:38:16 EDT (Wed, 01 Oct 2008)
@@ -11,13 +11,15 @@
 #include "helpers.hpp"
 #include "test_tree_traversal_data.hpp"
 
-#include <boost/test/minimal.hpp>
+#define BOOST_TEST_MODULE binary_tree test
+//#define BOOST_TEST_DYN_LINK
+#include <boost/test/included/unit_test.hpp>
 
 using boost::tree::binary_tree;
 
 //TODO: Make this a test suite.
 
-void test_rotate()
+BOOST_AUTO_TEST_CASE( rotate_binary_tree_test )
 {
     binary_tree<int> a;
     binary_tree<int> mytree(a);
@@ -79,10 +81,3 @@
 //    BOOST_CHECK(*c.parent().parent().end().begin() == 7);
     
 }
-
-
-int test_main(int, char* [])
-{
-    test_rotate();
-    return 0;
-}

Modified: sandbox/SOC/2006/tree/trunk/libs/tree/test/search_ordered_vector_test.cpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/libs/tree/test/search_ordered_vector_test.cpp	(original)
+++ sandbox/SOC/2006/tree/trunk/libs/tree/test/search_ordered_vector_test.cpp	2008-10-01 15:38:16 EDT (Wed, 01 Oct 2008)
@@ -4,16 +4,15 @@
 //  (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/test/minimal.hpp>
-
 #include <boost/tree/searcher.hpp>
 
 #include <vector>
 
-//TODO: Make this a test suite.
-
+#define BOOST_TEST_MODULE binary_tree test
+//#define BOOST_TEST_DYN_LINK
+#include <boost/test/included/unit_test.hpp>
 
-static void search_ordered_vector_test()
+BOOST_AUTO_TEST_CASE( search_ordered_vector_test )
 {
 //    using boost::tree::searcher;
 //    using std::vector;
@@ -47,11 +46,4 @@
 //    ordered_vector_test->add( BOOST_TEST_CASE( &search_ordered_vector_test ) );
 //
 //    return ordered_vector_test;
-//}
-
-
-int test_main(int, char* [])
-{
-    search_ordered_vector_test();
-    return 0;
-}
+//}
\ No newline at end of file

Modified: sandbox/SOC/2006/tree/trunk/libs/tree/test/string_search_binary_tree_test.cpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/libs/tree/test/string_search_binary_tree_test.cpp	(original)
+++ sandbox/SOC/2006/tree/trunk/libs/tree/test/string_search_binary_tree_test.cpp	2008-10-01 15:38:16 EDT (Wed, 01 Oct 2008)
@@ -16,9 +16,9 @@
 
 #include <string>
 
-#include <boost/test/minimal.hpp>
-
-//TODO: Make this a test suite.
+#define BOOST_TEST_MODULE binary_tree test
+//#define BOOST_TEST_DYN_LINK
+#include <boost/test/included/unit_test.hpp>
 
 //Words from Austern et al., p1290
 
@@ -77,7 +77,7 @@
 }
 
 
-int test_main(int, char* [])
+BOOST_AUTO_TEST_CASE( string_search_binary_tree_test )
 {
     test_normal_string_search_binary_tree();
     test_optimized_string_search_binary_tree();

Deleted: sandbox/SOC/2006/tree/trunk/libs/tree/test/subtree_algorithms_checks.hpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/libs/tree/test/subtree_algorithms_checks.hpp	2008-10-01 15:38:16 EDT (Wed, 01 Oct 2008)
+++ (empty file)
@@ -1,103 +0,0 @@
-//  Copyright (c) 2006-2008, Bernhard Reiter
-//
-//  Distributed under the Boost Software License, Version 1.0.
-//  (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/tree/algorithm.hpp>
-#include <boost/tree/binary_tree.hpp>
-
-#include <boost/lambda/bind.hpp>
-
-#include <list>
-#include <algorithm>
-#include <iterator>
-
-#include "helpers.hpp"
-#include "test_tree_traversal_data.hpp"
-
-using namespace boost::tree;
-
-namespace test {
-
-template <class Order, class Cursor, class Container>
-void test_for_each(Order, Cursor c, Container& cont)
-{
-    boost::tree::for_each(
-        Order(),
-        c, 
-        boost::lambda::bind(&Container::push_back, &cont, boost::lambda::_1)
-    );
-    test_traversal(Order(), cont.begin(), cont.end());
-}
-
-template <class Order, class Cursor, class OutCursor, class Container>
-void test_copy(Order, Cursor c, OutCursor& o, Container& cont)
-{    
-    boost::tree::copy(Order(), c, o);
-    test_traversal(Order(), cont.begin(), cont.end());
-}
-
-template <class Order, class Cursor, class OutCursor, class Container>
-void test_transform(Order, Cursor c, Cursor d, OutCursor& o, Container& cont)
-{
-    // First copy test_tree to test_tree2, by adding 1 to each element,
-    // then copy test_tree2 to test_list, by subtracting 1 - so 
-    // test_list should hold test_tree's original elements in ORDER.
-    boost::tree::transform(Order(), c, d, std::bind2nd(std::plus<int>(),1));
-    boost::tree::transform(Order(), d, o, std::bind2nd(std::minus<int>(),1));
-    test_traversal(Order(), cont.begin(), cont.end());
-}
-
-template <class Order, class Cursor>
-void algorithms(Order, Cursor c, Cursor d)
-{
-    std::list<int> test_list;
-    typedef std::back_insert_iterator< std::list<int> > back_insert_iter_list_int;
-    typedef output_cursor_iterator_wrapper<back_insert_iter_list_int> oc_bi_lst_type;
-    back_insert_iter_list_int it_test_list = std::back_inserter(test_list);
-    oc_bi_lst_type oc_test_list = oc_bi_lst_type(it_test_list);
-    
-    test_for_each(Order(), c, test_list);
-    
-    test_list.clear();
-    test_copy(Order(), c, oc_test_list, test_list);
-    
-    test_list.clear();
-    test_transform(Order(), c, d, oc_test_list, test_list);
-}
-
-template <class Order, class Cursor>
-void compare_cursor_to_iterator_traversal(Order, Cursor cur) {    
-    std::list<int> test_list;
-    typedef std::back_insert_iterator< std::list<int> > back_insert_iter_list_int;
-    typedef output_cursor_iterator_wrapper<back_insert_iter_list_int> oc_bi_lst_type;
-    back_insert_iter_list_int it_test_list = std::back_inserter(test_list);
-    oc_bi_lst_type oc_test_list = oc_bi_lst_type(it_test_list);
-    
-    boost::tree::copy(Order(), cur, oc_test_list);
-    
-    // Are the elements accessed in the correct order?
-    BOOST_CHECK(std::equal( boost::tree::begin(Order(), cur),
-                            boost::tree::end(Order(), cur),
-                            test_list.begin()
-                            ));
-
-    // Does end() mark the right element? 
-    BOOST_CHECK(std::distance(boost::tree::begin(Order(), cur),
-                              boost::tree::end(Order(), cur)) == 
-                std::distance(test_list.begin(), test_list.end()));
-
-    // Reverse order.
-    BOOST_CHECK(std::equal(    boost::tree::rbegin(Order(), cur),
-                            boost::tree::rend(Order(), cur),
-                            test_list.rbegin()
-                            ));
-
-    BOOST_CHECK(std::distance(boost::tree::rbegin(Order(), cur),
-                              boost::tree::rend(Order(), cur)) == 
-                std::distance(test_list.rbegin(), test_list.rend()));                    
-
-}
-
-} // namespace test

Modified: sandbox/SOC/2006/tree/trunk/libs/tree/test/treap_test.cpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/libs/tree/test/treap_test.cpp	(original)
+++ sandbox/SOC/2006/tree/trunk/libs/tree/test/treap_test.cpp	2008-10-01 15:38:16 EDT (Wed, 01 Oct 2008)
@@ -8,18 +8,18 @@
 #include <boost/tree/balancers/treap.hpp>
 #include <boost/tree/augmentors/unaugmented.hpp>
 
-//#include <boost/tree/searcher.hpp>
-
 #include <vector>
 #include <algorithm>
 
-#include <boost/test/minimal.hpp>
+#define BOOST_TEST_MODULE binary_tree test
+//#define BOOST_TEST_DYN_LINK
+#include <boost/test/included/unit_test.hpp>
 
 #include "helpers.hpp"
 
 //TODO: Make this a test suite.
 
-void test_treap()
+BOOST_AUTO_TEST_CASE( treap_test )
 {
     using namespace boost::tree;
     
@@ -55,11 +55,4 @@
     //c = c.parent();
     //treap_t::metadata_type m = c->metadata();
     //int i = ci.base().base().parent()->metadata().get_priority();//m.get_priority();
-}
-
-
-int test_main(int, char* [])
-{
-    test_treap();
-    return 0;
-}
+}
\ No newline at end of file

Modified: sandbox/SOC/2006/tree/trunk/libs/tree/test/unbalanced_binary_tree_test.cpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/libs/tree/test/unbalanced_binary_tree_test.cpp	(original)
+++ sandbox/SOC/2006/tree/trunk/libs/tree/test/unbalanced_binary_tree_test.cpp	2008-10-01 15:38:16 EDT (Wed, 01 Oct 2008)
@@ -4,21 +4,17 @@
 //  (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/test/minimal.hpp>
-
 #include <boost/tree/balanced_tree.hpp>
 #include <boost/tree/detail/balancers/unbalanced.hpp>
 #include <boost/tree/binary_tree.hpp>
 
-//#include <boost/tree/searcher.hpp>
-//#include <boost/tree/algorithm.hpp>
-
 #include "helpers.hpp"
 
-//TODO: Make this a test suite.
+#define BOOST_TEST_MODULE binary_tree test
+//#define BOOST_TEST_DYN_LINK
+#include <boost/test/included/unit_test.hpp>
 
-
-void test_unbalanced_binary_tree()
+BOOST_AUTO_TEST_CASE( unbalanced_binary_tree_test )
 {
     using namespace boost::tree;
     
@@ -81,10 +77,3 @@
 //
 //    return key_search_test;
 //}
-
-int test_main(int, char* [])
-{
-    test_unbalanced_binary_tree();
-
-    return 0;
-}