forked from boostorg/intrusive
Put swap tests inside generic associative container tests so that they are executed for every tree type.
This commit is contained in:
Ion Gaztañaga
@@ -3894,6 +3894,7 @@ to be inserted in intrusive containers are allocated using `std::vector` or `std
|
||||
* [@https://github.com/boostorg/intrusive/pull/57 GitHub #57: ['UB: comparing unrelated pointers]]
|
||||
* [@https://github.com/boostorg/intrusive/issues/59 GitHub #59: ['Add noexcept support to the library]]
|
||||
* [@https://github.com/boostorg/intrusive/issues/60 GitHub #60: ['Licensing question for math.hpp]]
|
||||
* [@https://github.com/boostorg/intrusive/pull/61 GitHub #61: ['Fix bstree_algorithms<>::swap_nodes]]
|
||||
* [@https://github.com/boostorg/intrusive/issues/63 GitHub #63: ['nop splice removes element]]
|
||||
|
||||
[endsect]
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// (C) Copyright Ion Gaztanaga 2007-2014
|
||||
// (C) Copyright Ion Gaztanaga 2007-2021
|
||||
// (C) Copyright Daniel Steck 2021
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
|
||||
@@ -17,6 +17,7 @@
|
||||
#ifdef BOOST_MSVC
|
||||
|
||||
#pragma warning (push)
|
||||
#pragma warning (disable : 4619) // there is no warning number 'XXXX'
|
||||
#pragma warning (disable : 4275) // non DLL-interface classkey "identifier" used as base for DLL-interface classkey "identifier"
|
||||
#pragma warning (disable : 4251) // "identifier" : class "type" needs to have dll-interface to be used by clients of class "type2"
|
||||
#pragma warning (disable : 4675) // "method" should be declared "static" and have exactly one parameter
|
||||
|
||||
@@ -1,7 +1,8 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// (C) Copyright Olaf Krzikalla 2004-2006.
|
||||
// (C) Copyright Ion Gaztanaga 2006-2013.
|
||||
// (C) Copyright Ion Gaztanaga 2006-2021.
|
||||
// (C) Copyright Daniel Steck 2021
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
@@ -18,6 +19,7 @@
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include "test_macros.hpp"
|
||||
#include "test_container.hpp"
|
||||
#include <boost/next_prior.hpp>
|
||||
|
||||
namespace boost{
|
||||
namespace intrusive{
|
||||
@@ -40,6 +42,9 @@ struct test_generic_assoc
|
||||
static void test_root(value_cont_type&);
|
||||
static void test_clone(value_cont_type&);
|
||||
static void test_insert_erase_burst();
|
||||
static void test_swap_nodes();
|
||||
template <class Assoc>
|
||||
static void test_perfect_binary_tree_of_height_2(value_cont_type &values, Assoc &assoc);
|
||||
static void test_container_from_end(value_cont_type&, detail::true_type);
|
||||
static void test_container_from_end(value_cont_type&, detail::false_type) {}
|
||||
static void test_splay_up(value_cont_type&, detail::true_type);
|
||||
@@ -130,6 +135,226 @@ void test_generic_assoc<ContainerDefiner>::test_insert_erase_burst()
|
||||
}
|
||||
}
|
||||
|
||||
// Perfect binary tree of height 2
|
||||
// 3 |
|
||||
// / \ |
|
||||
// 1 5 |
|
||||
// / \ / \ |
|
||||
// 0 2 4 6 |
|
||||
template<class ContainerDefiner>
|
||||
template <class Assoc>
|
||||
void test_generic_assoc<ContainerDefiner>::test_perfect_binary_tree_of_height_2
|
||||
(value_cont_type &values, Assoc &assoc)
|
||||
{
|
||||
//value_cont_type values;
|
||||
const std::size_t MaxValues = 7;
|
||||
BOOST_TEST(values.size() == MaxValues);
|
||||
for(std::size_t i = 0; i != MaxValues; ++i){
|
||||
(&values[i])->value_ = i;
|
||||
}
|
||||
|
||||
typedef typename Assoc::iterator iterator;
|
||||
|
||||
BOOST_TEST( assoc.empty() );
|
||||
assoc.clear();
|
||||
|
||||
const iterator it3 = assoc.insert_before(assoc.end(), values[3]);
|
||||
const iterator it1 = assoc.insert_before(it3, values[1]);
|
||||
const iterator it5 = assoc.insert_before(assoc.end(), values[5]);
|
||||
assoc.insert_before(it1, values[0]);
|
||||
assoc.insert_before(it3, values[2]);
|
||||
assoc.insert_before(it5, values[4]);
|
||||
assoc.insert_before(assoc.end(), values[6]);
|
||||
}
|
||||
|
||||
|
||||
template<class ContainerDefiner>
|
||||
void test_generic_assoc<ContainerDefiner>::test_swap_nodes()
|
||||
{
|
||||
// Perfect binary tree of height 2
|
||||
// 3 |
|
||||
// / \ |
|
||||
// 1 5 |
|
||||
// / \ / \ |
|
||||
// 0 2 4 6 |
|
||||
|
||||
typedef typename ContainerDefiner::template container
|
||||
<>::type assoc_type;
|
||||
typedef typename assoc_type::value_traits value_traits_t;
|
||||
typedef typename assoc_type::node_algorithms node_algorithms_t;
|
||||
const std::size_t MaxValues = 7;
|
||||
|
||||
{ //Unrelated swap
|
||||
value_cont_type values(MaxValues);
|
||||
assoc_type testset;
|
||||
test_perfect_binary_tree_of_height_2(values, testset);
|
||||
|
||||
node_algorithms_t::swap_nodes
|
||||
( value_traits_t::to_node_ptr(values[0])
|
||||
, value_traits_t::to_node_ptr(values[4])
|
||||
);
|
||||
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[4]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[1]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[2]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[0]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) );
|
||||
|
||||
node_algorithms_t::swap_nodes
|
||||
( value_traits_t::to_node_ptr(values[4])
|
||||
, value_traits_t::to_node_ptr(values[0])
|
||||
);
|
||||
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[0]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[1]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[2]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) );
|
||||
|
||||
testset.check();
|
||||
}
|
||||
|
||||
{ //sibling leaf nodes
|
||||
value_cont_type values(MaxValues);
|
||||
assoc_type testset;
|
||||
test_perfect_binary_tree_of_height_2(values, testset);
|
||||
|
||||
node_algorithms_t::swap_nodes
|
||||
( value_traits_t::to_node_ptr(values[0])
|
||||
, value_traits_t::to_node_ptr(values[2])
|
||||
);
|
||||
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[2]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[1]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[0]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) );
|
||||
|
||||
node_algorithms_t::swap_nodes
|
||||
( value_traits_t::to_node_ptr(values[0])
|
||||
, value_traits_t::to_node_ptr(values[2])
|
||||
);
|
||||
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[0]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[1]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[2]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) );
|
||||
|
||||
testset.check();
|
||||
}
|
||||
|
||||
{ //sibling nodes
|
||||
value_cont_type values(MaxValues);
|
||||
assoc_type testset;
|
||||
test_perfect_binary_tree_of_height_2(values, testset);
|
||||
|
||||
node_algorithms_t::swap_nodes
|
||||
( value_traits_t::to_node_ptr(values[1])
|
||||
, value_traits_t::to_node_ptr(values[5])
|
||||
);
|
||||
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[0]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[5]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[2]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[1]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) );
|
||||
|
||||
node_algorithms_t::swap_nodes
|
||||
( value_traits_t::to_node_ptr(values[1])
|
||||
, value_traits_t::to_node_ptr(values[5])
|
||||
);
|
||||
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[0]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[1]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[2]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) );
|
||||
|
||||
testset.check();
|
||||
}
|
||||
|
||||
{ //left child
|
||||
value_cont_type values(MaxValues);
|
||||
assoc_type testset;
|
||||
test_perfect_binary_tree_of_height_2(values, testset);
|
||||
|
||||
node_algorithms_t::swap_nodes
|
||||
( value_traits_t::to_node_ptr(values[0])
|
||||
, value_traits_t::to_node_ptr(values[1])
|
||||
);
|
||||
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[1]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[0]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[2]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) );
|
||||
|
||||
node_algorithms_t::swap_nodes
|
||||
( value_traits_t::to_node_ptr(values[0])
|
||||
, value_traits_t::to_node_ptr(values[1])
|
||||
);
|
||||
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[0]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[1]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[2]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) );
|
||||
|
||||
testset.check();
|
||||
}
|
||||
|
||||
{ //right child
|
||||
value_cont_type values(MaxValues);
|
||||
assoc_type testset;
|
||||
test_perfect_binary_tree_of_height_2(values, testset);
|
||||
|
||||
node_algorithms_t::swap_nodes
|
||||
( value_traits_t::to_node_ptr(values[1])
|
||||
, value_traits_t::to_node_ptr(values[2])
|
||||
);
|
||||
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[0]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[2]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[1]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) );
|
||||
|
||||
node_algorithms_t::swap_nodes
|
||||
( value_traits_t::to_node_ptr(values[1])
|
||||
, value_traits_t::to_node_ptr(values[2])
|
||||
);
|
||||
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 0) == &values[0]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 1) == &values[1]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 2) == &values[2]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 3) == &values[3]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 4) == &values[4]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 5) == &values[5]) );
|
||||
BOOST_TEST( (&*boost::next(testset.begin(), 6) == &values[6]) );
|
||||
|
||||
testset.check();
|
||||
}
|
||||
}
|
||||
|
||||
template<class ContainerDefiner>
|
||||
void test_generic_assoc<ContainerDefiner>::test_all(value_cont_type& values)
|
||||
{
|
||||
@@ -143,6 +368,7 @@ void test_generic_assoc<ContainerDefiner>::test_all(value_cont_type& values)
|
||||
test_rebalance(values, detail::bool_< has_rebalance< assoc_type >::value >());
|
||||
test_insert_before(values, detail::bool_< has_insert_before< assoc_type >::value >());
|
||||
test_insert_erase_burst();
|
||||
test_swap_nodes();
|
||||
test_container_from_iterator(values, detail::bool_< assoc_type::has_container_from_iterator >());
|
||||
}
|
||||
|
||||
|
||||
@@ -1,352 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// (C) Copyright Daniel Steck 2021
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
// See http://www.boost.org/libs/intrusive for documentation.
|
||||
//
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
#include <boost/intrusive/rbtree.hpp>
|
||||
#include <boost/next_prior.hpp>
|
||||
|
||||
#include <cassert>
|
||||
#include <vector>
|
||||
|
||||
namespace {
|
||||
|
||||
struct Node : boost::intrusive::set_base_hook<> {};
|
||||
|
||||
typedef boost::intrusive::rbtree<Node> Tree;
|
||||
typedef typename Tree::node_traits NodeTraits;
|
||||
|
||||
NodeTraits::node_ptr get_parent(const Node& node) {
|
||||
return NodeTraits::get_parent(node.this_ptr());
|
||||
}
|
||||
|
||||
NodeTraits::node_ptr get_left(const Node& node) {
|
||||
return NodeTraits::get_left(node.this_ptr());
|
||||
}
|
||||
|
||||
NodeTraits::node_ptr get_right(const Node& node) {
|
||||
return NodeTraits::get_right(node.this_ptr());
|
||||
}
|
||||
|
||||
void perfect_binary_tree_of_height_2(std::vector<Node>& node_buffer, Tree& tree) {
|
||||
// Perfect binary tree of height 2
|
||||
// 3
|
||||
// ╱ ╲
|
||||
// 1 5
|
||||
// ╱ ╲ ╱ ╲
|
||||
// 0 2 4 6
|
||||
assert(node_buffer.size() == 7);
|
||||
|
||||
const Tree::iterator it3 = tree.insert_before(tree.end(), node_buffer[3]);
|
||||
const Tree::iterator it1 = tree.insert_before(it3, node_buffer[1]);
|
||||
const Tree::iterator it5 = tree.insert_before(tree.end(), node_buffer[5]);
|
||||
tree.insert_before(it1, node_buffer[0]);
|
||||
tree.insert_before(it3, node_buffer[2]);
|
||||
tree.insert_before(it5, node_buffer[4]);
|
||||
tree.insert_before(tree.end(), node_buffer[6]);
|
||||
|
||||
// Make sure we got the tree we expected
|
||||
assert(get_parent(node_buffer[0]) == node_buffer[1].this_ptr());
|
||||
assert(get_left(node_buffer[0]) == NULL);
|
||||
assert(get_right(node_buffer[0]) == NULL);
|
||||
assert(get_parent(node_buffer[1]) == node_buffer[3].this_ptr());
|
||||
assert(get_left(node_buffer[1]) == node_buffer[0].this_ptr());
|
||||
assert(get_right(node_buffer[1]) == node_buffer[2].this_ptr());
|
||||
assert(get_parent(node_buffer[2]) == node_buffer[1].this_ptr());
|
||||
assert(get_left(node_buffer[2]) == NULL);
|
||||
assert(get_right(node_buffer[2]) == NULL);
|
||||
assert(get_left(node_buffer[3]) == node_buffer[1].this_ptr());
|
||||
assert(get_right(node_buffer[3]) == node_buffer[5].this_ptr());
|
||||
assert(get_parent(node_buffer[4]) == node_buffer[5].this_ptr());
|
||||
assert(get_left(node_buffer[4]) == NULL);
|
||||
assert(get_right(node_buffer[4]) == NULL);
|
||||
assert(get_parent(node_buffer[5]) == node_buffer[3].this_ptr());
|
||||
assert(get_left(node_buffer[5]) == node_buffer[4].this_ptr());
|
||||
assert(get_right(node_buffer[5]) == node_buffer[6].this_ptr());
|
||||
assert(get_parent(node_buffer[6]) == node_buffer[5].this_ptr());
|
||||
assert(get_left(node_buffer[6]) == NULL);
|
||||
assert(get_right(node_buffer[6]) == NULL);
|
||||
}
|
||||
|
||||
// Test that swaps node_buffer 0 and 4 and verifies the results
|
||||
struct SwapUnrelatedLeafNodesTest {
|
||||
std::vector<Node>& node_buffer;
|
||||
Tree& tree;
|
||||
|
||||
SwapUnrelatedLeafNodesTest(std::vector<Node>& node_buffer, Tree& tree)
|
||||
: node_buffer(node_buffer), tree(tree) {}
|
||||
|
||||
void check() {
|
||||
assert(&*boost::next(tree.begin(), 0) == &node_buffer[4]);
|
||||
assert(&*boost::next(tree.begin(), 1) == &node_buffer[1]);
|
||||
assert(&*boost::next(tree.begin(), 2) == &node_buffer[2]);
|
||||
assert(&*boost::next(tree.begin(), 3) == &node_buffer[3]);
|
||||
assert(&*boost::next(tree.begin(), 4) == &node_buffer[0]);
|
||||
assert(&*boost::next(tree.begin(), 5) == &node_buffer[5]);
|
||||
assert(&*boost::next(tree.begin(), 6) == &node_buffer[6]);
|
||||
assert(get_parent(node_buffer[0]) == node_buffer[5].this_ptr());
|
||||
assert(get_left(node_buffer[0]) == NULL);
|
||||
assert(get_right(node_buffer[0]) == NULL);
|
||||
assert(get_left(node_buffer[1]) == node_buffer[4].this_ptr());
|
||||
assert(get_right(node_buffer[1]) == node_buffer[2].this_ptr());
|
||||
assert(get_parent(node_buffer[4]) == node_buffer[1].this_ptr());
|
||||
assert(get_left(node_buffer[4]) == NULL);
|
||||
assert(get_right(node_buffer[4]) == NULL);
|
||||
assert(get_left(node_buffer[5]) == node_buffer[0].this_ptr());
|
||||
assert(get_right(node_buffer[5]) == node_buffer[6].this_ptr());
|
||||
}
|
||||
|
||||
void swap04() {
|
||||
node_buffer[0].swap_nodes(node_buffer[4]);
|
||||
}
|
||||
|
||||
void swap40() {
|
||||
node_buffer[4].swap_nodes(node_buffer[0]);
|
||||
}
|
||||
};
|
||||
|
||||
// Test that swaps node_buffer 0 and 2 and verifies the results
|
||||
struct SwapSiblingLeafNodesTest {
|
||||
std::vector<Node>& node_buffer;
|
||||
Tree& tree;
|
||||
|
||||
SwapSiblingLeafNodesTest(std::vector<Node>& node_buffer, Tree& tree)
|
||||
: node_buffer(node_buffer), tree(tree) {}
|
||||
|
||||
void check() {
|
||||
assert(&*boost::next(tree.begin(), 0) == &node_buffer[2]);
|
||||
assert(&*boost::next(tree.begin(), 1) == &node_buffer[1]);
|
||||
assert(&*boost::next(tree.begin(), 2) == &node_buffer[0]);
|
||||
assert(&*boost::next(tree.begin(), 3) == &node_buffer[3]);
|
||||
assert(&*boost::next(tree.begin(), 4) == &node_buffer[4]);
|
||||
assert(&*boost::next(tree.begin(), 5) == &node_buffer[5]);
|
||||
assert(&*boost::next(tree.begin(), 6) == &node_buffer[6]);
|
||||
assert(get_parent(node_buffer[0]) == node_buffer[1].this_ptr());
|
||||
assert(get_left(node_buffer[0]) == NULL);
|
||||
assert(get_right(node_buffer[0]) == NULL);
|
||||
assert(get_left(node_buffer[1]) == node_buffer[2].this_ptr());
|
||||
assert(get_right(node_buffer[1]) == node_buffer[0].this_ptr());
|
||||
assert(get_parent(node_buffer[2]) == node_buffer[1].this_ptr());
|
||||
assert(get_left(node_buffer[2]) == NULL);
|
||||
assert(get_right(node_buffer[2]) == NULL);
|
||||
}
|
||||
|
||||
void swap02() {
|
||||
node_buffer[0].swap_nodes(node_buffer[2]);
|
||||
}
|
||||
|
||||
void swap20() {
|
||||
node_buffer[2].swap_nodes(node_buffer[0]);
|
||||
}
|
||||
};
|
||||
|
||||
// Test that swaps node_buffer 1 and 5 and verifies the results
|
||||
struct SwapSiblingNodesTest {
|
||||
std::vector<Node>& node_buffer;
|
||||
Tree& tree;
|
||||
|
||||
SwapSiblingNodesTest(std::vector<Node>& node_buffer, Tree& tree)
|
||||
: node_buffer(node_buffer), tree(tree) {}
|
||||
|
||||
void check() {
|
||||
assert(&*boost::next(tree.begin(), 0) == &node_buffer[0]);
|
||||
assert(&*boost::next(tree.begin(), 1) == &node_buffer[5]);
|
||||
assert(&*boost::next(tree.begin(), 2) == &node_buffer[2]);
|
||||
assert(&*boost::next(tree.begin(), 3) == &node_buffer[3]);
|
||||
assert(&*boost::next(tree.begin(), 4) == &node_buffer[4]);
|
||||
assert(&*boost::next(tree.begin(), 5) == &node_buffer[1]);
|
||||
assert(&*boost::next(tree.begin(), 6) == &node_buffer[6]);
|
||||
assert(get_parent(node_buffer[0]) == node_buffer[5].this_ptr());
|
||||
assert(get_parent(node_buffer[1]) == node_buffer[3].this_ptr());
|
||||
assert(get_left(node_buffer[1]) == node_buffer[4].this_ptr());
|
||||
assert(get_right(node_buffer[1]) == node_buffer[6].this_ptr());
|
||||
assert(get_parent(node_buffer[2]) == node_buffer[5].this_ptr());
|
||||
assert(get_left(node_buffer[3]) == node_buffer[5].this_ptr());
|
||||
assert(get_right(node_buffer[3]) == node_buffer[1].this_ptr());
|
||||
assert(get_parent(node_buffer[4]) == node_buffer[1].this_ptr());
|
||||
assert(get_parent(node_buffer[5]) == node_buffer[3].this_ptr());
|
||||
assert(get_left(node_buffer[5]) == node_buffer[0].this_ptr());
|
||||
assert(get_right(node_buffer[5]) == node_buffer[2].this_ptr());
|
||||
assert(get_parent(node_buffer[6]) == node_buffer[1].this_ptr());
|
||||
}
|
||||
|
||||
void swap15() {
|
||||
node_buffer[1].swap_nodes(node_buffer[5]);
|
||||
}
|
||||
|
||||
void swap51() {
|
||||
node_buffer[5].swap_nodes(node_buffer[1]);
|
||||
}
|
||||
};
|
||||
|
||||
// Test that swaps node_buffer 0 and 1 and verifies the results
|
||||
struct SwapWithLeftChildTest {
|
||||
std::vector<Node>& node_buffer;
|
||||
Tree& tree;
|
||||
|
||||
SwapWithLeftChildTest(std::vector<Node>& node_buffer, Tree& tree)
|
||||
: node_buffer(node_buffer), tree(tree) {}
|
||||
|
||||
void check() {
|
||||
assert(&*boost::next(tree.begin(), 0) == &node_buffer[1]);
|
||||
assert(&*boost::next(tree.begin(), 1) == &node_buffer[0]);
|
||||
assert(&*boost::next(tree.begin(), 2) == &node_buffer[2]);
|
||||
assert(&*boost::next(tree.begin(), 3) == &node_buffer[3]);
|
||||
assert(&*boost::next(tree.begin(), 4) == &node_buffer[4]);
|
||||
assert(&*boost::next(tree.begin(), 5) == &node_buffer[5]);
|
||||
assert(&*boost::next(tree.begin(), 6) == &node_buffer[6]);
|
||||
assert(get_parent(node_buffer[0]) == node_buffer[3].this_ptr());
|
||||
assert(get_left(node_buffer[0]) == node_buffer[1].this_ptr());
|
||||
assert(get_right(node_buffer[0]) == node_buffer[2].this_ptr());
|
||||
assert(get_parent(node_buffer[1]) == node_buffer[0].this_ptr());
|
||||
assert(get_left(node_buffer[1]) == NULL);
|
||||
assert(get_right(node_buffer[1]) == NULL);
|
||||
assert(get_parent(node_buffer[2]) == node_buffer[0].this_ptr());
|
||||
assert(get_left(node_buffer[2]) == NULL);
|
||||
assert(get_right(node_buffer[2]) == NULL);
|
||||
}
|
||||
|
||||
void swap01() {
|
||||
node_buffer[0].swap_nodes(node_buffer[1]);
|
||||
}
|
||||
|
||||
void swap10() {
|
||||
node_buffer[1].swap_nodes(node_buffer[0]);
|
||||
}
|
||||
};
|
||||
|
||||
// Test that swaps node_buffer 1 and 2 and verifies the results
|
||||
struct SwapWithRightChildTest {
|
||||
std::vector<Node>& node_buffer;
|
||||
Tree& tree;
|
||||
|
||||
SwapWithRightChildTest(std::vector<Node>& node_buffer, Tree& tree)
|
||||
: node_buffer(node_buffer), tree(tree) {}
|
||||
|
||||
void check() {
|
||||
assert(&*boost::next(tree.begin(), 0) == &node_buffer[0]);
|
||||
assert(&*boost::next(tree.begin(), 1) == &node_buffer[2]);
|
||||
assert(&*boost::next(tree.begin(), 2) == &node_buffer[1]);
|
||||
assert(&*boost::next(tree.begin(), 3) == &node_buffer[3]);
|
||||
assert(&*boost::next(tree.begin(), 4) == &node_buffer[4]);
|
||||
assert(&*boost::next(tree.begin(), 5) == &node_buffer[5]);
|
||||
assert(&*boost::next(tree.begin(), 6) == &node_buffer[6]);
|
||||
assert(get_parent(node_buffer[0]) == node_buffer[2].this_ptr());
|
||||
assert(get_left(node_buffer[0]) == NULL);
|
||||
assert(get_right(node_buffer[0]) == NULL);
|
||||
assert(get_parent(node_buffer[1]) == node_buffer[2].this_ptr());
|
||||
assert(get_left(node_buffer[1]) == NULL);
|
||||
assert(get_right(node_buffer[1]) == NULL);
|
||||
assert(get_parent(node_buffer[2]) == node_buffer[3].this_ptr());
|
||||
assert(get_left(node_buffer[2]) == node_buffer[0].this_ptr());
|
||||
assert(get_right(node_buffer[2]) == node_buffer[1].this_ptr());
|
||||
}
|
||||
|
||||
void swap12() {
|
||||
node_buffer[1].swap_nodes(node_buffer[2]);
|
||||
}
|
||||
|
||||
void swap21() {
|
||||
node_buffer[2].swap_nodes(node_buffer[1]);
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
int main() {
|
||||
{ // SwapUnrelatedLeafNodesTest 0 -> 4
|
||||
std::vector<Node> node_buffer(7);
|
||||
Tree tree;
|
||||
perfect_binary_tree_of_height_2(node_buffer, tree);
|
||||
SwapUnrelatedLeafNodesTest test(node_buffer, tree);
|
||||
test.swap04();
|
||||
test.check();
|
||||
}
|
||||
|
||||
{ // SwapUnrelatedLeafNodesTest 0 <- 4
|
||||
std::vector<Node> node_buffer(7);
|
||||
Tree tree;
|
||||
perfect_binary_tree_of_height_2(node_buffer, tree);
|
||||
SwapUnrelatedLeafNodesTest test(node_buffer, tree);
|
||||
test.swap40();
|
||||
test.check();
|
||||
}
|
||||
|
||||
{ // SwapSiblingLeafNodesTest 0 -> 2
|
||||
std::vector<Node> node_buffer(7);
|
||||
Tree tree;
|
||||
perfect_binary_tree_of_height_2(node_buffer, tree);
|
||||
SwapSiblingLeafNodesTest test(node_buffer, tree);
|
||||
test.swap02();
|
||||
test.check();
|
||||
}
|
||||
|
||||
{ // SwapSiblingLeafNodesTest 0 <- 2
|
||||
std::vector<Node> node_buffer(7);
|
||||
Tree tree;
|
||||
perfect_binary_tree_of_height_2(node_buffer, tree);
|
||||
SwapSiblingLeafNodesTest test(node_buffer, tree);
|
||||
test.swap20();
|
||||
test.check();
|
||||
}
|
||||
|
||||
{ // SwapSiblingNodesTest 1 -> 5
|
||||
std::vector<Node> node_buffer(7);
|
||||
Tree tree;
|
||||
perfect_binary_tree_of_height_2(node_buffer, tree);
|
||||
SwapSiblingNodesTest test(node_buffer, tree);
|
||||
test.swap15();
|
||||
test.check();
|
||||
}
|
||||
|
||||
{ // SwapSiblingNodesTest 1 <- 5
|
||||
std::vector<Node> node_buffer(7);
|
||||
Tree tree;
|
||||
perfect_binary_tree_of_height_2(node_buffer, tree);
|
||||
SwapSiblingNodesTest test(node_buffer, tree);
|
||||
test.swap51();
|
||||
test.check();
|
||||
}
|
||||
|
||||
{ // SwapWithLeftChildTest 0 -> 1
|
||||
std::vector<Node> node_buffer(7);
|
||||
Tree tree;
|
||||
perfect_binary_tree_of_height_2(node_buffer, tree);
|
||||
SwapWithLeftChildTest test(node_buffer, tree);
|
||||
test.swap01();
|
||||
test.check();
|
||||
}
|
||||
|
||||
{ // SwapWithLeftChildTest 0 <- 1
|
||||
std::vector<Node> node_buffer(7);
|
||||
Tree tree;
|
||||
perfect_binary_tree_of_height_2(node_buffer, tree);
|
||||
SwapWithLeftChildTest test(node_buffer, tree);
|
||||
test.swap10();
|
||||
test.check();
|
||||
}
|
||||
|
||||
{ // SwapWithRightChildTest 1 -> 2
|
||||
std::vector<Node> node_buffer(7);
|
||||
Tree tree;
|
||||
perfect_binary_tree_of_height_2(node_buffer, tree);
|
||||
SwapWithRightChildTest test(node_buffer, tree);
|
||||
test.swap12();
|
||||
test.check();
|
||||
}
|
||||
|
||||
{ // SwapWithRightChildTest 1 <- 2
|
||||
std::vector<Node> node_buffer(7);
|
||||
Tree tree;
|
||||
perfect_binary_tree_of_height_2(node_buffer, tree);
|
||||
SwapWithRightChildTest test(node_buffer, tree);
|
||||
test.swap21();
|
||||
test.check();
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user