Subject: [Boost-commit] svn:boost r50396 - in sandbox/SOC/2006/tree/trunk: boost/tree libs/tree/test
From: ockham_at_[hidden]
Date: 2008-12-29 08:40:05
Author: bernhard.reiter
Date: 2008-12-29 08:40:04 EST (Mon, 29 Dec 2008)
New Revision: 50396
URL: http://svn.boost.org/trac/boost/changeset/50396
Log:
More fake_binary_tree/test related fixes.
Start factoring out insert_cursor_test.
Added:
sandbox/SOC/2006/tree/trunk/libs/tree/test/insert_cursor_test.cpp
- copied, changed from r50395, /sandbox/SOC/2006/tree/trunk/libs/tree/test/cursor_algorithm_test.cpp
Text files modified:
sandbox/SOC/2006/tree/trunk/boost/tree/ascending_cursor.hpp | 2
sandbox/SOC/2006/tree/trunk/libs/tree/test/Jamfile.v2 | 1
sandbox/SOC/2006/tree/trunk/libs/tree/test/cursor_algorithm_test.cpp | 102 +++++++++++++++++++++++----------
sandbox/SOC/2006/tree/trunk/libs/tree/test/fake_binary_tree.hpp | 104 +++++++++++++++++++--------------
sandbox/SOC/2006/tree/trunk/libs/tree/test/insert_cursor_test.cpp | 108 ++++++++++------------------------
sandbox/SOC/2006/tree/trunk/libs/tree/test/iterator_algorithm_test.cpp | 122 ++++++++++++++++++++--------------------
6 files changed, 226 insertions(+), 213 deletions(-)
Modified: sandbox/SOC/2006/tree/trunk/boost/tree/ascending_cursor.hpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/boost/tree/ascending_cursor.hpp (original)
+++ sandbox/SOC/2006/tree/trunk/boost/tree/ascending_cursor.hpp 2008-12-29 08:40:04 EST (Mon, 29 Dec 2008)
@@ -134,7 +134,7 @@
void advance(typename ascending_cursor::cursor_facade_::difference_type n)
{
- m_s.top() += n;
+ m_s.top() += n;
}
typename ascending_cursor::cursor_facade_::difference_type
Modified: sandbox/SOC/2006/tree/trunk/libs/tree/test/Jamfile.v2
==============================================================================
--- sandbox/SOC/2006/tree/trunk/libs/tree/test/Jamfile.v2 (original)
+++ sandbox/SOC/2006/tree/trunk/libs/tree/test/Jamfile.v2 2008-12-29 08:40:04 EST (Mon, 29 Dec 2008)
@@ -27,6 +27,7 @@
[ run binary_tree_search_test.cpp ]
# [ run key_search_binary_tree_test.cpp ]
# [ run rank_search_binary_tree_test.cpp ]
+ [ run insert_cursor_test.cpp ]
[ run algorithm_concepts_test.cpp ]
[ run cursor_algorithm_test.cpp ]
[ run iterator_algorithm_test.cpp ]
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-12-29 08:40:04 EST (Mon, 29 Dec 2008)
@@ -4,18 +4,10 @@
// (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/tree/insert_cursor.hpp>
-
#include <boost/lambda/bind.hpp>
-#include <list>
-#include <algorithm>
-#include <iterator>
-
#define BOOST_TEST_MODULE cursor_algorithm test
#include <boost/test/included/unit_test.hpp>
#include <boost/test/test_case_template.hpp>
@@ -27,47 +19,76 @@
using namespace boost::tree;
-BOOST_FIXTURE_TEST_SUITE(cursor_algorithms, fake_binary_tree_fixture<int>)
+BOOST_FIXTURE_TEST_SUITE(cursor_algorithms_test, fake_binary_tree_with_list_fixture<int>)
-BOOST_AUTO_TEST_CASE_TEMPLATE( test_foreach, Order, orders)
+BOOST_AUTO_TEST_CASE_TEMPLATE( test_foreach_descending, Order, orders)
{
- fake_binary_tree<int> mt = generate_fake_binary_tree();
- std::list<int> l;
boost::tree::for_each(
Order(),
- mbt1.root(),
+ fbt1.descending_root(),
boost::lambda::bind(&std::list<int>::push_back, &l, boost::lambda::_1)
);
test_traversal(Order(), l.begin(), l.end());
}
-BOOST_AUTO_TEST_SUITE_END()
+BOOST_AUTO_TEST_CASE_TEMPLATE( test_foreach_ascending, Order, orders)
+{
+ boost::tree::for_each(
+ Order(),
+ fbt1.ascending_root(),
+ boost::lambda::bind(&std::list<int>::push_back, &l, boost::lambda::_1)
+ );
+ test_traversal(Order(), l.begin(), l.end());
+}
-BOOST_FIXTURE_TEST_SUITE(cursor_algorithms_test, fake_binary_tree_with_list_fixture<int>)
+BOOST_AUTO_TEST_CASE( test_foreach_subtree3_descending )
+{
+ boost::tree::for_each(
+ preorder(),
+ fbt1.descending_root().begin(),
+ boost::lambda::bind(&std::list<int>::push_back, &l, boost::lambda::_1)
+ );
+ test_subtree_traversal(preorder(), l.begin(), l.end(), 1);
+ BOOST_CHECK_EQUAL(l.size(), 5);
+}
-BOOST_AUTO_TEST_CASE( test_foreach_subtree3 )
+BOOST_AUTO_TEST_CASE( test_foreach_subtree3_ascending )
{
boost::tree::for_each(
preorder(),
- mbt1.root().begin(),
+ fbt1.ascending_root().begin(),
boost::lambda::bind(&std::list<int>::push_back, &l, boost::lambda::_1)
);
test_subtree_traversal(preorder(), l.begin(), l.end(), 1);
BOOST_CHECK_EQUAL(l.size(), 5);
}
-BOOST_AUTO_TEST_CASE_TEMPLATE( test_copy, Order, orders)
+BOOST_AUTO_TEST_CASE_TEMPLATE( test_copy_descending, Order, orders)
{
- boost::tree::copy(Order(), mbt1.root(), o);
+ boost::tree::copy(Order(), fbt1.descending_root(), o);
test_traversal(Order(), l.begin(), l.end());
}
-BOOST_AUTO_TEST_CASE_TEMPLATE( test_copy_trees, Order, orders)
+BOOST_AUTO_TEST_CASE_TEMPLATE( test_copy_ascending, Order, orders)
{
- BOOST_CHECK(mbt1 != mbt2);
- boost::tree::copy(Order(), mbt1.root(), mbt2.root());
- BOOST_CHECK(mbt1 == mbt2);
- validate_test_dataset1_tree(mbt2.root());
+ boost::tree::copy(Order(), fbt1.ascending_root(), o);
+ test_traversal(Order(), l.begin(), l.end());
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE( test_copy_trees_descending, Order, orders)
+{
+ BOOST_CHECK(fbt1 != fbt2);
+ boost::tree::copy(Order(), fbt1.descending_root(), fbt2.descending_root());
+ BOOST_CHECK(fbt1 == fbt2);
+ validate_test_dataset1_tree(fbt2.descending_root());
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE( test_copy_trees_ascending, Order, orders)
+{
+ BOOST_CHECK(fbt1 != fbt2);
+ boost::tree::copy(Order(), fbt1.ascending_root(), fbt2.ascending_root());
+ BOOST_CHECK(fbt1 == fbt2);
+ validate_test_dataset1_tree(fbt2.ascending_root());
}
//BOOST_AUTO_TEST_CASE_TEMPLATE ( test_desc_copy_using_insert_cursor, Order, orders )
@@ -92,22 +113,41 @@
// BOOST_CHECK_EQUAL(size(bt2.root()), size(bt.root()));
//}
-BOOST_AUTO_TEST_CASE_TEMPLATE( test_transform, Order, orders)
+BOOST_AUTO_TEST_CASE_TEMPLATE( test_transform_descending, Order, orders)
{
// 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(), mbt1.root(), mbt2.root(), std::bind2nd(std::plus<int>(),1));
- boost::tree::transform(Order(), mbt2.root(), o, std::bind2nd(std::minus<int>(),1));
+ boost::tree::transform(Order(), fbt1.descending_root(), fbt2.descending_root(), std::bind2nd(std::plus<int>(),1));
+ boost::tree::transform(Order(), fbt2.descending_root(), o, std::bind2nd(std::minus<int>(),1));
test_traversal(Order(), l.begin(), l.end());
}
-BOOST_AUTO_TEST_CASE_TEMPLATE( test_transform_trees, Order, orders)
+BOOST_AUTO_TEST_CASE_TEMPLATE( test_transform_ascending, Order, orders)
{
- BOOST_CHECK(mbt1 != mbt2);
- boost::tree::transform(Order(), mbt1.root(), mbt2.root()
+ // 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(), fbt1.ascending_root(), fbt2.ascending_root(), std::bind2nd(std::plus<int>(),1));
+ boost::tree::transform(Order(), fbt2.ascending_root(), o, std::bind2nd(std::minus<int>(),1));
+ test_traversal(Order(), l.begin(), l.end());
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE( test_transform_trees_descending, Order, orders)
+{
+ BOOST_CHECK(fbt1 != fbt2);
+ boost::tree::transform(Order(), fbt1.descending_root(), fbt2.descending_root()
, std::bind2nd(std::minus<int>(),1));
- validate_test_dataset1_minus_1_tree(mbt2.root());
+ validate_test_dataset1_minus_1_tree(fbt2.descending_root());
}
+BOOST_AUTO_TEST_CASE_TEMPLATE( test_transform_trees_ascending, Order, orders)
+{
+ BOOST_CHECK(fbt1 != fbt2);
+ boost::tree::transform(Order(), fbt1.ascending_root(), fbt2.ascending_root()
+ , std::bind2nd(std::minus<int>(),1));
+ validate_test_dataset1_minus_1_tree(fbt2.ascending_root());
+}
+
+
BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file
Modified: sandbox/SOC/2006/tree/trunk/libs/tree/test/fake_binary_tree.hpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/libs/tree/test/fake_binary_tree.hpp (original)
+++ sandbox/SOC/2006/tree/trunk/libs/tree/test/fake_binary_tree.hpp 2008-12-29 08:40:04 EST (Mon, 29 Dec 2008)
@@ -14,20 +14,31 @@
#include "helpers.hpp"
template <class T>
-struct fake_binary_tree_cursor;
+struct fake_descending_binary_cursor;
+
+template <class T>
+struct fake_ascending_binary_cursor;
/// See http://en.wikipedia.org/wiki/Binary_Tree#Methods_for_storing_binary_trees
template <class T>
struct fake_binary_tree {
- typedef fake_binary_tree_cursor<T> cursor;
- typedef fake_binary_tree_cursor<T const> const_cursor;
+ typedef fake_descending_binary_cursor<T> descending_cursor;
+ typedef fake_descending_binary_cursor<T const> const_descending_cursor;
+
+ typedef fake_ascending_binary_cursor<T> ascending_cursor;
+ typedef fake_ascending_binary_cursor<T const> const_ascending_cursor;
fake_binary_tree(typename std::vector<T>::size_type s) : m_data(s)
{ }
- cursor root()
+ descending_cursor descending_root()
+ {
+ return descending_cursor(*this, 0);
+ }
+
+ ascending_cursor ascending_root()
{
- return cursor(*this, 0);
+ return ascending_cursor(*this, 0);
}
typedef std::vector<T> children_type;
@@ -52,9 +63,9 @@
return !(x == y);
}
-// Make this use cursor_adaptor. Yes, even if that means relying on it.
+// Make this use cursor_facade. Yes, even if that means relying on it.
template <class T>
-struct fake_binary_tree_cursor {
+struct fake_descending_binary_cursor {
typedef boost::forward_traversal_tag vertical_traversal;
typedef boost::bidirectional_traversal_tag horizontal_traversal;
typedef horizontal_traversal iterator_category;
@@ -65,21 +76,21 @@
typedef typename fake_binary_tree<T>::size_type size_type;
- typedef fake_binary_tree_cursor<T> cursor;
- typedef fake_binary_tree_cursor<T const> const_cursor;
-
-
- //typedef typename fake_binary_tree<T>::children_type::value_type cur;
- //cur c;
+ typedef fake_descending_binary_cursor<T> cursor;
+ typedef fake_descending_binary_cursor<T const> const_cursor;
+
fake_binary_tree<T>& m_tree;
typename fake_binary_tree<T>::size_type m_pos;
- explicit fake_binary_tree_cursor(fake_binary_tree<T>& t, size_type p = 0) : m_tree(t), m_pos(p) {}
- //fake_binary_tree_cursor(fake_binary_tree_cursor const& mtc) : c(mtc.c), bgn(false) {}
+ explicit fake_descending_binary_cursor(fake_binary_tree<T>& t, size_type p = 0)
+ : m_tree(t), m_pos(p) {}
+
+ fake_descending_binary_cursor(fake_descending_binary_cursor<T> const& other)
+ : m_tree(other.m_tree), m_pos(other.m_pos) {}
T const& operator*() const
{
- return m_tree.m_data[m_pos];
+ return m_tree.m_data[(m_pos-1)/2];
}
T& operator*()
@@ -87,41 +98,41 @@
return m_tree.m_data[(m_pos-1)/2];
}
- fake_binary_tree_cursor& to_begin()
+ fake_descending_binary_cursor& to_begin()
{
m_pos <<= 1;
++m_pos;
return *this;
}
- fake_binary_tree_cursor begin()
+ fake_descending_binary_cursor begin()
{
- fake_binary_tree_cursor tmp(*this);
+ fake_descending_binary_cursor tmp(*this);
tmp.to_begin();
return tmp;
}
- fake_binary_tree_cursor& to_end()
+ fake_descending_binary_cursor& to_end()
{
++m_pos;
m_pos <<= 1;
return *this;
}
- fake_binary_tree_cursor end()
+ fake_descending_binary_cursor end()
{
- fake_binary_tree_cursor tmp(*this);
+ fake_descending_binary_cursor tmp(*this);
tmp.to_end();
return tmp;
}
- fake_binary_tree_cursor& operator++()
+ fake_descending_binary_cursor& operator++()
{
++m_pos;
return *this;
}
- fake_binary_tree_cursor& operator--()
+ fake_descending_binary_cursor& operator--()
{
--m_pos;
return *this;
@@ -143,31 +154,34 @@
};
template <class T>
-bool operator==(fake_binary_tree_cursor<T> const& x, fake_binary_tree_cursor<T> const& y)
+bool operator==(fake_descending_binary_cursor<T> const& x, fake_descending_binary_cursor<T> const& y)
{
return (x.m_tree == y.m_tree) && (x.m_pos == y.m_pos);
}
template <class T>
-bool operator!=(fake_binary_tree_cursor<T> const& x, fake_binary_tree_cursor<T> const& y)
+bool operator!=(fake_descending_binary_cursor<T> const& x, fake_descending_binary_cursor<T> const& y)
{
return !(x==y);
}
template <class T>
-struct fake_ascending_binary_tree_cursor;
+struct fake_ascending_binary_cursor;
template <class T>
-struct fake_ascending_binary_tree_cursor
-: public boost::tree::cursor_adaptor<fake_ascending_binary_tree_cursor<T>
- , fake_binary_tree_cursor<T> >
+struct fake_ascending_binary_cursor
+: public boost::tree::cursor_adaptor<fake_ascending_binary_cursor<T>
+ , fake_descending_binary_cursor<T>
+ , boost::use_default
+ , boost::use_default
+ , boost::bidirectional_traversal_tag >
{
- typedef fake_ascending_binary_tree_cursor<T> cursor;
- typedef fake_ascending_binary_tree_cursor<T const> const_cursor;
+ typedef fake_ascending_binary_cursor<T> cursor;
+ typedef fake_ascending_binary_cursor<T const> const_cursor;
- fake_ascending_binary_tree_cursor(fake_binary_tree<T>& t
+ fake_ascending_binary_cursor(fake_binary_tree<T>& t
, typename fake_binary_tree<T>::size_type p)
- : fake_ascending_binary_tree_cursor::cursor_adaptor_(fake_binary_tree_cursor<T>(t, p)) {}
+ : fake_ascending_binary_cursor::cursor_adaptor_(fake_descending_binary_cursor<T>(t, p)) {}
private:
friend class boost::iterator_core_access;
@@ -181,22 +195,22 @@
};
//template <class T>
-//struct fake_ascending_binary_tree_cursor
-//: public fake_binary_tree_cursor<T> {
-// fake_ascending_binary_tree_cursor(fake_binary_tree<T>& t
+//struct fake_ascending_binary_cursor
+//: public fake_descending_binary_cursor<T> {
+// fake_ascending_binary_cursor(fake_binary_tree<T>& t
// , typename fake_binary_tree<T>::size_type p)
-// : fake_binary_tree_cursor<T>(t, p) {}
+// : fake_descending_binary_cursor<T>(t, p) {}
//
-// fake_ascending_binary_tree_cursor& to_parent()
+// fake_ascending_binary_cursor& to_parent()
// {
-// --fake_binary_tree_cursor<T>::m_pos;
-// fake_binary_tree_cursor<T>::m_pos >>= 1;
+// --fake_descending_binary_cursor<T>::m_pos;
+// fake_descending_binary_cursor<T>::m_pos >>= 1;
// return *this;
// }
//
-// fake_ascending_binary_tree_cursor parent()
+// fake_ascending_binary_cursor parent()
// {
-// fake_ascending_binary_tree_cursor tmp(*this);
+// fake_ascending_binary_cursor tmp(*this);
// tmp.to_parent();
// return tmp;
// }
@@ -223,7 +237,7 @@
template <class T = int>
struct fake_binary_tree_fixture {
- fake_binary_tree_fixture() : mbt1(generate_fake_binary_tree()), mbt2(57) {}
+ fake_binary_tree_fixture() : fbt1(generate_fake_binary_tree()), fbt2(57) {}
template <class Cursor>
static void validate_test_dataset1_tree(Cursor cur)
@@ -258,7 +272,7 @@
BOOST_CHECK_EQUAL(*cur.end().end().begin().begin().end().begin(), 11); //Leaf
}
- fake_binary_tree<T> mbt1, mbt2;
+ fake_binary_tree<T> fbt1, fbt2;
};
template <class T = int>
Copied: sandbox/SOC/2006/tree/trunk/libs/tree/test/insert_cursor_test.cpp (from r50395, /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/insert_cursor_test.cpp 2008-12-29 08:40:04 EST (Mon, 29 Dec 2008)
@@ -10,11 +10,11 @@
#include <boost/tree/insert_cursor.hpp>
-#include <boost/lambda/bind.hpp>
+//#include <boost/lambda/bind.hpp>
-#include <list>
-#include <algorithm>
-#include <iterator>
+//#include <list>
+//#include <algorithm>
+//#include <iterator>
#define BOOST_TEST_MODULE cursor_algorithm test
#include <boost/test/included/unit_test.hpp>
@@ -27,87 +27,45 @@
using namespace boost::tree;
-BOOST_FIXTURE_TEST_SUITE(cursor_algorithms, fake_binary_tree_fixture<int>)
+BOOST_FIXTURE_TEST_SUITE(insert_cursor_test, test_binary_tree_fixture<int>)
-BOOST_AUTO_TEST_CASE_TEMPLATE( test_foreach, Order, orders)
+template <class Cursor>
+void fill_subtree_with_data(Cursor cur)
{
- fake_binary_tree<int> mt = generate_fake_binary_tree();
- std::list<int> l;
- boost::tree::for_each(
- Order(),
- mbt1.root(),
- boost::lambda::bind(&std::list<int>::push_back, &l, boost::lambda::_1)
- );
- test_traversal(Order(), l.begin(), l.end());
+ *cur.begin() = 8;
+ *cur.begin().begin() = 3;
+ *cur.begin().begin().begin() = 1; //Leaf
+ *cur.begin().end().begin() = 6;
+ *cur.begin().end().begin().begin() = 4; //Leaf
+ *cur.begin().end().end().begin() = 7; //Leaf
+ *cur.end().begin() = 10;
+ *cur.end().end().begin() = 14;
+ *cur.end().end().begin().begin() = 13;
+ *cur.end().end().begin().begin().begin() = 11;
+ *cur.end().end().begin().begin().end().begin() = 12; //Leaf
}
-BOOST_AUTO_TEST_SUITE_END()
-
-BOOST_FIXTURE_TEST_SUITE(cursor_algorithms_test, fake_binary_tree_with_list_fixture<int>)
-
-BOOST_AUTO_TEST_CASE( test_foreach_subtree3 )
+BOOST_AUTO_TEST_CASE_TEMPLATE ( test_desc_copy_using_insert_cursor, Order, orders )
{
- boost::tree::for_each(
- preorder(),
- mbt1.root().begin(),
- boost::lambda::bind(&std::list<int>::push_back, &l, boost::lambda::_1)
- );
- test_subtree_traversal(preorder(), l.begin(), l.end(), 1);
- BOOST_CHECK_EQUAL(l.size(), 5);
-}
+ bt2.clear();
-BOOST_AUTO_TEST_CASE_TEMPLATE( test_copy, Order, orders)
-{
- boost::tree::copy(Order(), mbt1.root(), o);
- test_traversal(Order(), l.begin(), l.end());
-}
+ boost::tree::copy(Order(), bt.root(), tree_inserter(bt2, bt2.root())
+ , boost::forward_traversal_tag());
+// fill_subtree_with_data(tree_inserter(bt2, bt2.root()));
-BOOST_AUTO_TEST_CASE_TEMPLATE( test_copy_trees, Order, orders)
-{
- BOOST_CHECK(mbt1 != mbt2);
- boost::tree::copy(Order(), mbt1.root(), mbt2.root());
- BOOST_CHECK(mbt1 == mbt2);
- validate_test_dataset1_tree(mbt2.root());
+ validate_test_dataset1_tree(bt2.root());
+ BOOST_CHECK_EQUAL(size(bt2.root()), size(bt.root()));
}
-//BOOST_AUTO_TEST_CASE_TEMPLATE ( test_desc_copy_using_insert_cursor, Order, orders )
-//{
-// bt2.clear();
-//
-// boost::tree::copy(Order(), bt.root(), tree_inserter(bt2, bt2.root())
-// , boost::forward_traversal_tag());
-//
-// validate_test_dataset1_tree(bt2.root());
-// BOOST_CHECK_EQUAL(size(bt2.root()), size(bt.root()));
-//}
-//
-//BOOST_AUTO_TEST_CASE_TEMPLATE ( test_asc_copy_using_insert_cursor, Order, orders )
-//{
-// bt2.clear();
-//
-// boost::tree::copy(Order(), bt.root(), tree_inserter(bt2, bt2.root())
-// , boost::bidirectional_traversal_tag());
-//
-// validate_test_dataset1_tree(bt2.root());
-// BOOST_CHECK_EQUAL(size(bt2.root()), size(bt.root()));
-//}
+BOOST_AUTO_TEST_CASE_TEMPLATE ( test_asc_copy_using_insert_cursor, Order, orders )
+{
+ bt2.clear();
+
+ boost::tree::copy(Order(), bt.root(), tree_inserter(bt2, bt2.root())
+ , boost::bidirectional_traversal_tag());
-BOOST_AUTO_TEST_CASE_TEMPLATE( test_transform, Order, orders)
-{
- // 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(), mbt1.root(), mbt2.root(), std::bind2nd(std::plus<int>(),1));
- boost::tree::transform(Order(), mbt2.root(), o, std::bind2nd(std::minus<int>(),1));
- test_traversal(Order(), l.begin(), l.end());
-}
-
-BOOST_AUTO_TEST_CASE_TEMPLATE( test_transform_trees, Order, orders)
-{
- BOOST_CHECK(mbt1 != mbt2);
- boost::tree::transform(Order(), mbt1.root(), mbt2.root()
- , std::bind2nd(std::minus<int>(),1));
- validate_test_dataset1_minus_1_tree(mbt2.root());
+ validate_test_dataset1_tree(bt2.root());
+ BOOST_CHECK_EQUAL(size(bt2.root()), size(bt.root()));
}
BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file
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-12-29 08:40:04 EST (Mon, 29 Dec 2008)
@@ -27,101 +27,101 @@
BOOST_AUTO_TEST_CASE_TEMPLATE( test_iterator_algorithms, Order, orders )
{
- fake_ascending_binary_tree_cursor<int> ambtc1(mbt1, 0);
+ fake_ascending_binary_cursor<int> afbtc1(fbt1, 0);
- test_traversal(Order(), begin(Order(), ambtc1)
- , end(Order(), ambtc1));
+ test_traversal(Order(), begin(Order(), afbtc1)
+ , end(Order(), afbtc1));
- test_reverse_traversal(Order(), end(Order(), ambtc1)
- , begin(Order(), ambtc1));
+ test_reverse_traversal(Order(), end(Order(), afbtc1)
+ , begin(Order(), afbtc1));
- BOOST_CHECK_EQUAL(std::distance(begin(Order(), ambtc1)
- , end(Order(), ambtc1)), 11);
+ BOOST_CHECK_EQUAL(std::distance(begin(Order(), afbtc1)
+ , end(Order(), afbtc1)), 11);
// TODO: Also check with binary_tree-specialized inorder begin()!
// Now the iterators based on stack-based cursors (that don't use cursor.to_parent())
// FIXME
-// test_traversal(Order(), begin(Order(), make_ascending_cursor(mbt1.root()))
-// , end(Order(), make_ascending_cursor(mbt1.root())));
-// test_reverse_traversal(Order(), end(Order(), make_ascending_cursor(mbt1.root()))
-// , begin(Order(), make_ascending_cursor(mbt1.root())));
+// test_traversal(Order(), begin(Order(), make_ascending_cursor(fbt1.descending_root()))
+// , end(Order(), make_ascending_cursor(fbt1.descending_root())));
+// test_reverse_traversal(Order(), end(Order(), make_ascending_cursor(fbt1.descending_root()))
+// , begin(Order(), make_ascending_cursor(fbt1.descending_root())));
// BOOST_CHECK_EQUAL(std::distance(
-// begin(Order(), make_ascending_cursor(mbt1.root()))
-// , end(Order(), make_ascending_cursor(mbt1.root()))), 11);
+// begin(Order(), make_ascending_cursor(fbt1.descending_root()))
+// , end(Order(), make_ascending_cursor(fbt1.descending_root()))), 11);
}
BOOST_AUTO_TEST_CASE( test_subtree3_iterator_algorithms )
{
- fake_ascending_binary_tree_cursor<int> ambtc1(mbt1, 0);
+ fake_ascending_binary_cursor<int> afbtc1(fbt1, 0);
- test_subtree_traversal(preorder(), begin(preorder(), ambtc1.begin())
- , end(preorder(), ambtc1.begin()), 1);
- BOOST_CHECK_EQUAL(std::distance(begin(preorder(), ambtc1.begin())
- , end(preorder(), ambtc1.begin())), 5);
-
- test_subtree_traversal(inorder(), begin(inorder(), ambtc1.begin())
- , end(inorder(), ambtc1.begin()), 0);
- BOOST_CHECK_EQUAL(std::distance(begin(inorder(), ambtc1.begin())
- , end(inorder(), ambtc1.begin())), 5);
-
- test_subtree_traversal(postorder(), begin(postorder(), ambtc1.begin())
- , end(postorder(), ambtc1.begin()), 0);
- BOOST_CHECK_EQUAL(std::distance(begin(postorder(), ambtc1.begin())
- , end(postorder(), ambtc1.begin())), 5);
+ test_subtree_traversal(preorder(), begin(preorder(), afbtc1.begin())
+ , end(preorder(), afbtc1.begin()), 1);
+ BOOST_CHECK_EQUAL(std::distance(begin(preorder(), afbtc1.begin())
+ , end(preorder(), afbtc1.begin())), 5);
+
+ test_subtree_traversal(inorder(), begin(inorder(), afbtc1.begin())
+ , end(inorder(), afbtc1.begin()), 0);
+ BOOST_CHECK_EQUAL(std::distance(begin(inorder(), afbtc1.begin())
+ , end(inorder(), afbtc1.begin())), 5);
+
+ test_subtree_traversal(postorder(), begin(postorder(), afbtc1.begin())
+ , end(postorder(), afbtc1.begin()), 0);
+ BOOST_CHECK_EQUAL(std::distance(begin(postorder(), afbtc1.begin())
+ , end(postorder(), afbtc1.begin())), 5);
}
BOOST_AUTO_TEST_CASE( test_subtree6_iterator_algorithms )
{
- fake_ascending_binary_tree_cursor<int> ambtc1(mbt1, 0);
+ fake_ascending_binary_cursor<int> afbtc1(fbt1, 0);
- test_subtree_traversal(preorder(), begin(preorder(), ambtc1.begin().end())
- , end(preorder(), ambtc1.begin().end()), 3);
- BOOST_CHECK_EQUAL(std::distance(begin(preorder(), ambtc1.begin().end())
- , end(preorder(), ambtc1.begin().end())), 3);
-
- test_subtree_traversal(inorder(), begin(inorder(), ambtc1.begin().end())
- , end(inorder(), ambtc1.begin().end()), 2);
- BOOST_CHECK_EQUAL(std::distance(begin(inorder(), ambtc1.begin().end())
- , end(inorder(), ambtc1.begin().end())), 3);
-
- test_subtree_traversal(postorder(), begin(postorder(), ambtc1.begin().end())
- , end(postorder(), ambtc1.begin().end()), 1);
- BOOST_CHECK_EQUAL(std::distance(begin(postorder(), ambtc1.begin().end())
- , end(postorder(), ambtc1.begin().end())), 3);
+ test_subtree_traversal(preorder(), begin(preorder(), afbtc1.begin().end())
+ , end(preorder(), afbtc1.begin().end()), 3);
+ BOOST_CHECK_EQUAL(std::distance(begin(preorder(), afbtc1.begin().end())
+ , end(preorder(), afbtc1.begin().end())), 3);
+
+ test_subtree_traversal(inorder(), begin(inorder(), afbtc1.begin().end())
+ , end(inorder(), afbtc1.begin().end()), 2);
+ BOOST_CHECK_EQUAL(std::distance(begin(inorder(), afbtc1.begin().end())
+ , end(inorder(), afbtc1.begin().end())), 3);
+
+ test_subtree_traversal(postorder(), begin(postorder(), afbtc1.begin().end())
+ , end(postorder(), afbtc1.begin().end()), 1);
+ BOOST_CHECK_EQUAL(std::distance(begin(postorder(), afbtc1.begin().end())
+ , end(postorder(), afbtc1.begin().end())), 3);
}
BOOST_AUTO_TEST_CASE( test_subtree10_iterator_algorithms )
{
- fake_ascending_binary_tree_cursor<int> ambtc1(mbt1, 0);
+ fake_ascending_binary_cursor<int> afbtc1(fbt1, 0);
- test_subtree_traversal(preorder(), begin(preorder(), ambtc1.end())
- , end(preorder(), ambtc1.end()), 6);
- BOOST_CHECK_EQUAL(std::distance(begin(preorder(), ambtc1.end())
- , end(preorder(), ambtc1.end())), 5);
-
- test_subtree_traversal(inorder(), begin(inorder(), ambtc1.end())
- , end(inorder(), ambtc1.end()), 6);
- BOOST_CHECK_EQUAL(std::distance(begin(inorder(), ambtc1.end())
- , end(inorder(), ambtc1.end())), 5);
-
- test_subtree_traversal(postorder(), begin(postorder(), ambtc1.end())
- , end(postorder(), ambtc1.end()), 5);
- BOOST_CHECK_EQUAL(std::distance(begin(postorder(), ambtc1.end())
- , end(postorder(), ambtc1.end())), 5);
+ test_subtree_traversal(preorder(), begin(preorder(), afbtc1.end())
+ , end(preorder(), afbtc1.end()), 6);
+ BOOST_CHECK_EQUAL(std::distance(begin(preorder(), afbtc1.end())
+ , end(preorder(), afbtc1.end())), 5);
+
+ test_subtree_traversal(inorder(), begin(inorder(), afbtc1.end())
+ , end(inorder(), afbtc1.end()), 6);
+ BOOST_CHECK_EQUAL(std::distance(begin(inorder(), afbtc1.end())
+ , end(inorder(), afbtc1.end())), 5);
+
+ test_subtree_traversal(postorder(), begin(postorder(), afbtc1.end())
+ , end(postorder(), afbtc1.end()), 5);
+ BOOST_CHECK_EQUAL(std::distance(begin(postorder(), afbtc1.end())
+ , end(postorder(), afbtc1.end())), 5);
}
BOOST_AUTO_TEST_CASE( test_ascending_iterator_algorithms )
{
- typedef fake_ascending_binary_tree_cursor<int> cursor;
- cursor c(mbt1, 0);
+ typedef fake_ascending_binary_cursor<int> cursor;
+ cursor c(fbt1, 0);
typedef boost::tree::root_tracking_cursor<cursor> rtc;
typedef boost::tree::iterator<ascending, rtc> ai;
c.to_begin().to_end().to_begin().to_begin();
BOOST_CHECK_EQUAL(*c, 4);
- test_traversal_from_leaf4(ai(rtc(c)), ai(rtc(cursor(mbt1,0))));
+ test_traversal_from_leaf4(ai(rtc(c)), ai(rtc(cursor(fbt1,0))));
}
BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file