Subject: [Boost-commit] svn:boost r49489 - in sandbox/SOC/2006/tree/trunk: . boost/tree boost/tree/detail/algorithm libs/tree/test
From: ockham_at_[hidden]
Date: 2008-10-29 20:08:04
Author: bernhard.reiter
Date: 2008-10-29 20:08:01 EDT (Wed, 29 Oct 2008)
New Revision: 49489
URL: http://svn.boost.org/trac/boost/changeset/49489
Log:
Introduce insert_cursor.
Added:
sandbox/SOC/2006/tree/trunk/boost/tree/insert_cursor.hpp (contents, props changed)
Text files modified:
sandbox/SOC/2006/tree/trunk/TODO | 5 +
sandbox/SOC/2006/tree/trunk/boost/tree/binary_tree.hpp | 1
sandbox/SOC/2006/tree/trunk/boost/tree/cursor_adaptor.hpp | 3
sandbox/SOC/2006/tree/trunk/boost/tree/detail/algorithm/preorder.hpp | 2
sandbox/SOC/2006/tree/trunk/boost/tree/root_tracking_cursor.hpp | 6
sandbox/SOC/2006/tree/trunk/libs/tree/test/binary_tree_search_test.cpp | 18 +-
sandbox/SOC/2006/tree/trunk/libs/tree/test/binary_tree_test.cpp | 116 +++++++++++-----------
sandbox/SOC/2006/tree/trunk/libs/tree/test/cursor_algorithm_test.cpp | 14 ++
sandbox/SOC/2006/tree/trunk/libs/tree/test/forest_tree_test.cpp | 53 ++++++----
sandbox/SOC/2006/tree/trunk/libs/tree/test/graph_test.cpp | 20 ++--
sandbox/SOC/2006/tree/trunk/libs/tree/test/interval_search_binary_tree_test.cpp | 12 +-
sandbox/SOC/2006/tree/trunk/libs/tree/test/iterator_algorithm_test.cpp | 2
sandbox/SOC/2006/tree/trunk/libs/tree/test/key_search_binary_tree_test.cpp | 100 ++++++++++----------
sandbox/SOC/2006/tree/trunk/libs/tree/test/nary_tree_test.cpp | 14 +-
sandbox/SOC/2006/tree/trunk/libs/tree/test/red_black_tree_test.cpp | 64 ++++++------
sandbox/SOC/2006/tree/trunk/libs/tree/test/search_ordered_vector_test.cpp | 10 +-
sandbox/SOC/2006/tree/trunk/libs/tree/test/string_search_binary_tree_test.cpp | 24 ++--
sandbox/SOC/2006/tree/trunk/libs/tree/test/test_tree_traversal_data.hpp | 196 ++++++++++++++++++++--------------------
sandbox/SOC/2006/tree/trunk/libs/tree/test/unbalanced_binary_tree_test.cpp | 24 ++--
19 files changed, 357 insertions(+), 327 deletions(-)
Modified: sandbox/SOC/2006/tree/trunk/TODO
==============================================================================
--- sandbox/SOC/2006/tree/trunk/TODO (original)
+++ sandbox/SOC/2006/tree/trunk/TODO 2008-10-29 20:08:01 EDT (Wed, 29 Oct 2008)
@@ -14,6 +14,11 @@
[section TODO]
General:
+* Future: Optimise insert_cursor for use with binary_tree insert and copy ctor
+ (preorder copy; ideally, we can guarantee RAII for every single element)
+ and clear/dtor (postorder for_each).
+* Get insert_cursor to work with postorder copy, then with linear (ascending cursor)
+ versions. Check with other algorithms that use output cursors.
* Caution: Iterative algorithms require ascending cursors!
* Move some of the secondary stuff to a util/ dir? Is that what they're used for?
* Redo testing. Right now, it's just chaotic.
Modified: sandbox/SOC/2006/tree/trunk/boost/tree/binary_tree.hpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/boost/tree/binary_tree.hpp (original)
+++ sandbox/SOC/2006/tree/trunk/boost/tree/binary_tree.hpp 2008-10-29 20:08:01 EDT (Wed, 29 Oct 2008)
@@ -242,6 +242,7 @@
template <class InputCursor>
cursor insert(cursor pos, InputCursor subtree)
{
+ //boost::tree::copy(boost::tree::preorder(), subtree, pos, forward_traversal_tag());
subtree.to_begin();
insert(pos, *subtree);
if (!subtree.empty())
Modified: sandbox/SOC/2006/tree/trunk/boost/tree/cursor_adaptor.hpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/boost/tree/cursor_adaptor.hpp (original)
+++ sandbox/SOC/2006/tree/trunk/boost/tree/cursor_adaptor.hpp 2008-10-29 20:08:01 EDT (Wed, 29 Oct 2008)
@@ -158,7 +158,8 @@
{
return *m_cursor;
}
-
+
+private:
void increment()
{
++m_cursor;
Modified: sandbox/SOC/2006/tree/trunk/boost/tree/detail/algorithm/preorder.hpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/boost/tree/detail/algorithm/preorder.hpp (original)
+++ sandbox/SOC/2006/tree/trunk/boost/tree/detail/algorithm/preorder.hpp 2008-10-29 20:08:01 EDT (Wed, 29 Oct 2008)
@@ -183,7 +183,7 @@
s.to_begin();
t.to_begin();
- for (; s != r; ++s, ++t) {
+ for (;s != r; ++s, ++t) {
*t = *s;
if (!s.empty())
copy(preorder(), s, t, forward_traversal_tag());
Added: sandbox/SOC/2006/tree/trunk/boost/tree/insert_cursor.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2006/tree/trunk/boost/tree/insert_cursor.hpp 2008-10-29 20:08:01 EDT (Wed, 29 Oct 2008)
@@ -0,0 +1,100 @@
+// 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)
+
+/**
+ * @file insert_cursor.hpp
+ * Insert cursor implementation
+ */
+
+#ifndef BOOST_TREE_INSERT_CURSOR_HPP
+#define BOOST_TREE_INSERT_CURSOR_HPP
+
+#include <boost/tree/cursor_adaptor.hpp>
+
+namespace boost {
+namespace tree {
+
+using boost::iterator_core_access;
+
+template <class Tree>
+class insert_cursor;
+
+/**
+ * @brief Output cursor wrapper around an output iterator.
+ *
+ * This can be very useful e.g. to have cursor algorithms actually work on
+ * iterators, thus permitting some kind of linearization of a given subtree.
+ * (Modelled after std::insert_iterator and the like.)
+ *
+ * For construction, the outputter_cursor_iterator_wrapper might come in useful
+ * in saving keystrokes.
+ */
+// TODO: Complete this.
+// Shouldn't we be using cursor_facade?
+template <class Tree>
+class insert_cursor
+: public cursor_adaptor<insert_cursor<Tree>
+ , typename Tree::cursor
+// , boost::use_default
+// , boost::use_default
+// , boost::use_default
+ >
+ {
+protected:
+ mutable Tree& tree;
+ mutable bool ins;
+public:
+ /**
+ * For construction, we obviously need a tree and a cursor to work on (i.e., write to).
+ */
+ explicit insert_cursor(Tree& x, typename Tree::cursor cur)
+ : insert_cursor::cursor_adaptor_(cur), tree(x), ins(false) {}
+
+private:
+ friend class boost::iterator_core_access;
+ friend class boost::tree::cursor_core_access;
+
+ typename insert_cursor::cursor_adaptor_::reference dereference() const
+ {
+ if (ins) {
+ const_cast<typename Tree::cursor&>(this->base_reference()) =
+ tree.insert(this->base_reference(), typename Tree::value_type());
+ }
+ return *this->base_reference();
+ }
+
+ void increment()
+ {
+ ins = true;
+ ++this->base_reference();
+ }
+
+ void left()
+ {
+ this->base_reference() =
+ tree.insert(this->base_reference(), typename Tree::value_type());
+ ins = false;
+ }
+
+};
+
+/**
+ * @param o An output iterator.
+ * @result An instance of insert_cursor working on o.
+ *
+ * Use as shortcut for cumbersome typenames, just as with std::inserter and the like.
+ */
+template<class Tree>
+inline insert_cursor<Tree>
+tree_inserter(Tree& t, typename Tree::cursor c)
+{
+ return insert_cursor<Tree>(t, c);
+}
+
+} // namespace tree
+} // namespace boost
+
+#endif // BOOST_TREE_INSERT_CURSOR_HPP
Modified: sandbox/SOC/2006/tree/trunk/boost/tree/root_tracking_cursor.hpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/boost/tree/root_tracking_cursor.hpp (original)
+++ sandbox/SOC/2006/tree/trunk/boost/tree/root_tracking_cursor.hpp 2008-10-29 20:08:01 EDT (Wed, 29 Oct 2008)
@@ -28,9 +28,9 @@
class root_tracking_cursor
: public cursor_adaptor<root_tracking_cursor<Cursor>
, Cursor
- , boost::use_default
- , typename cursor_horizontal_traversal<Cursor>::type
- , typename cursor_vertical_traversal<Cursor>::type
+// , boost::use_default
+// , typename cursor_horizontal_traversal<Cursor>::type
+// , typename cursor_vertical_traversal<Cursor>::type
> {
private:
struct enabler {};
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-29 20:08:01 EDT (Wed, 29 Oct 2008)
@@ -31,8 +31,8 @@
c = lower_bound(r, v);
d = upper_bound(r, v);
- BOOST_CHECK(*c == v);
- //BOOST_CHECK(inorder::next(c) == d);
+ BOOST_CHECK_EQUAL(*c, v);
+ //BOOST_CHECK_EQUAL(inorder::next(c) , d);
}
BOOST_AUTO_TEST_CASE( binary_tree_search_test )
@@ -46,20 +46,20 @@
c = lower_bound(bt.root(), 5); // Not in tree
d = lower_bound(bt.root(), 5);
- BOOST_CHECK(*c == 6);
- BOOST_CHECK(*d == 6);
+ BOOST_CHECK_EQUAL(*c, 6);
+ BOOST_CHECK_EQUAL(*d, 6);
*c = 4;
c = lower_bound(bt.root(), 5); // Not in tree
- BOOST_CHECK(*c == 7);
+ BOOST_CHECK_EQUAL(*c, 7);
c = lower_bound(bt.root(), 4); // Twice in tree
d = upper_bound(bt.root(), 4);
- BOOST_CHECK(*c == 4);
- BOOST_CHECK(*d == 7);
- BOOST_CHECK(*c.parent() == 4);
- //BOOST_CHECK(inorder::next(c, 2) == d);
+ BOOST_CHECK_EQUAL(*c, 4);
+ BOOST_CHECK_EQUAL(*d, 7);
+ BOOST_CHECK_EQUAL(*c.parent(), 4);
+ //BOOST_CHECK_EQUAL(inorder::next(c, 2), d);
*c.to_parent() = 6;
validate_test_data_tree(bt);
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-29 20:08:01 EDT (Wed, 29 Oct 2008)
@@ -29,7 +29,7 @@
BOOST_CHECK(c.empty());
c1 = mytree.insert(c, 1);
- BOOST_CHECK(*c1 == 1);
+ BOOST_CHECK_EQUAL(*c1, 1);
BOOST_CHECK(!c.empty());
@@ -41,18 +41,18 @@
c2 = mytree.insert(c1, 2);
BOOST_CHECK(!c.empty());
BOOST_CHECK(c2.empty());
- BOOST_CHECK(*c1 == 1);
- BOOST_CHECK(*c2 == 2);
+ BOOST_CHECK_EQUAL(*c1, 1);
+ BOOST_CHECK_EQUAL(*c2, 2);
*c1 = 14;
- BOOST_CHECK(*c1 == 14);
- BOOST_CHECK(*c2 == 2);
+ BOOST_CHECK_EQUAL(*c1, 14);
+ BOOST_CHECK_EQUAL(*c2, 2);
BOOST_CHECK(c2.parent() == c1);
BOOST_CHECK(c1.parent() == c);
c3 = c1.end();
BOOST_CHECK(c3 == c1.end());
--c3;
- BOOST_CHECK(c3.parity() == 0);
+ BOOST_CHECK_EQUAL(c3.parity(), 0);
BOOST_CHECK(c3.parent() != c3);
BOOST_CHECK(c3.parent() == c1);
BOOST_CHECK(c3 == c1.begin());
@@ -60,24 +60,24 @@
*c3 = 3;
*(c1.begin()) = 2;
- BOOST_CHECK(*c3 == 2);
+ BOOST_CHECK_EQUAL(*c3, 2);
++c3;
c4 = mytree.insert(c3, 4);
- BOOST_CHECK(*c4 == 4);
+ BOOST_CHECK_EQUAL(*c4, 4);
c4 = c4.parent();
--c4;
- BOOST_CHECK(*c4 == 2);
+ BOOST_CHECK_EQUAL(*c4, 2);
BOOST_CHECK(c4.parent() == c1);
c = boost::tree::lower_bound(mytree.root(), 2, std::less<int>());
- BOOST_CHECK(*c == 2);
+ BOOST_CHECK_EQUAL(*c, 2);
BOOST_CHECK(c4.empty());
- BOOST_CHECK(*c1 == 14);
+ BOOST_CHECK_EQUAL(*c1, 14);
BOOST_CHECK(c1.begin().empty() || c1.end().empty());
//c1 = mytree.erase(c1);
- //BOOST_CHECK(*c1 == 2);
+ //BOOST_CHECK_EQUAL(*c1, 2);
}
@@ -85,28 +85,28 @@
void inorder_erase_test_data_tree(Tree& mytree)
{
typename Tree::cursor c = mytree.root().end().end().begin();
- BOOST_CHECK(*c == 14);
+ BOOST_CHECK_EQUAL(*c, 14);
c = c.parent().parent();
- BOOST_CHECK(*(c.begin()) == 10);
+ BOOST_CHECK_EQUAL(*(c.begin()), 10);
BOOST_CHECK(c.begin().empty());
BOOST_CHECK(!c.end().empty());
- BOOST_CHECK(*c.end().begin() == 14);
+ BOOST_CHECK_EQUAL(*c.end().begin(), 14);
c = c.begin();
// Left child empty
c = mytree.inorder_erase(c);
- BOOST_CHECK(*c == 11);
+ BOOST_CHECK_EQUAL(*c, 11);
++c;
- BOOST_CHECK(*c.begin() == 12);
+ BOOST_CHECK_EQUAL(*c.begin(), 12);
BOOST_CHECK(c.begin().empty());
BOOST_CHECK(c.end().empty());
c = c.begin();
// Both children empty
c = mytree.inorder_erase(c);
- BOOST_CHECK(*c == 13);
+ BOOST_CHECK_EQUAL(*c, 13);
}
template <class Tree>
@@ -126,15 +126,15 @@
c1 = c.begin();
BOOST_CHECK(c1.parent() == c);
- BOOST_CHECK(*c1 == 14);
+ BOOST_CHECK_EQUAL(*c1, 14);
c2 = c1.begin();
BOOST_CHECK(c2.parent() == c1);
- BOOST_CHECK(*c2 == 2);
+ BOOST_CHECK_EQUAL(*c2, 2);
c3 = c1.end();
BOOST_CHECK(c3.parent() == c1);
- BOOST_CHECK(*c3.begin() == 4);
+ BOOST_CHECK_EQUAL(*c3.begin(), 4);
}
@@ -188,7 +188,7 @@
// Insert subtree
tree_t::cursor c = bt.insert(bt.root(), tree1.root());
- BOOST_CHECK(*c == 8);
+ BOOST_CHECK_EQUAL(*c, 8);
validate_test_data_tree(bt);
// Copy constructor
@@ -208,10 +208,10 @@
BOOST_CHECK(bt == tree3);
c = tree3.inorder_first();
- BOOST_CHECK(*c == 1);
+ BOOST_CHECK_EQUAL(*c, 1);
c = tree3.root();
//inorder::back(c);
- //BOOST_CHECK(*c == 14);
+ //BOOST_CHECK_EQUAL(*c, 14);
destroy_binary_tree(bt);
bt.splice(bt.root(), tree3);
@@ -219,67 +219,67 @@
BOOST_CHECK(tree3.empty());
validate_test_data_tree(bt);
c = bt.inorder_first();
- BOOST_CHECK(*c == 1);
+ BOOST_CHECK_EQUAL(*c, 1);
- inorder_erase_test_data_tree(bt);
+ //inorder_erase_test_data_tree(bt);
}
BOOST_AUTO_TEST_CASE( rotate_binary_tree_test )
{
binary_tree<int>::cursor c = bt.root().begin().end();
- BOOST_CHECK(*c.begin() == 6);
+ BOOST_CHECK_EQUAL(*c.begin(), 6);
- BOOST_CHECK(*c.parent() == 8);
- BOOST_CHECK(*c.parent().begin() == 3); // invariant candidate
+ BOOST_CHECK_EQUAL(*c.parent(), 8);
+ BOOST_CHECK_EQUAL(*c.parent().begin(), 3); // invariant candidate
- BOOST_CHECK(*--c == 3); // differently (not invariantly!) spoken
- BOOST_CHECK(*c.begin() == 1);
- BOOST_CHECK(*((++c).begin()).begin() == 4);
- BOOST_CHECK(*(++c.begin()).begin() == 7);
+ BOOST_CHECK_EQUAL(*--c, 3); // differently (not invariantly!) spoken
+ BOOST_CHECK_EQUAL(*c.begin(), 1);
+ BOOST_CHECK_EQUAL(*((++c).begin()).begin(), 4);
+ BOOST_CHECK_EQUAL(*(++c.begin()).begin(), 7);
- BOOST_CHECK(c.parity() == 1);
- BOOST_CHECK(*c.begin() == 6);
+ BOOST_CHECK_EQUAL(c.parity(), 1);
+ BOOST_CHECK_EQUAL(*c.begin(), 6);
bt.rotate(c); // Left rotate
- BOOST_CHECK(*c.begin() == 6);
- BOOST_CHECK(*c.parent().begin() == 8);
+ BOOST_CHECK_EQUAL(*c.begin(), 6);
+ BOOST_CHECK_EQUAL(*c.parent().begin(), 8);
- BOOST_CHECK(*c.end().begin() == 7);
- BOOST_CHECK(*c.begin().begin() == 3);
- BOOST_CHECK(*c.begin().begin().begin() == 1);
+ BOOST_CHECK_EQUAL(*c.end().begin(), 7);
+ BOOST_CHECK_EQUAL(*c.begin().begin(), 3);
+ BOOST_CHECK_EQUAL(*c.begin().begin().begin(), 1);
- BOOST_CHECK(*c.begin().end().begin() == 4);
+ BOOST_CHECK_EQUAL(*c.begin().end().begin(), 4);
c = c.begin();
- BOOST_CHECK(*c.begin() == 3);
+ BOOST_CHECK_EQUAL(*c.begin(), 3);
bt.rotate(c); // Right rotate
- BOOST_CHECK(*c.begin() == 3);
+ BOOST_CHECK_EQUAL(*c.begin(), 3);
c = c.end();
- BOOST_CHECK(*c.begin() == 6);
+ BOOST_CHECK_EQUAL(*c.begin(), 6);
- BOOST_CHECK(*c.parent() == 8);
- BOOST_CHECK(*c.parent().begin() == 3); // other invariant candidate
+ BOOST_CHECK_EQUAL(*c.parent(), 8);
+ BOOST_CHECK_EQUAL(*c.parent().begin(), 3); // other invariant candidate
- BOOST_CHECK(*--c == 3);
- BOOST_CHECK(*c.begin() == 1);
- BOOST_CHECK(*((++c).begin()).begin() == 4);
- BOOST_CHECK(*(++c.begin()).begin() == 7);
+ BOOST_CHECK_EQUAL(*--c, 3);
+ BOOST_CHECK_EQUAL(*c.begin(), 1);
+ BOOST_CHECK_EQUAL(*((++c).begin()).begin(), 4);
+ BOOST_CHECK_EQUAL(*(++c.begin()).begin(), 7);
- BOOST_CHECK(*c.begin() == 6);
+ BOOST_CHECK_EQUAL(*c.begin(), 6);
-// BOOST_CHECK(*c.parent().parent().begin() == 6);
-// BOOST_CHECK(*c.parent().parent().end().begin() == 7);
+// BOOST_CHECK_EQUAL(*c.parent().parent().begin(), 6);
+// BOOST_CHECK_EQUAL(*c.parent().parent().end().begin(), 7);
-// BOOST_CHECK(*c.begin() == 1);
-// BOOST_CHECK(*c.parent().begin() == 3); // invariant?
+// BOOST_CHECK_EQUAL(*c.begin(), 1);
+// BOOST_CHECK_EQUAL(*c.parent().begin(), 3); // invariant?
//
-// BOOST_CHECK(*c.parent().parent().begin() == 6);
-// BOOST_CHECK(*c.parent().parent().parent().begin() == 8);
-// BOOST_CHECK(*c.parent().parent().end().begin() == 7);
+// BOOST_CHECK_EQUAL(*c.parent().parent().begin(), 6);
+// BOOST_CHECK_EQUAL(*c.parent().parent().parent().begin(), 8);
+// BOOST_CHECK_EQUAL(*c.parent().parent().end().begin(), 7);
}
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-29 20:08:01 EDT (Wed, 29 Oct 2008)
@@ -8,6 +8,8 @@
#include <boost/tree/iterator.hpp>
#include <boost/tree/algorithm.hpp>
+#include <boost/tree/insert_cursor.hpp>
+
#include <boost/lambda/bind.hpp>
#include <list>
@@ -44,6 +46,18 @@
test_traversal(Order(), l.begin(), l.end());
}
+typedef boost::mpl::list<preorder,inorder/*,postorder*/> preandinorders; //FIXME
+
+BOOST_AUTO_TEST_CASE_TEMPLATE ( test_copy2, Order, preandinorders )
+{
+ //boost::unit_test::unit_test_log.set_threshold_level(boost::unit_test::log_messages ) ;
+ bt2.clear();
+ l.clear();
+ boost::tree::copy(Order(), bt.root(), tree_inserter(bt2, bt2.root()), boost::forward_traversal_tag());
+ boost::tree::copy(Order(), bt2.root(), o);
+ validate_test_data_tree(bt2);
+}
+
BOOST_AUTO_TEST_CASE_TEMPLATE( test_transform, Order, orders)
{
// First copy test_tree to test_tree2, by adding 1 to each element,
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-29 20:08:01 EDT (Wed, 29 Oct 2008)
@@ -9,14 +9,23 @@
#include <boost/lambda/bind.hpp>
+#include <boost/mpl/list.hpp>
+#include <boost/mpl/pair.hpp>
+
#include <list>
#define BOOST_TEST_MODULE forest_tree test
//#define BOOST_TEST_DYN_LINK
#include <boost/test/included/unit_test.hpp>
+#include <boost/test/test_case_template.hpp>
#include "test_tree_traversal_data.hpp"
+using namespace boost::tree;
+
+typedef boost::mpl::list< boost::mpl::pair<preorder, preorder>
+ /*, boost::mpl::pair<postorder, inorder>*/ > order_pairs;
+
BOOST_FIXTURE_TEST_SUITE(forest_algorithms_test, test_binary_tree_with_list_fixture<int>)
BOOST_AUTO_TEST_CASE( forest_tree_test )
@@ -28,33 +37,33 @@
tree_type::cursor c = mytree.root();
c = mytree.insert(c, 6);
- BOOST_CHECK(*c == 6);
+ BOOST_CHECK_EQUAL(*c, 6);
c = mytree.insert(c, 5);
- BOOST_CHECK(*c == 5);
+ BOOST_CHECK_EQUAL(*c, 5);
c = mytree.insert(c, 4);
- BOOST_CHECK(*c == 4);
+ BOOST_CHECK_EQUAL(*c, 4);
BOOST_CHECK(c == mytree.root().begin());
++c;
- BOOST_CHECK(*c == 5);
+ BOOST_CHECK_EQUAL(*c, 5);
++c;
- BOOST_CHECK(*c == 6);
+ BOOST_CHECK_EQUAL(*c, 6);
tree_type forest;
//create_test_data_tree(forest);
c = forest.insert(forest.root(), 8);
BOOST_CHECK(c == forest.root().begin());
- BOOST_CHECK(*c == 8);
+ BOOST_CHECK_EQUAL(*c, 8);
c = forest.insert(c, 3);
- BOOST_CHECK(*c == 3);
- BOOST_CHECK(*++c == 8);
-// BOOST_CHECK(*forest.root().begin().begin() == 3);
+ BOOST_CHECK_EQUAL(*c, 3);
+ BOOST_CHECK_EQUAL(*++c, 8);
+// BOOST_CHECK_EQUAL(*forest.root().begin().begin(), 3);
}
-BOOST_AUTO_TEST_CASE( test_natural_correspondence )
+BOOST_AUTO_TEST_CASE_TEMPLATE( test_natural_correspondence, Order, order_pairs )
{
using namespace boost::tree;
@@ -74,29 +83,29 @@
oc_bi_lst_type oc_test_list = oc_bi_lst_type(it_test_list);
boost::tree::for_each(
- preorder(),
+ typename Order::first(),
ft.root(),
boost::lambda::bind(&std::list<int>::push_back, &test_list, boost::lambda::_1)
);
- test_traversal(preorder(), test_list.begin(), test_list.end());
- BOOST_CHECK(test_list.size() == 11);
+ test_traversal(typename Order::second(), test_list.begin(), test_list.end());
+ BOOST_CHECK_EQUAL(test_list.size(), 11);
test_list.clear();
- boost::tree::copy(preorder(), ft.root(), oc_test_list);
- test_traversal(preorder(), test_list.begin(), test_list.end());
- BOOST_CHECK(test_list.size() == 11);
+ boost::tree::copy(typename Order::first(), ft.root(), oc_test_list);
+ test_traversal(typename Order::second(), test_list.begin(), test_list.end());
+ BOOST_CHECK_EQUAL(test_list.size(), 11);
test_list.clear();
- boost::tree::transform(preorder(), ft.root(), oc_test_list, std::bind2nd(std::plus<int>(),0));
- test_traversal(preorder(), test_list.begin(), test_list.end());
- BOOST_CHECK(test_list.size() == 11);
+ boost::tree::transform(typename Order::first(), ft.root(), oc_test_list, std::bind2nd(std::plus<int>(),0));
+ test_traversal(typename Order::second(), test_list.begin(), test_list.end());
+ BOOST_CHECK_EQUAL(test_list.size(), 11);
test_list.clear();
//test::preorder::algorithms(ft.root(), ft.root()); // FIXME: Fix algorithms for use in here.
- boost::tree::copy(postorder(), ft.root(), oc_test_list);
- test_traversal(inorder(), test_list.begin(), test_list.end());
- BOOST_CHECK(test_list.size() == 11);
+// boost::tree::copy(typename Order::first(), ft.root(), oc_test_list);
+// test_traversal(typename Order::second(), test_list.begin(), test_list.end());
+// BOOST_CHECK_EQUAL(test_list.size(), 11);
}
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-29 20:08:01 EDT (Wed, 29 Oct 2008)
@@ -59,13 +59,13 @@
boost::tree::cursor_value<cursor>::type::extract_meta
> cpm;
- BOOST_CHECK(get(dpm, bt.root()) == 8); // Check the entire tree?
- BOOST_CHECK(get(cpm, bt.root()) == Color::white());
+ BOOST_CHECK_EQUAL(get(dpm, bt.root()), 8); // Check the entire tree?
+ BOOST_CHECK_EQUAL(get(cpm, bt.root()), Color::white());
put(cpm, bt.root(), Color::gray());
- BOOST_CHECK(get(cpm, bt.root()) == Color::gray());
+ BOOST_CHECK_EQUAL(get(cpm, bt.root()), Color::gray());
put(cpm, bt.root(), Color::white());
- BOOST_CHECK(get(cpm, bt.root()) == Color::white());
+ BOOST_CHECK_EQUAL(get(cpm, bt.root()), Color::white());
boost::dfs_visitor<
boost::property_writer<
@@ -90,10 +90,10 @@
w = bt.root().begin().end().begin();
default_color_type color = get(cpm, w);
- BOOST_CHECK(color == Color::white());
+ BOOST_CHECK_EQUAL(color, Color::white());
put(cpm, w, Color::white());
- BOOST_CHECK(get(cpm, w) == Color::white());
+ BOOST_CHECK_EQUAL(get(cpm, w), Color::white());
BOOST_CHECK(!empty_cursor(v, bt));
@@ -105,14 +105,14 @@
BOOST_CHECK(target(*oei, bt) == bt.root().begin());
BOOST_CHECK(target(*oei_end, bt) == bt.root());
- BOOST_CHECK(out_degree(v, bt) == 2);
+ BOOST_CHECK_EQUAL(out_degree(v, bt), 2);
//
-// BOOST_CHECK(test_list.size() == 2);
+// BOOST_CHECK_EQUAL(test_list.size(), 2);
//
// std::list<int>::const_iterator ci = test_list.begin();
//
-// BOOST_CHECK(*ci == 8);
-// BOOST_CHECK(*++ci == 10); //FIXME
+// BOOST_CHECK_EQUAL(*ci, 8);
+// BOOST_CHECK_EQUAL(*++ci, 10); //FIXME
// test::preorder::traversal(test_list.begin(), test_list.end());
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-29 20:08:01 EDT (Wed, 29 Oct 2008)
@@ -52,11 +52,11 @@
my_tree.insert(interval<int>(29,99));
searcher_t::iterator ci = my_tree.begin();
- BOOST_CHECK(*ci++ == interval<int>( 0, 1));
-// BOOST_CHECK(*ci++ == interval<int>( 3,41));
- BOOST_CHECK(*ci++ == interval<int>(10,15));
-// BOOST_CHECK(*ci++ == interval<int>(20,36));
-// BOOST_CHECK(*ci++ == interval<int>(29,99));
-// BOOST_CHECK(ci == my_tree.end());
+ BOOST_CHECK_EQUAL(*ci++, interval<int>( 0, 1));
+// BOOST_CHECK_EQUAL(*ci++, interval<int>( 3,41));
+ BOOST_CHECK_EQUAL(*ci++, interval<int>(10,15));
+// BOOST_CHECK_EQUAL(*ci++, interval<int>(20,36));
+// BOOST_CHECK_EQUAL(*ci++, interval<int>(29,99));
+// BOOST_CHECK_EQUAL(ci, my_tree.end());
}
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-29 20:08:01 EDT (Wed, 29 Oct 2008)
@@ -196,7 +196,7 @@
// binary_tree<int>::cursor c = test_tree.root();
// boost::tree::iterator<ascending, binary_tree<int>::cursor> ai_root(c);
// c = c.begin().end().begin().begin();
-// BOOST_CHECK(*c == 4);
+// BOOST_CHECK_EQUAL(*c, 4);
//
// boost::tree::iterator<ascending, binary_tree<int>::cursor> ais(c);
// test_traversal_from_leaf4(ais, ai_root);
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-29 20:08:01 EDT (Wed, 29 Oct 2008)
@@ -29,17 +29,17 @@
//std::pair<searcher_t::iterator, std::pair<bool, bool> > ret;
c = my_tree.end();
- BOOST_CHECK(c == my_tree.end());
- BOOST_CHECK(c == my_tree.begin());
+ BOOST_CHECK_EQUAL(c, my_tree.end());
+ BOOST_CHECK_EQUAL(c, my_tree.begin());
// searcher_t::cursor cur = searcher_t::cursor(c);
// BOOST_CHECK(cur.empty());
-// BOOST_CHECK(cur == searcher_t::cursor(my_tree.end()));
+// BOOST_CHECK_EQUAL(cur, searcher_t::cursor(my_tree.end()));
c1 = my_tree.insert(c, 8);
- BOOST_CHECK(*c1 == 8);
-// BOOST_CHECK(searcher_t::cursor(c1).parity() == 0);
+ BOOST_CHECK_EQUAL(*c1, 8);
+// BOOST_CHECK_EQUAL(searcher_t::cursor(c1).parity(), 0);
BOOST_CHECK(c != my_tree.end());
BOOST_CHECK(c1 != my_tree.end());
@@ -49,43 +49,43 @@
//
// cur = cur.parent(); //header-cursor(,1) (root)
// BOOST_CHECK(!cur.parity());
-// BOOST_CHECK(searcher_t::iterator(cur) == my_tree.end());
+// BOOST_CHECK_EQUAL(searcher_t::iterator(cur), my_tree.end());
BOOST_CHECK(*c1 = 8);
- BOOST_CHECK(++c1 == my_tree.end());
+ BOOST_CHECK_EQUAL(++c1, my_tree.end());
--c1;
- BOOST_CHECK(*c1 == 8);
+ BOOST_CHECK_EQUAL(*c1, 8);
-// BOOST_CHECK(searcher_t::cursor(my_tree.end()).parity() == 1);
+// BOOST_CHECK_EQUAL(searcher_t::cursor(my_tree.end()).parity(), 1);
//
-// BOOST_CHECK(cur.end().parity() == 1);
+// BOOST_CHECK_EQUAL(cur.end().parity(), 1);
//
// cur = searcher_t::cursor(c1);
//
-// BOOST_CHECK(*cur == 8);
+// BOOST_CHECK_EQUAL(*cur, 8);
//
// BOOST_CHECK((++cur).empty());
// BOOST_CHECK(!(--cur).parent().parity()); // root's parity...
//
-// BOOST_CHECK(*(searcher_t::cursor(c).begin()) == 8);
+// BOOST_CHECK_EQUAL(*(searcher_t::cursor(c).begin()), 8);
- BOOST_CHECK(*c1 == 8);
- BOOST_CHECK(++c1 == my_tree.end());
+ BOOST_CHECK_EQUAL(*c1, 8);
+ BOOST_CHECK_EQUAL(++c1, my_tree.end());
// root (e.g. c) instead of c1 would crash this. but should that be really
// illegal?
c2 = my_tree.insert(c1, 18);
- BOOST_CHECK(*c2 == 18);
+ BOOST_CHECK_EQUAL(*c2, 18);
++c2;
- BOOST_CHECK(c2 == my_tree.end());
+ BOOST_CHECK_EQUAL(c2, my_tree.end());
c = my_tree.end();
--c;
- BOOST_CHECK(*c == 18);
+ BOOST_CHECK_EQUAL(*c, 18);
c2 = my_tree.insert(c, 31);
@@ -94,19 +94,19 @@
c4 = my_tree.insert(c, 7);
- BOOST_CHECK(*c4 == 7);
+ BOOST_CHECK_EQUAL(*c4, 7);
- BOOST_CHECK(++c2 == my_tree.end());
+ BOOST_CHECK_EQUAL(++c2, my_tree.end());
c = my_tree.end();
--c;
BOOST_CHECK(*c != 39);
- BOOST_CHECK(*c == 412);
+ BOOST_CHECK_EQUAL(*c, 412);
--c;
- BOOST_CHECK(*c == 39);
+ BOOST_CHECK_EQUAL(*c, 39);
c = my_tree.begin();
-// BOOST_CHECK(searcher_t::cursor(c).parity() == 0);
+// BOOST_CHECK_EQUAL(searcher_t::cursor(c).parity(), 0);
// BOOST_CHECK(*(searcher_t::cursor(c).parent()) != 412);
BOOST_CHECK(*c < 413);
@@ -117,57 +117,57 @@
// BOOST_CHECK(tree_cur.empty());
// BOOST_CHECK((++tree_cur).empty());
// --tree_cur;
-// BOOST_CHECK(*tree_cur == 39);
+// BOOST_CHECK_EQUAL(*tree_cur, 39);
//
// tree_cur = boost::tree::lower_bound(the_tree.root(), 18);
-// BOOST_CHECK(*tree_cur == 18);
+// BOOST_CHECK_EQUAL(*tree_cur, 18);
//
// tree_cur = boost::tree::lower_bound(the_tree.root(), 30);
// BOOST_CHECK(tree_cur.empty());
// BOOST_CHECK(!(++tree_cur).empty());
// --tree_cur;
-// BOOST_CHECK(*tree_cur == 31);
+// BOOST_CHECK_EQUAL(*tree_cur, 31);
//
// tree_cur = boost::tree::lower_bound(the_tree.root(), 3);
-// BOOST_CHECK(*tree_cur == 7);
+// BOOST_CHECK_EQUAL(*tree_cur, 7);
c = my_tree.begin();
- BOOST_CHECK(*c++ == 7);
- BOOST_CHECK(*c++ == 8);
- BOOST_CHECK(*c++ == 18);
- BOOST_CHECK(*c++ == 31);
- BOOST_CHECK(*c++ == 39);
- BOOST_CHECK(*c++ == 412);
- BOOST_CHECK(c == my_tree.end());
- BOOST_CHECK(*--c == 412);
- BOOST_CHECK(*--c == 39);
- BOOST_CHECK(*--c == 31);
- BOOST_CHECK(*--c == 18);
- BOOST_CHECK(*--c == 8);
- BOOST_CHECK(*--c == 7);
- BOOST_CHECK(c == my_tree.begin());
+ BOOST_CHECK_EQUAL(*c++, 7);
+ BOOST_CHECK_EQUAL(*c++, 8);
+ BOOST_CHECK_EQUAL(*c++, 18);
+ BOOST_CHECK_EQUAL(*c++, 31);
+ BOOST_CHECK_EQUAL(*c++, 39);
+ BOOST_CHECK_EQUAL(*c++, 412);
+ BOOST_CHECK_EQUAL(c, my_tree.end());
+ BOOST_CHECK_EQUAL(*--c, 412);
+ BOOST_CHECK_EQUAL(*--c, 39);
+ BOOST_CHECK_EQUAL(*--c, 31);
+ BOOST_CHECK_EQUAL(*--c, 18);
+ BOOST_CHECK_EQUAL(*--c, 8);
+ BOOST_CHECK_EQUAL(*--c, 7);
+ BOOST_CHECK_EQUAL(c, my_tree.begin());
while (c != my_tree.end())
++c;
------c;
- BOOST_CHECK(*c == 31);
+ BOOST_CHECK_EQUAL(*c, 31);
//my_tree.erase(c);
- //BOOST_CHECK(*c == 39);
+ //BOOST_CHECK_EQUAL(*c, 39);
// tree_cur = boost::tree::lower_bound(the_tree.root(), 412);
-// BOOST_CHECK(*tree_cur == 412);
-// BOOST_CHECK(*tree_cur.parent() == 18);
+// BOOST_CHECK_EQUAL(*tree_cur, 412);
+// BOOST_CHECK_EQUAL(*tree_cur.parent(), 18);
//
// c = my_tree.begin();
-// BOOST_CHECK(*c++ == 7);
-// BOOST_CHECK(*c++ == 8);
-// BOOST_CHECK(*c++ == 18);
-// BOOST_CHECK(*c++ == 39);
-// BOOST_CHECK(*c++ == 412);
-// BOOST_CHECK(c == my_tree.end());
+// BOOST_CHECK_EQUAL(*c++, 7);
+// BOOST_CHECK_EQUAL(*c++, 8);
+// BOOST_CHECK_EQUAL(*c++, 18);
+// BOOST_CHECK_EQUAL(*c++, 39);
+// BOOST_CHECK_EQUAL(*c++, 412);
+// BOOST_CHECK_EQUAL(c, my_tree.end());
}
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-29 20:08:01 EDT (Wed, 29 Oct 2008)
@@ -21,22 +21,22 @@
BOOST_CHECK(c.empty());
c = mytree.insert(c, 4);
- BOOST_CHECK(*c == 4);
- BOOST_CHECK(c == mytree.root());
+ BOOST_CHECK_EQUAL(*c, 4);
+ BOOST_CHECK_EQUAL(c, mytree.root());
BOOST_CHECK(c.empty());
c = mytree.insert(c, 5);
- BOOST_CHECK(*c == 5);
- BOOST_CHECK(c == mytree.root());
+ BOOST_CHECK_EQUAL(*c, 5);
+ BOOST_CHECK_EQUAL(c, mytree.root());
++c;
- BOOST_CHECK(*c == 4);
+ BOOST_CHECK_EQUAL(*c, 4);
BOOST_CHECK(c != mytree.root());
BOOST_CHECK(c.empty());
// BOOST_CHECK(c.m_cur != tree_type::node_type::nil());
mytree.insert(c.end(), 3);
- BOOST_CHECK(*(c.begin()) == 3);
+ BOOST_CHECK_EQUAL(*(c.begin()), 3);
BOOST_CHECK(!c.empty());
- BOOST_CHECK(c == c.begin().parent());
+ BOOST_CHECK_EQUAL(c, c.begin().parent());
}
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-29 20:08:01 EDT (Wed, 29 Oct 2008)
@@ -53,7 +53,7 @@
//
// cit = my_searcher.begin();
-// BOOST_CHECK(*c1 == 8);
+// BOOST_CHECK_EQUAL(*c1, 8);
// my_searcher.insert(5);
// my_searcher.insert(it, 7);
@@ -64,35 +64,35 @@
// searcher_t::container_type core = my_searcher.get_container();
// searcher_t::container_type::cursor c = core.root().begin();
-// BOOST_CHECK(*c == 8);
+// BOOST_CHECK_EQUAL(*c, 8);
-// BOOST_CHECK(c1.parent() == c); //Maybe factor out specifc tests (parent(), begin(), ...)
-// BOOST_CHECK(c1 == my_searcher.end().begin()); //FIXME. end means root
+// BOOST_CHECK_EQUAL(c1.parent(), c); //Maybe factor out specifc tests (parent(), begin(), ...)
+// BOOST_CHECK_EQUAL(c1, my_searcher.end().begin()); //FIXME. end means root
// BOOST_CHECK(c1 != my_searcher.end().end()); //ditto
-// BOOST_CHECK(*c1 == 8);
+// BOOST_CHECK_EQUAL(*c1, 8);
// BOOST_CHECK(!c1.has_child());
//
// BOOST_CHECK(c.has_child());
-// BOOST_CHECK(c == my_searcher.end());
+// BOOST_CHECK_EQUAL(c, my_searcher.end());
// ret = key_lower_bound(my_searcher.end(), 18,
// lower_bound_wrapper<mycursor, int, std::less<int> >(),
// boost::multi_index::identity<int>(), std::less<int>());
-// BOOST_CHECK(ret.first == my_searcher.root().end());
+// BOOST_CHECK_EQUAL(ret.first, my_searcher.root().end());
// BOOST_CHECK(ret.second.first);
-// //BOOST_CHECK(ret.first.m_pos == 1);
+// //BOOST_CHECK_EQUAL(ret.first.m_pos, 1);
// c2 = my_searcher.insert(c, 18); //so where does that go?
-// //BOOST_CHECK(c2.parent() == c1);
-// //BOOST_CHECK(c1.end() == c2);
+// //BOOST_CHECK_EQUAL(c2.parent(), c1);
+// //BOOST_CHECK_EQUAL(c1.end(), c2);
// //BOOST_CHECK(c2 != my_searcher.root().end());
//
-// BOOST_CHECK(*c2 == 18);
+// BOOST_CHECK_EQUAL(*c2, 18);
// BOOST_CHECK(!c2.has_child());
//
-// BOOST_CHECK(c2 == my_searcher.root().end().begin());
-// //BOOST_CHECK(c2.m_parent == c.m_parent);
-// //BOOST_CHECK(c2 == c.m_parent);
+// BOOST_CHECK_EQUAL(c2, my_searcher.root().end().begin());
+// //BOOST_CHECK_EQUAL(c2.m_parent, c.m_parent);
+// //BOOST_CHECK_EQUAL(c2, c.m_parent);
// //BOOST_CHECK(c1.has_child()); ///also fails!!!
//
//
@@ -104,46 +104,46 @@
//
// c4 = my_searcher.insert(c, 7);
//
-// BOOST_CHECK(*(c2.parent()) == 31);
-// BOOST_CHECK(*(c2.begin()) == 39);
+// BOOST_CHECK_EQUAL(*(c2.parent()), 31);
+// BOOST_CHECK_EQUAL(*(c2.begin()), 39);
//
-// //BOOST_CHECK(c4.parent() == c1);
+// //BOOST_CHECK_EQUAL(c4.parent(), c1);
//
-// BOOST_CHECK(*c3 == 39);
-// BOOST_CHECK(c4.parent() == c1);
-// BOOST_CHECK(c1.begin() == c4);
+// BOOST_CHECK_EQUAL(*c3, 39);
+// BOOST_CHECK_EQUAL(c4.parent(), c1);
+// BOOST_CHECK_EQUAL(c1.begin(), c4);
//*(mytree.root()) = -5;
//c = my_searcher.root();
//my_searcher.c();
// //*c = 5;
-//// //BOOST_CHECK(*c == 5);
+//// //BOOST_CHECK_EQUAL(*c, 5);
////
// c1 = mytree.insert(c, 1);
-// BOOST_CHECK(*c == 1);
+// BOOST_CHECK_EQUAL(*c, 1);
// c2 = mytree.insert(c1, 2);
-// BOOST_CHECK(*c1 == 1);
-// BOOST_CHECK(*c2 == 2);
+// BOOST_CHECK_EQUAL(*c1, 1);
+// BOOST_CHECK_EQUAL(*c2, 2);
// *c1 = 14; //how can we forbid this? by setting key to int const&
-// BOOST_CHECK(*c1 == 14);
-// BOOST_CHECK(*c2 == 2);
-// BOOST_CHECK(c2.parent() == c1);
-// BOOST_CHECK(c1.parent() == c);
+// BOOST_CHECK_EQUAL(*c1, 14);
+// BOOST_CHECK_EQUAL(*c2, 2);
+// BOOST_CHECK_EQUAL(c2.parent(), c1);
+// BOOST_CHECK_EQUAL(c1.parent(), c);
//
// c3 = c1.end();
// --c3;
-// BOOST_CHECK(*c3 == 2);
+// BOOST_CHECK_EQUAL(*c3, 2);
// ++c3;
// c4 = mytree.insert(c3, 4);
-// BOOST_CHECK(*c4 == 4);
+// BOOST_CHECK_EQUAL(*c4, 4);
// c4 = c4.parent();
// --c4;
-// BOOST_CHECK(*c4 == 2);
+// BOOST_CHECK_EQUAL(*c4, 2);
//
-// //BOOST_CHECK(c4.parent() == c1);
+// //BOOST_CHECK_EQUAL(c4.parent(), c1);
}
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-29 20:08:01 EDT (Wed, 29 Oct 2008)
@@ -30,11 +30,11 @@
// c1 = my_searcher.insert(c1, 8);
//
// c1 = my_searcher.begin();
-// BOOST_CHECK(*c1++ == 6);
-// BOOST_CHECK(*c1++ == 7);
-// BOOST_CHECK(*c1++ == 8);
-// BOOST_CHECK(*c1++ == 18);
-// BOOST_CHECK(c1 == my_searcher.end());
+// BOOST_CHECK_EQUAL(*c1++, 6);
+// BOOST_CHECK_EQUAL(*c1++, 7);
+// BOOST_CHECK_EQUAL(*c1++, 8);
+// BOOST_CHECK_EQUAL(*c1++, 18);
+// BOOST_CHECK_EQUAL(c1, my_searcher.end());
}
//boost::unit_test::test_suite*
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-29 20:08:01 EDT (Wed, 29 Oct 2008)
@@ -40,12 +40,12 @@
//FIXME: const_iterator doesn't work properly yet
searcher_t::iterator ci = my_tree.begin();
- BOOST_CHECK(*ci++ == "anagram");
- BOOST_CHECK(*ci++ == "anodyne");
- BOOST_CHECK(*ci++ == "anteater");
- BOOST_CHECK(*ci++ == "anthology");
- BOOST_CHECK(*ci++ == "anthrax");
- BOOST_CHECK(ci == my_tree.end());
+ BOOST_CHECK_EQUAL(*ci++, "anagram");
+ BOOST_CHECK_EQUAL(*ci++, "anodyne");
+ BOOST_CHECK_EQUAL(*ci++, "anteater");
+ BOOST_CHECK_EQUAL(*ci++, "anthology");
+ BOOST_CHECK_EQUAL(*ci++, "anthrax");
+ BOOST_CHECK_EQUAL(ci, my_tree.end());
}
void test_optimized_string_search_binary_tree()
@@ -68,12 +68,12 @@
//FIXME: const_iterator doesn't work properly yet
searcher_t::iterator ci = my_tree.begin();
- BOOST_CHECK(*ci++ == "anagram");
- BOOST_CHECK(*ci++ == "anodyne");
- BOOST_CHECK(*ci++ == "anteater");
- BOOST_CHECK(*ci++ == "anthology");
- BOOST_CHECK(*ci++ == "anthrax");
- BOOST_CHECK(ci == my_tree.end());
+ BOOST_CHECK_EQUAL(*ci++, "anagram");
+ BOOST_CHECK_EQUAL(*ci++, "anodyne");
+ BOOST_CHECK_EQUAL(*ci++, "anteater");
+ BOOST_CHECK_EQUAL(*ci++, "anthology");
+ BOOST_CHECK_EQUAL(*ci++, "anthrax");
+ BOOST_CHECK_EQUAL(ci, my_tree.end());
}
Modified: sandbox/SOC/2006/tree/trunk/libs/tree/test/test_tree_traversal_data.hpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/libs/tree/test/test_tree_traversal_data.hpp (original)
+++ sandbox/SOC/2006/tree/trunk/libs/tree/test/test_tree_traversal_data.hpp 2008-10-29 20:08:01 EDT (Wed, 29 Oct 2008)
@@ -71,123 +71,123 @@
template <class Tree>
void validate_test_data_tree(Tree const& ret)
{
- BOOST_CHECK(*ret.root().begin() == 8);
- BOOST_CHECK(*ret.root().begin().begin() == 3);
- BOOST_CHECK(*ret.root().begin().begin().begin() == 1); //Leaf
- BOOST_CHECK(*ret.root().begin().end().begin() == 6);
- BOOST_CHECK(*ret.root().begin().end().begin().begin() == 4); //Leaf
- BOOST_CHECK(*ret.root().begin().end().end().begin() == 7); //Leaf
-
- BOOST_CHECK(*ret.root().end().begin() == 10);
- BOOST_CHECK(*ret.root().end().end().begin() == 14);
- BOOST_CHECK(*ret.root().end().end().begin().begin() == 13);
- BOOST_CHECK(*ret.root().end().end().begin().begin().begin() == 11);
- BOOST_CHECK(*ret.root().end().end().begin().begin().end().begin() == 12); //Leaf
+ BOOST_CHECK_EQUAL(*ret.root().begin(), 8);
+ BOOST_CHECK_EQUAL(*ret.root().begin().begin(), 3);
+ BOOST_CHECK_EQUAL(*ret.root().begin().begin().begin(), 1); //Leaf
+ BOOST_CHECK_EQUAL(*ret.root().begin().end().begin(), 6);
+ BOOST_CHECK_EQUAL(*ret.root().begin().end().begin().begin(), 4); //Leaf
+ BOOST_CHECK_EQUAL(*ret.root().begin().end().end().begin(), 7); //Leaf
+
+ BOOST_CHECK_EQUAL(*ret.root().end().begin(), 10);
+ BOOST_CHECK_EQUAL(*ret.root().end().end().begin(), 14);
+ BOOST_CHECK_EQUAL(*ret.root().end().end().begin().begin(), 13);
+ BOOST_CHECK_EQUAL(*ret.root().end().end().begin().begin().begin(), 11);
+ BOOST_CHECK_EQUAL(*ret.root().end().end().begin().begin().end().begin(), 12); //Leaf
}
template <class Tree>
void validate_corresponding_forest_tree(Tree const& t)
{
typename Tree::const_cursor c = t.root().begin();
- BOOST_CHECK(*c == 8);
- BOOST_CHECK(*c.to_begin() == 3);
- BOOST_CHECK(*c.to_begin() == 1);
+ BOOST_CHECK_EQUAL(*c, 8);
+ BOOST_CHECK_EQUAL(*c.to_begin(), 3);
+ BOOST_CHECK_EQUAL(*c.to_begin(), 1);
BOOST_CHECK(c.empty());
BOOST_CHECK(++c == t.root().begin().begin().end());
--c;
c.to_parent();
- BOOST_CHECK(*++c == 6);
- BOOST_CHECK(*c.to_begin() == 4);
+ BOOST_CHECK_EQUAL(*++c, 6);
+ BOOST_CHECK_EQUAL(*c.to_begin(), 4);
c.to_parent();
- BOOST_CHECK(*++c == 7);
+ BOOST_CHECK_EQUAL(*++c, 7);
BOOST_CHECK(++c == t.root().begin().end());
c = t.root().begin();
- BOOST_CHECK(*++c == 10);
- BOOST_CHECK(*++c == 14);
+ BOOST_CHECK_EQUAL(*++c, 10);
+ BOOST_CHECK_EQUAL(*++c, 14);
BOOST_CHECK(++c == t.root().end());
--c;
- BOOST_CHECK(*c.to_begin() == 13);
- BOOST_CHECK(*c.to_begin() == 11);
- BOOST_CHECK(*++c == 12);
+ BOOST_CHECK_EQUAL(*c.to_begin(), 13);
+ BOOST_CHECK_EQUAL(*c.to_begin(), 11);
+ BOOST_CHECK_EQUAL(*++c, 12);
}
template <class Iterator>
void test_traversal(boost::tree::preorder, Iterator a, Iterator b)
{
- BOOST_CHECK(*a++ == 8);
- BOOST_CHECK(*a++ == 3);
- BOOST_CHECK(*a++ == 1);
- BOOST_CHECK(*a++ == 6);
- BOOST_CHECK(*a++ == 4);
- BOOST_CHECK(*a++ == 7);
- BOOST_CHECK(*a++ == 10);
- BOOST_CHECK(*a++ == 14);
- BOOST_CHECK(*a++ == 13);
- BOOST_CHECK(*a++ == 11);
- BOOST_CHECK(*a++ == 12);
+ BOOST_CHECK_EQUAL(*a++, 8);
+ BOOST_CHECK_EQUAL(*a++, 3);
+ BOOST_CHECK_EQUAL(*a++, 1);
+ BOOST_CHECK_EQUAL(*a++, 6);
+ BOOST_CHECK_EQUAL(*a++, 4);
+ BOOST_CHECK_EQUAL(*a++, 7);
+ BOOST_CHECK_EQUAL(*a++, 10);
+ BOOST_CHECK_EQUAL(*a++, 14);
+ BOOST_CHECK_EQUAL(*a++, 13);
+ BOOST_CHECK_EQUAL(*a++, 11);
+ BOOST_CHECK_EQUAL(*a++, 12);
BOOST_CHECK(a == b);
}
template <class Iterator>
void test_reverse_traversal(boost::tree::preorder, Iterator a, Iterator b)
{
- BOOST_CHECK(*--a == 12);
- BOOST_CHECK(*--a == 11);
- BOOST_CHECK(*--a == 13);
- BOOST_CHECK(*--a == 14);
- BOOST_CHECK(*--a == 10);
- BOOST_CHECK(*--a == 7);
- BOOST_CHECK(*--a == 4);
- BOOST_CHECK(*--a == 6);
- BOOST_CHECK(*--a == 1);
- BOOST_CHECK(*--a == 3);
- BOOST_CHECK(*--a == 8);
+ BOOST_CHECK_EQUAL(*--a, 12);
+ BOOST_CHECK_EQUAL(*--a, 11);
+ BOOST_CHECK_EQUAL(*--a, 13);
+ BOOST_CHECK_EQUAL(*--a, 14);
+ BOOST_CHECK_EQUAL(*--a, 10);
+ BOOST_CHECK_EQUAL(*--a, 7);
+ BOOST_CHECK_EQUAL(*--a, 4);
+ BOOST_CHECK_EQUAL(*--a, 6);
+ BOOST_CHECK_EQUAL(*--a, 1);
+ BOOST_CHECK_EQUAL(*--a, 3);
+ BOOST_CHECK_EQUAL(*--a, 8);
BOOST_CHECK(a == b);
}
template <class Iterator>
void test_subtree_traversal(boost::tree::preorder, Iterator a, Iterator b)
{
- BOOST_CHECK(*a++ == 3);
- BOOST_CHECK(*a++ == 1);
- BOOST_CHECK(*a++ == 6);
- BOOST_CHECK(*a++ == 4);
- BOOST_CHECK(*a++ == 7);
+ BOOST_CHECK_EQUAL(*a++, 3);
+ BOOST_CHECK_EQUAL(*a++, 1);
+ BOOST_CHECK_EQUAL(*a++, 6);
+ BOOST_CHECK_EQUAL(*a++, 4);
+ BOOST_CHECK_EQUAL(*a++, 7);
BOOST_CHECK(a == b);
}
template <class Iterator>
void test_traversal(boost::tree::inorder, Iterator a, Iterator b)
{
- BOOST_CHECK(*a++ == 1);
- BOOST_CHECK(*a++ == 3);
- BOOST_CHECK(*a++ == 4);
- BOOST_CHECK(*a++ == 6);
- BOOST_CHECK(*a++ == 7);
- BOOST_CHECK(*a++ == 8);
- BOOST_CHECK(*a++ == 10);
- BOOST_CHECK(*a++ == 11);
- BOOST_CHECK(*a++ == 12);
- BOOST_CHECK(*a++ == 13);
- BOOST_CHECK(*a++ == 14);
+ BOOST_CHECK_EQUAL(*a++, 1);
+ BOOST_CHECK_EQUAL(*a++, 3);
+ BOOST_CHECK_EQUAL(*a++, 4);
+ BOOST_CHECK_EQUAL(*a++, 6);
+ BOOST_CHECK_EQUAL(*a++, 7);
+ BOOST_CHECK_EQUAL(*a++, 8);
+ BOOST_CHECK_EQUAL(*a++, 10);
+ BOOST_CHECK_EQUAL(*a++, 11);
+ BOOST_CHECK_EQUAL(*a++, 12);
+ BOOST_CHECK_EQUAL(*a++, 13);
+ BOOST_CHECK_EQUAL(*a++, 14);
BOOST_CHECK(a == b);
}
template <class Iterator>
void test_reverse_traversal(boost::tree::inorder, Iterator a, Iterator b)
{
- BOOST_CHECK(*--a == 14);
- BOOST_CHECK(*--a == 13);
- BOOST_CHECK(*--a == 12);
- BOOST_CHECK(*--a == 11);
- BOOST_CHECK(*--a == 10);
- BOOST_CHECK(*--a == 8);
- BOOST_CHECK(*--a == 7);
- BOOST_CHECK(*--a == 6);
- BOOST_CHECK(*--a == 4);
- BOOST_CHECK(*--a == 3);
- BOOST_CHECK(*--a == 1);
+ BOOST_CHECK_EQUAL(*--a, 14);
+ BOOST_CHECK_EQUAL(*--a, 13);
+ BOOST_CHECK_EQUAL(*--a, 12);
+ BOOST_CHECK_EQUAL(*--a, 11);
+ BOOST_CHECK_EQUAL(*--a, 10);
+ BOOST_CHECK_EQUAL(*--a, 8);
+ BOOST_CHECK_EQUAL(*--a, 7);
+ BOOST_CHECK_EQUAL(*--a, 6);
+ BOOST_CHECK_EQUAL(*--a, 4);
+ BOOST_CHECK_EQUAL(*--a, 3);
+ BOOST_CHECK_EQUAL(*--a, 1);
BOOST_CHECK(a == b);
}
@@ -195,44 +195,44 @@
template <class Iterator>
void test_traversal(boost::tree::postorder, Iterator a, Iterator b)
{
- BOOST_CHECK(*a++ == 1);
- BOOST_CHECK(*a++ == 4);
- BOOST_CHECK(*a++ == 7);
- BOOST_CHECK(*a++ == 6);
- BOOST_CHECK(*a++ == 3);
- BOOST_CHECK(*a++ == 12);
- BOOST_CHECK(*a++ == 11);
- BOOST_CHECK(*a++ == 13);
- BOOST_CHECK(*a++ == 14);
- BOOST_CHECK(*a++ == 10);
- BOOST_CHECK(*a++ == 8);
+ BOOST_CHECK_EQUAL(*a++, 1);
+ BOOST_CHECK_EQUAL(*a++, 4);
+ BOOST_CHECK_EQUAL(*a++, 7);
+ BOOST_CHECK_EQUAL(*a++, 6);
+ BOOST_CHECK_EQUAL(*a++, 3);
+ BOOST_CHECK_EQUAL(*a++, 12);
+ BOOST_CHECK_EQUAL(*a++, 11);
+ BOOST_CHECK_EQUAL(*a++, 13);
+ BOOST_CHECK_EQUAL(*a++, 14);
+ BOOST_CHECK_EQUAL(*a++, 10);
+ BOOST_CHECK_EQUAL(*a++, 8);
BOOST_CHECK(a == b);
}
template <class Iterator>
void test_reverse_traversal(boost::tree::postorder, Iterator a, Iterator b)
{
- BOOST_CHECK(*--a == 8);
- BOOST_CHECK(*--a == 10);
- BOOST_CHECK(*--a == 14);
- BOOST_CHECK(*--a == 13);
- BOOST_CHECK(*--a == 11);
- BOOST_CHECK(*--a == 12);
- BOOST_CHECK(*--a == 3);
- BOOST_CHECK(*--a == 6);
- BOOST_CHECK(*--a == 7);
- BOOST_CHECK(*--a == 4);
- BOOST_CHECK(*--a == 1);
+ BOOST_CHECK_EQUAL(*--a, 8);
+ BOOST_CHECK_EQUAL(*--a, 10);
+ BOOST_CHECK_EQUAL(*--a, 14);
+ BOOST_CHECK_EQUAL(*--a, 13);
+ BOOST_CHECK_EQUAL(*--a, 11);
+ BOOST_CHECK_EQUAL(*--a, 12);
+ BOOST_CHECK_EQUAL(*--a, 3);
+ BOOST_CHECK_EQUAL(*--a, 6);
+ BOOST_CHECK_EQUAL(*--a, 7);
+ BOOST_CHECK_EQUAL(*--a, 4);
+ BOOST_CHECK_EQUAL(*--a, 1);
BOOST_CHECK(a == b);
}
template <class Iterator>
void test_traversal_from_leaf4(Iterator a, Iterator b)
{
- BOOST_CHECK(*a == 4);
- BOOST_CHECK(*++a == 6);
- BOOST_CHECK(*++a == 3);
- BOOST_CHECK(*++a == 8);
+ BOOST_CHECK_EQUAL(*a, 4);
+ BOOST_CHECK_EQUAL(*++a, 6);
+ BOOST_CHECK_EQUAL(*++a, 3);
+ BOOST_CHECK_EQUAL(*++a, 8);
BOOST_CHECK(++a == b);
} // namespace ascending
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-29 20:08:01 EDT (Wed, 29 Oct 2008)
@@ -30,40 +30,40 @@
c1 = my_tree.insert(c, 8);
- BOOST_CHECK(*c1 == 8);
+ BOOST_CHECK_EQUAL(*c1, 8);
c1 = my_tree.insert(c1, 7);
- BOOST_CHECK(*c1 == 7);
+ BOOST_CHECK_EQUAL(*c1, 7);
++c1;
- BOOST_CHECK(*c1 == 8);
+ BOOST_CHECK_EQUAL(*c1, 8);
++c1;
BOOST_CHECK(c1 == my_tree.end());
c1 = my_tree.insert(my_tree.end(), 10);
- BOOST_CHECK(*c1 == 10);
+ BOOST_CHECK_EQUAL(*c1, 10);
--c1;
- BOOST_CHECK(*c1 == 8);
+ BOOST_CHECK_EQUAL(*c1, 8);
--c1;
- BOOST_CHECK(*c1 == 7);
+ BOOST_CHECK_EQUAL(*c1, 7);
c = my_tree.lower_bound(8);
- BOOST_CHECK(*c == 8);
+ BOOST_CHECK_EQUAL(*c, 8);
++c;
- BOOST_CHECK(*c == 10);
+ BOOST_CHECK_EQUAL(*c, 10);
--c;
- BOOST_CHECK(*c == 8);
+ BOOST_CHECK_EQUAL(*c, 8);
--c;
- BOOST_CHECK(*c == 7);
+ BOOST_CHECK_EQUAL(*c, 7);
++c;
- BOOST_CHECK(*c == 8);
+ BOOST_CHECK_EQUAL(*c, 8);
//c = my_tree.erase(c);
--c;
- BOOST_CHECK(*c == 7);
+ BOOST_CHECK_EQUAL(*c, 7);
}