feedc0de/boost_intrusive
1
0 Fork 0
forked from boostorg/intrusive
Code Pull Requests Activity

Added scapegoat trees and an option to store the hash value in the hook for unordered containers

Browse Source 
[SVN r41196]
This commit is contained in:
Ion Gaztañaga committed 2007-11-18 10:44:56 +00:00
1 parent f4992b8b14
commit 15de4da451
44 files changed
+1987 -1958
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

test/avl_multiset_test.cpp
+66 -342
View File
@@ -15,296 +15,47 @@
#include <boost/intrusive/detail/pointer_to_other.hpp>
#include "itestvalue.hpp"
#include "smart_ptr.hpp"
#include "common_functors.hpp"
#include <vector>
#include <boost/detail/lightweight_test.hpp>
#include "test_macros.hpp"
#include "test_container.hpp"
#include <set>
#include "generic_multiset_test.hpp"
namespace boost { namespace intrusive { namespace test {
template<class T, class O1, class O2, class O3, class O4>
struct has_const_overloads<boost::intrusive::avl_multiset<T, O1, O2, O3, O4> >
template< class ValueType
, class Option1 = boost::intrusive::none
, class Option2 = boost::intrusive::none
, class Option3 = boost::intrusive::none
>
struct GetContainer
{
static const bool value = false;
typedef boost::intrusive::avl_multiset
< ValueType
, Option1
, Option2
, Option3
> type;
};
}}}
using namespace boost::intrusive;
template<class ValueTraits>
struct test_avl_multiset
{
typedef typename ValueTraits::value_type value_type;
static void test_all (std::vector<value_type>& values);
static void test_sort(std::vector<value_type>& values);
static void test_insert(std::vector<value_type>& values);
static void test_swap(std::vector<value_type>& values);
static void test_find(std::vector<value_type>& values);
static void test_impl();
static void test_clone(std::vector<value_type>& values);
static void test_container_from_end(std::vector<value_type>& values);
};
template<class ValueTraits>
void test_avl_multiset<ValueTraits>::test_all
(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef avl_multiset
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> avl_multiset_type;
{
avl_multiset_type testset(values.begin(), values.end());
test::test_container(testset);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_common_unordered_and_associative_container(testset, values);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_associative_container(testset, values);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_non_unique_container(testset, values);
}
test_sort(values);
test_insert(values);
test_swap(values);
test_find(values);
test_impl();
test_clone(values);
test_container_from_end(values);
}
//test case due to an error in tree implementation:
template<class ValueTraits>
void test_avl_multiset<ValueTraits>::test_impl()
{
typedef typename ValueTraits::value_type value_type;
std::vector<value_type> values (5);
for (int i = 0; i < 5; ++i)
values[i].value_ = i;
typedef typename ValueTraits::value_type value_type;
typedef avl_multiset
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> multiset_type;
multiset_type testset;
for (int i = 0; i < 5; ++i)
testset.insert (values[i]);
testset.erase (testset.iterator_to (values[0]));
testset.erase (testset.iterator_to (values[1]));
testset.insert (values[1]);
testset.erase (testset.iterator_to (values[2]));
testset.erase (testset.iterator_to (values[3]));
}
//test: constructor, iterator, clear, reverse_iterator, front, back, size:
template<class ValueTraits>
void test_avl_multiset<ValueTraits>::test_sort
(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef avl_multiset
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> multiset_type;
multiset_type testset1 (values.begin(), values.end());
{ int init_values [] = { 1, 2, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
testset1.clear();
BOOST_TEST (testset1.empty());
typedef avl_multiset
<value_type
, compare<even_odd>
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> multiset_type2;
multiset_type2 testset2 (&values[0], &values[0] + 6);
{ int init_values [] = { 5, 3, 1, 4, 2, 2 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset2.rbegin() ); }
BOOST_TEST (testset2.begin()->value_ == 2);
BOOST_TEST (testset2.rbegin()->value_ == 5);
}
//test: insert, const_iterator, const_reverse_iterator, erase, iterator_to:
template<class ValueTraits>
void test_avl_multiset<ValueTraits>::test_insert
(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef avl_multiset
< value_type
, value_traits<ValueTraits>
, size_type<std::size_t>
, constant_time_size<value_type::constant_time_size>
> multiset_type;
multiset_type testset;
testset.insert(&values[0] + 2, &values[0] + 5);
{ int init_values [] = { 1, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset.begin() ); }
typename multiset_type::iterator i = testset.begin();
BOOST_TEST (i->value_ == 1);
i = testset.insert (i, values[0]);
BOOST_TEST (&*i == &values[0]);
{ int init_values [] = { 5, 4, 3, 1 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset.rbegin() ); }
i = testset.iterator_to (values[2]);
BOOST_TEST (&*i == &values[2]);
i = multiset_type::s_iterator_to (values[2]);
BOOST_TEST (&*i == &values[2]);
testset.erase(i);
{ int init_values [] = { 1, 3, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset.begin() ); }
}
//test: insert (seq-version), swap, erase (seq-version), size:
template<class ValueTraits>
void test_avl_multiset<ValueTraits>::test_swap
(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef avl_multiset
< value_type
, value_traits<ValueTraits>
, size_type<std::size_t>
, constant_time_size<value_type::constant_time_size>
> multiset_type;
multiset_type testset1 (&values[0], &values[0] + 2);
multiset_type testset2;
testset2.insert (&values[0] + 2, &values[0] + 6);
{ int init_values [] = { 1, 2, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset2.begin() ); }
{ int init_values [] = { 2, 3 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
testset1.swap (testset2);
{ int init_values [] = { 1, 2, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
{ int init_values [] = { 2, 3 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset2.begin() ); }
testset1.erase (testset1.iterator_to(values[5]), testset1.end());
BOOST_TEST (testset1.size() == 1);
BOOST_TEST (&*testset1.begin() == &values[3]);
}
//test: find, equal_range (lower_bound, upper_bound):
template<class ValueTraits>
void test_avl_multiset<ValueTraits>::test_find
(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef avl_multiset
< value_type
, value_traits<ValueTraits>
, size_type<std::size_t>
, constant_time_size<value_type::constant_time_size>
> multiset_type;
multiset_type testset (values.begin(), values.end());
typedef typename multiset_type::iterator iterator;
value_type cmp_val;
cmp_val.value_ = 2;
iterator i = testset.find (cmp_val);
BOOST_TEST (i->value_ == 2);
BOOST_TEST ((++i)->value_ == 2);
std::pair<iterator,iterator> range = testset.equal_range (cmp_val);
BOOST_TEST (range.first->value_ == 2);
BOOST_TEST (range.second->value_ == 3);
BOOST_TEST (std::distance (range.first, range.second) == 2);
cmp_val.value_ = 7;
BOOST_TEST (testset.find (cmp_val) == testset.end());
}
template<class ValueTraits>
void test_avl_multiset<ValueTraits>::test_clone
(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef avl_multiset
< value_type
, value_traits<ValueTraits>
, size_type<std::size_t>
, constant_time_size<value_type::constant_time_size>
> multiset_type;
multiset_type testmultiset1 (&values[0], &values[0] + values.size());
multiset_type testmultiset2;
testmultiset2.clone_from(testmultiset1, test::new_cloner<value_type>(), test::delete_disposer<value_type>());
BOOST_TEST (testmultiset2 == testmultiset1);
testmultiset2.clear_and_dispose(test::delete_disposer<value_type>());
BOOST_TEST (testmultiset2.empty());
}
template<class ValueTraits>
void test_avl_multiset<ValueTraits>::test_container_from_end
(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef avl_multiset
< value_type
, value_traits<ValueTraits>
, size_type<std::size_t>
, constant_time_size<value_type::constant_time_size>
> multiset_type;
multiset_type testmultiset (&values[0], &values[0] + values.size());
BOOST_TEST (testmultiset == multiset_type::container_from_end_iterator(testmultiset.end()));
BOOST_TEST (testmultiset == multiset_type::container_from_end_iterator(testmultiset.cend()));
}
template<class VoidPointer, bool constant_time_size>
class test_main_template
{
public:
int operator()()
{
for(int n = 0; n < 2; ++n){
typedef testvalue<VoidPointer, constant_time_size> value_type;
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
std::vector<testvalue<VoidPointer, constant_time_size> > data (6);
for (int i = 0; i < 6; ++i)
data[i].value_ = random_init[i];
using namespace boost::intrusive;
typedef testvalue<VoidPointer, constant_time_size> value_type;
test_avl_multiset < typename detail::get_base_value_traits
< value_type
, typename value_type::avl_set_base_hook_t
>::type
>::test_all(data);
test_avl_multiset < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::avl_set_member_hook_t
, &value_type::avl_set_node_
>
>::type
>::test_all(data);
}
test::test_generic_multiset < typename detail::get_base_value_traits
< value_type
, typename value_type::avl_set_base_hook_t
>::type
, GetContainer
>::test_all();
test::test_generic_multiset < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::avl_set_member_hook_t
, &value_type::avl_set_node_
>
>::type
, GetContainer
>::test_all();
return 0;
}
};
@@ -315,80 +66,53 @@ class test_main_template<VoidPointer, false>
public:
int operator()()
{
for(int n = 0; n < 2; ++n){
typedef testvalue<VoidPointer, false> value_type;
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
std::vector<testvalue<VoidPointer, false> > data (6);
for (int i = 0; i < 6; ++i)
data[i].value_ = random_init[i];
using namespace boost::intrusive;
typedef testvalue<VoidPointer, false> value_type;
test_avl_multiset < typename detail::get_base_value_traits
< value_type
, typename value_type::avl_set_base_hook_t
>::type
>::test_all(data);
test::test_generic_multiset < typename detail::get_base_value_traits
< value_type
, typename value_type::avl_set_base_hook_t
>::type
, GetContainer
>::test_all();
test_avl_multiset < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::avl_set_member_hook_t
, &value_type::avl_set_node_
>
>::type
>::test_all(data);
test::test_generic_multiset < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::avl_set_member_hook_t
, &value_type::avl_set_node_
>
>::type
, GetContainer
>::test_all();
test_avl_multiset < typename detail::get_base_value_traits
< value_type
, typename value_type::avl_set_auto_base_hook_t
>::type
>::test_all(data);
test::test_generic_multiset < typename detail::get_base_value_traits
< value_type
, typename value_type::avl_set_auto_base_hook_t
>::type
, GetContainer
>::test_all();
test_avl_multiset < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::avl_set_auto_member_hook_t
, &value_type::avl_set_auto_node_
>
>::type
>::test_all(data);
}
test::test_generic_multiset < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::avl_set_auto_member_hook_t
, &value_type::avl_set_auto_node_
>
>::type
, GetContainer
>::test_all();
return 0;
}
};
//Explicit instantiations of non-counted classes
//template class multiset
// <set_base_raw, std::less<set_base_raw::value_type>, false>;
//template class multiset
// <set_member_raw, std::less<set_member_raw::value_type>, false>;
//template class multiset
// <set_auto_base_raw, std::less<set_auto_base_raw::value_type>, false>;
//template class multiset
// <set_auto_member_raw, std::less<set_auto_member_raw::value_type>, false>;
//template class multiset
// <set_base_smart, std::less<set_base_smart::value_type>, false>;
//template class multiset
// <set_member_smart, std::less<set_member_smart::value_type>, false>;
//template class multiset
// <set_auto_base_smart, std::less<set_auto_base_smart::value_type>, false>;
//template class multiset
// <set_auto_member_smart, std::less<set_auto_member_smart::value_type>, false>;
//Explicit instantiation of counted classes
//template class multiset
// <set_base_raw_t, std::less<set_base_raw_t::value_type>, true>;
//template class multiset
// <set_member_raw_t, std::less<set_member_raw_t::value_type>, true>;
//template class multiset
// <set_base_smart_t, std::less<set_base_smart_t::value_type>, true>;
//template class multiset
// <set_member_smart_t, std::less<set_member_smart_t::value_type>, true>;
int main( int, char* [] )
{
test_main_template<void*, false>()();
test_main_template<smart_ptr<void>, false>()();
test_main_template<boost::intrusive::smart_ptr<void>, false>()();
test_main_template<void*, true>()();
test_main_template<smart_ptr<void>, true>()();
test_main_template<boost::intrusive::smart_ptr<void>, true>()();
return boost::report_errors();
}
#include <boost/intrusive/detail/config_end.hpp>
test/avl_set_test.cpp
+39 -270
View File
@@ -1,6 +1,7 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2007.
// (C) Copyright Olaf Krzikalla 2004-2006.
// (C) Copyright Ion Gaztanaga 2006-2007.
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
@@ -11,284 +12,49 @@
/////////////////////////////////////////////////////////////////////////////
#include <boost/intrusive/detail/config_begin.hpp>
#include <boost/intrusive/avl_set.hpp>
#include <boost/intrusive/detail/pointer_to_other.hpp>
#include "itestvalue.hpp"
#include "smart_ptr.hpp"
#include "common_functors.hpp"
#include <vector>
#include <boost/detail/lightweight_test.hpp>
#include "test_macros.hpp"
#include "test_container.hpp"
#include <set>
#include "generic_set_test.hpp"
namespace boost { namespace intrusive { namespace test {
template<class T, class O1, class O2, class O3, class O4>
struct has_const_overloads<boost::intrusive::avl_set<T, O1, O2, O3, O4> >
template< class ValueType
, class Option1 = boost::intrusive::none
, class Option2 = boost::intrusive::none
, class Option3 = boost::intrusive::none
>
struct GetContainer
{
static const bool value = false;
typedef boost::intrusive::avl_set
< ValueType
, Option1
, Option2
, Option3
> type;
};
}}}
using namespace boost::intrusive;
template<class ValueTraits>
struct test_avl_set
{
typedef typename ValueTraits::value_type value_type;
static void test_all(std::vector<value_type>& values);
static void test_sort(std::vector<value_type>& values);
static void test_insert(std::vector<value_type>& values);
static void test_swap(std::vector<value_type>& values);
static void test_find(std::vector<value_type>& values);
static void test_impl();
static void test_clone(std::vector<value_type>& values);
static void test_container_from_end(std::vector<value_type>& values);
};
template<class ValueTraits>
void test_avl_set<ValueTraits>::test_all(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef avl_set
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> avl_set_type;
{
avl_set_type testset(values.begin(), values.end());
test::test_container(testset);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_common_unordered_and_associative_container(testset, values);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_associative_container(testset, values);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_unique_container(testset, values);
}
test_sort(values);
test_insert(values);
test_swap(values);
test_find(values);
test_impl();
test_clone(values);
test_container_from_end(values);
}
//test case due to an error in tree implementation:
template<class ValueTraits>
void test_avl_set<ValueTraits>::test_impl()
{
typedef typename ValueTraits::value_type value_type;
std::vector<value_type> values (5);
for (int i = 0; i < 5; ++i)
values[i].value_ = i;
typedef typename ValueTraits::value_type value_type;
typedef avl_set
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> avl_set_type;
avl_set_type testset;
for (int i = 0; i < 5; ++i)
testset.insert (values[i]);
testset.erase (testset.iterator_to (values[0]));
testset.erase (testset.iterator_to (values[1]));
testset.insert (values[1]);
testset.erase (testset.iterator_to (values[2]));
testset.erase (testset.iterator_to (values[3]));
}
//test: constructor, iterator, clear, reverse_iterator, front, back, size:
template<class ValueTraits>
void test_avl_set<ValueTraits>::test_sort(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef avl_set
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> avl_set_type;
avl_set_type testset1 (values.begin(), values.end());
{ int init_values [] = { 1, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
testset1.clear();
BOOST_TEST (testset1.empty());
typedef typename ValueTraits::value_type value_type;
typedef avl_set
< value_type
, compare<even_odd>
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> set_type2;
set_type2 testset2 (&values[0], &values[0] + 6);
{ int init_values [] = { 5, 3, 1, 4, 2 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset2.rbegin() ); }
BOOST_TEST (testset2.begin()->value_ == 2);
BOOST_TEST (testset2.rbegin()->value_ == 5);
}
//test: insert, const_iterator, const_reverse_iterator, erase, s_iterator_to:
template<class ValueTraits>
void test_avl_set<ValueTraits>::test_insert(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef avl_set
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> avl_set_type;
avl_set_type testset;
testset.insert(&values[0] + 2, &values[0] + 5);
const avl_set_type& const_testset = testset;
{ int init_values [] = { 1, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, const_testset.begin() ); }
typename avl_set_type::iterator i = testset.begin();
BOOST_TEST (i->value_ == 1);
i = testset.insert (i, values[0]);
BOOST_TEST (&*i == &values[0]);
{ int init_values [] = { 5, 4, 3, 1 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset.rbegin() ); }
i = testset.iterator_to (values[2]);
BOOST_TEST (&*i == &values[2]);
i = avl_set_type::s_iterator_to(values[2]);
BOOST_TEST (&*i == &values[2]);
testset.erase (i);
{ int init_values [] = { 1, 3, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset.begin() ); }
}
//test: insert (seq-version), swap, erase (seq-version), size:
template<class ValueTraits>
void test_avl_set<ValueTraits>::test_swap(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef avl_set
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> avl_set_type;
avl_set_type testset1 (&values[0], &values[0] + 2);
avl_set_type testset2;
testset2.insert (&values[0] + 2, &values[0] + 6);
testset1.swap (testset2);
{ int init_values [] = { 1, 2, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
{ int init_values [] = { 2, 3 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset2.begin() ); }
testset1.erase (testset1.iterator_to(values[5]), testset1.end());
BOOST_TEST (testset1.size() == 1);
// BOOST_TEST (&testset1.front() == &values[3]);
BOOST_TEST (&*testset1.begin() == &values[3]);
}
//test: find, equal_range (lower_bound, upper_bound):
template<class ValueTraits>
void test_avl_set<ValueTraits>::test_find(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef avl_set
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> avl_set_type;
avl_set_type testset (values.begin(), values.end());
typedef typename avl_set_type::iterator iterator;
value_type cmp_val;
cmp_val.value_ = 2;
iterator i = testset.find (cmp_val);
BOOST_TEST (i->value_ == 2);
BOOST_TEST ((++i)->value_ != 2);
std::pair<iterator,iterator> range = testset.equal_range (cmp_val);
BOOST_TEST (range.first->value_ == 2);
BOOST_TEST (range.second->value_ == 3);
BOOST_TEST (std::distance (range.first, range.second) == 1);
cmp_val.value_ = 7;
BOOST_TEST (testset.find (cmp_val) == testset.end());
}
template<class ValueTraits>
void test_avl_set<ValueTraits>
::test_clone(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef avl_set
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> avl_set_type;
avl_set_type testset1 (&values[0], &values[0] + values.size());
avl_set_type testset2;
testset2.clone_from(testset1, test::new_cloner<value_type>(), test::delete_disposer<value_type>());
BOOST_TEST (testset2 == testset1);
testset2.clear_and_dispose(test::delete_disposer<value_type>());
BOOST_TEST (testset2.empty());
}
template<class ValueTraits>
void test_avl_set<ValueTraits>
::test_container_from_end(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef avl_set
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> avl_set_type;
avl_set_type testset (&values[0], &values[0] + values.size());
BOOST_TEST (testset == avl_set_type::container_from_end_iterator(testset.end()));
BOOST_TEST (testset == avl_set_type::container_from_end_iterator(testset.cend()));
}
template<class VoidPointer, bool constant_time_size>
class test_main_template
{
public:
int operator()()
{
using namespace boost::intrusive;
typedef testvalue<VoidPointer, constant_time_size> value_type;
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
std::vector<testvalue<VoidPointer, constant_time_size> > data (6);
for (int i = 0; i < 6; ++i)
data[i].value_ = random_init[i];
test_avl_set < typename detail::get_base_value_traits
test::test_generic_set < typename detail::get_base_value_traits
< value_type
, typename value_type::avl_set_base_hook_t
>::type
>::test_all(data);
test_avl_set < typename detail::get_member_value_traits
, GetContainer
>::test_all();
test::test_generic_set < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::avl_set_member_hook_t
, &value_type::avl_set_node_
>
>::type
>::test_all(data);
, GetContainer
>::test_all();
return 0;
}
};
@@ -299,41 +65,42 @@ class test_main_template<VoidPointer, false>
public:
int operator()()
{
using namespace boost::intrusive;
typedef testvalue<VoidPointer, false> value_type;
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
std::vector<testvalue<VoidPointer, false> > data (6);
for (int i = 0; i < 6; ++i)
data[i].value_ = random_init[i];
test_avl_set < typename detail::get_base_value_traits
test::test_generic_set < typename detail::get_base_value_traits
< value_type
, typename value_type::avl_set_base_hook_t
>::type
>::test_all(data);
, GetContainer
>::test_all();
test_avl_set < typename detail::get_member_value_traits
test::test_generic_set < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::avl_set_member_hook_t
, &value_type::avl_set_node_
>
>::type
>::test_all(data);
, GetContainer
>::test_all();
test_avl_set < typename detail::get_base_value_traits
test::test_generic_set < typename detail::get_base_value_traits
< value_type
, typename value_type::avl_set_auto_base_hook_t
>::type
>::test_all(data);
, GetContainer
>::test_all();
test_avl_set < typename detail::get_member_value_traits
test::test_generic_set < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::avl_set_auto_member_hook_t
, &value_type::avl_set_auto_node_
>
>::type
>::test_all(data);
, GetContainer
>::test_all();
return 0;
}
@@ -341,10 +108,12 @@ class test_main_template<VoidPointer, false>
int main( int, char* [] )
{
test_main_template<void*, false>()();
test_main_template<smart_ptr<void>, false>()();
test_main_template<boost::intrusive::smart_ptr<void>, false>()();
test_main_template<void*, true>()();
test_main_template<smart_ptr<void>, true>()();
test_main_template<boost::intrusive::smart_ptr<void>, true>()();
return boost::report_errors();
}
#include <boost/intrusive/detail/config_end.hpp>
test/external_value_traits_test.cpp
+3 -4
View File
@@ -207,8 +207,7 @@ int main()
Rbtree &my_rbtree = static_cast<Rbtree &> (cont_holder);
Hash &my_hash = static_cast<Hash &> (cont_holder);
//Now insert them in the reverse order
//in the base hook intrusive list
//Now insert them in containers
for(MyClass * it(&values[0]), *itend(&values[NumElements])
; it != itend; ++it){
my_list.push_front(*it);
@@ -217,7 +216,7 @@ int main()
my_hash.insert_unique(*it);
}
//Now test lists
//Now test containers
{
List::const_iterator list_it (my_list.cbegin());
Slist::const_iterator slist_it (my_slist.cbegin());
@@ -225,7 +224,7 @@ int main()
Hash::const_iterator hash_it (my_hash.cbegin());
MyClass *it_val(&values[NumElements] - 1), *it_rbeg_val(&values[0]-1);
//Test the objects inserted in the base hook list
//Test inserted objects
for(; it_val != it_rbeg_val; --it_val, ++list_it, ++slist_it, ++rbtree_it){
if(&*list_it != &*it_val) return 1;
if(&*slist_it != &*it_val) return 1;
test/generic_assoc_test.hpp
+328
View File
@@ -0,0 +1,328 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Olaf Krzikalla 2004-2006.
// (C) Copyright Ion Gaztanaga 2006-2007.
//
// 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 <vector> //vector
#include <algorithm> //sort, random_shuffle
#include <boost/intrusive/detail/config_begin.hpp>
#include "common_functors.hpp"
#include <boost/intrusive/options.hpp>
#include <boost/detail/lightweight_test.hpp>
#include "test_macros.hpp"
#include "test_container.hpp"
namespace boost{
namespace intrusive{
namespace test{
template<class T>
struct has_splay
{
static const bool value = false;
};
template<class T>
struct has_rebalance
{
static const bool value = false;
};
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
struct test_generic_assoc
{
typedef typename ValueTraits::value_type value_type;
static void test_all(std::vector<value_type>& values);
static void test_clone(std::vector<value_type>& values);
static void test_insert_erase_burst();
static void test_container_from_end(std::vector<value_type>& values);
static void test_splay_up(std::vector<value_type>& values);
static void test_splay_up(std::vector<value_type>& values, boost::intrusive::detail::true_type);
static void test_splay_up(std::vector<value_type>& values, boost::intrusive::detail::false_type);
static void test_splay_down(std::vector<value_type>& values);
static void test_splay_down(std::vector<value_type>& values, boost::intrusive::detail::true_type);
static void test_splay_down(std::vector<value_type>& values, boost::intrusive::detail::false_type);
static void test_rebalance(std::vector<value_type>& values);
static void test_rebalance(std::vector<value_type>& values, boost::intrusive::detail::true_type);
static void test_rebalance(std::vector<value_type>& values, boost::intrusive::detail::false_type);
};
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
void test_generic_assoc<ValueTraits, ContainerDefiner>::test_insert_erase_burst()
{
typedef typename ValueTraits::value_type value_type;
std::vector<value_type> values;
const int MaxValues = 100;
for(int i = 0; i != MaxValues; ++i){
values.push_back(value_type(i));
}
typedef typename ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
>::type assoc_type;
typedef typename assoc_type::iterator iterator;
//First ordered insertions
assoc_type testset (&values[0], &values[0] + values.size());
TEST_INTRUSIVE_SEQUENCE_EXPECTED(testset, testset.begin());
//Ordered erasure
iterator it(testset.begin()), itend(testset.end());
for(int i = 0; it != itend; ++i){
BOOST_TEST(&*it == &values[i]);
it = testset.erase(it);
}
BOOST_TEST(testset.empty());
//Now random insertions
std::random_shuffle(values.begin(), values.end());
testset.insert(&values[0], &values[0] + values.size());
std::sort(values.begin(), values.end());
TEST_INTRUSIVE_SEQUENCE_EXPECTED(testset, testset.begin());
//Random erasure
std::random_shuffle(values.begin(), values.end());
for(int i = 0; i != MaxValues; ++i){
it = testset.erase(testset.iterator_to(values[i]));
}
BOOST_TEST(testset.empty());
}
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
void test_generic_assoc<ValueTraits, ContainerDefiner>::test_all(std::vector<typename ValueTraits::value_type>& values)
{
test_clone(values);
test_container_from_end(values);
test_splay_up(values);
test_splay_down(values);
test_rebalance(values);
test_insert_erase_burst();
}
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
void test_generic_assoc<ValueTraits, ContainerDefiner>
::test_clone(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef typename ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
>::type assoc_type;
assoc_type testset1 (&values[0], &values[0] + values.size());
assoc_type testset2;
testset2.clone_from(testset1, test::new_cloner<value_type>(), test::delete_disposer<value_type>());
BOOST_TEST (testset2 == testset1);
testset2.clear_and_dispose(test::delete_disposer<value_type>());
BOOST_TEST (testset2.empty());
}
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
void test_generic_assoc<ValueTraits, ContainerDefiner>
::test_container_from_end(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef typename ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
>::type assoc_type;
assoc_type testset (&values[0], &values[0] + values.size());
BOOST_TEST (testset == assoc_type::container_from_end_iterator(testset.end()));
BOOST_TEST (testset == assoc_type::container_from_end_iterator(testset.cend()));
}
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
void test_generic_assoc<ValueTraits, ContainerDefiner>::test_splay_up
(std::vector<typename ValueTraits::value_type>& values, boost::intrusive::detail::true_type)
{
typedef typename ValueTraits::value_type value_type;
typedef typename ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
>::type assoc_type;
typedef typename assoc_type::iterator iterator;
typedef std::vector<value_type> orig_set_t;
std::size_t num_values;
orig_set_t original_testset;
{
assoc_type testset (values.begin(), values.end());
num_values = testset.size();
original_testset.insert(original_testset.end(), testset.begin(), testset.end());
}
for(std::size_t i = 0; i != num_values; ++i){
assoc_type testset (values.begin(), values.end());
{
iterator it = testset.begin();
for(std::size_t j = 0; j != i; ++j, ++it){}
testset.splay_up(it);
}
BOOST_TEST (testset.size() == num_values);
iterator it = testset.begin();
for( typename orig_set_t::const_iterator origit = original_testset.begin()
, origitend = original_testset.end()
; origit != origitend
; ++origit, ++it){
BOOST_TEST(*origit == *it);
}
}
}
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
void test_generic_assoc<ValueTraits, ContainerDefiner>::test_splay_up
(std::vector<typename ValueTraits::value_type>&, boost::intrusive::detail::false_type)
{}
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
void test_generic_assoc<ValueTraits, ContainerDefiner>::test_splay_up
(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
>::type assoc_type;
typedef typename detail::remove_const<assoc_type>::type Type;
typedef detail::bool_<has_splay<Type>::value> enabler;
test_splay_up(values, enabler());
}
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
void test_generic_assoc<ValueTraits, ContainerDefiner>::test_splay_down
(std::vector<typename ValueTraits::value_type>& values, boost::intrusive::detail::true_type)
{
typedef typename ValueTraits::value_type value_type;
typedef typename ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
>::type assoc_type;
typedef typename assoc_type::iterator iterator;
typedef std::vector<value_type> orig_set_t;
std::size_t num_values;
orig_set_t original_testset;
{
assoc_type testset (values.begin(), values.end());
num_values = testset.size();
original_testset.insert(original_testset.end(), testset.begin(), testset.end());
}
for(std::size_t i = 0; i != num_values; ++i){
assoc_type testset (values.begin(), values.end());
BOOST_TEST(testset.size() == num_values);
{
iterator it = testset.begin();
for(std::size_t j = 0; j != i; ++j, ++it){}
BOOST_TEST(*it == *testset.splay_down(*it));
}
BOOST_TEST (testset.size() == num_values);
iterator it = testset.begin();
for( typename orig_set_t::const_iterator origit = original_testset.begin()
, origitend = original_testset.end()
; origit != origitend
; ++origit, ++it){
BOOST_TEST(*origit == *it);
}
}
}
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
void test_generic_assoc<ValueTraits, ContainerDefiner>::test_splay_down
(std::vector<typename ValueTraits::value_type>&, boost::intrusive::detail::false_type)
{}
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
void test_generic_assoc<ValueTraits, ContainerDefiner>::test_splay_down
(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
>::type assoc_type;
typedef typename detail::remove_const<assoc_type>::type Type;
typedef detail::bool_<has_splay<Type>::value> enabler;
test_splay_down(values, enabler());
}
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
void test_generic_assoc<ValueTraits, ContainerDefiner>::test_rebalance
(std::vector<typename ValueTraits::value_type>& values, boost::intrusive::detail::true_type)
{
typedef typename ValueTraits::value_type value_type;
typedef typename ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
>::type assoc_type;
typedef std::vector<value_type> orig_set_t;
typedef typename orig_set_t::iterator iterator_t;
std::size_t num_values;
orig_set_t original_testset;
{
assoc_type testset (values.begin(), values.end());
num_values = testset.size();
original_testset.insert(original_testset.end(), testset.begin(), testset.end());
}
{
assoc_type testset(values.begin(), values.end());
testset.rebalance();
iterator_t it = original_testset.begin();
TEST_INTRUSIVE_SEQUENCE_EXPECTED(original_testset, testset.begin());
}
{
std::size_t numdata;
{
assoc_type testset(values.begin(), values.end());
numdata = testset.size();
}
for(int i = 0; i != (int)numdata; ++i){
assoc_type testset(values.begin(), values.end());
typename assoc_type::iterator it = testset.begin();
for(int j = 0; j != i; ++j) ++it;
testset.rebalance_subtree(it);
TEST_INTRUSIVE_SEQUENCE_EXPECTED(original_testset, testset.begin());
}
}
}
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
void test_generic_assoc<ValueTraits, ContainerDefiner>::test_rebalance
(std::vector<typename ValueTraits::value_type>&, boost::intrusive::detail::false_type)
{}
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
void test_generic_assoc<ValueTraits, ContainerDefiner>::test_rebalance
(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
>::type assoc_type;
typedef typename detail::remove_const<assoc_type>::type Type;
typedef detail::bool_<has_rebalance<Type>::value> enabler;
test_rebalance(values, enabler());
}
}}} //namespace boost::intrusive::test
#include <boost/intrusive/detail/config_end.hpp>
test/generic_multiset_test.hpp
+227
View File
@@ -0,0 +1,227 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Olaf Krzikalla 2004-2006.
// (C) Copyright Ion Gaztanaga 2006-2007.
//
// 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 <vector>
#include <boost/intrusive/detail/config_begin.hpp>
#include "common_functors.hpp"
#include <boost/detail/lightweight_test.hpp>
#include <boost/intrusive/options.hpp>
#include "test_macros.hpp"
#include "test_container.hpp"
#include "generic_assoc_test.hpp"
namespace boost{
namespace intrusive{
namespace test{
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
struct test_generic_multiset
{
typedef typename ValueTraits::value_type value_type;
static void test_all ();
static void test_sort(std::vector<value_type>& values);
static void test_insert(std::vector<value_type>& values);
static void test_swap(std::vector<value_type>& values);
static void test_find(std::vector<value_type>& values);
static void test_impl();
};
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
void test_generic_multiset<ValueTraits, ContainerDefiner>::test_all ()
{
typedef typename ValueTraits::value_type value_type;
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
std::vector<value_type> values (6);
for (int i = 0; i < 6; ++i)
values[i].value_ = random_init[i];
typedef typename ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
>::type multiset_type;
{
multiset_type testset(values.begin(), values.end());
test::test_container(testset);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_common_unordered_and_associative_container(testset, values);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_associative_container(testset, values);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_non_unique_container(testset, values);
}
test_sort(values);
test_insert(values);
test_swap(values);
test_find(values);
test_impl();
test_generic_assoc<ValueTraits, ContainerDefiner>::test_all(values);
}
//test case due to an error in tree implementation:
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
void test_generic_multiset<ValueTraits, ContainerDefiner>::test_impl()
{
typedef typename ValueTraits::value_type value_type;
std::vector<value_type> values (5);
for (int i = 0; i < 5; ++i)
values[i].value_ = i;
typedef typename ValueTraits::value_type value_type;
typedef typename ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
>::type multiset_type;
multiset_type testset;
for (int i = 0; i < 5; ++i)
testset.insert (values[i]);
testset.erase (testset.iterator_to (values[0]));
testset.erase (testset.iterator_to (values[1]));
testset.insert (values[1]);
testset.erase (testset.iterator_to (values[2]));
testset.erase (testset.iterator_to (values[3]));
}
//test: constructor, iterator, clear, reverse_iterator, front, back, size:
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
void test_generic_multiset<ValueTraits, ContainerDefiner>::test_sort(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef typename ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
>::type multiset_type;
multiset_type testset1 (values.begin(), values.end());
{ int init_values [] = { 1, 2, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
testset1.clear();
BOOST_TEST (testset1.empty());
typedef typename ContainerDefiner
<value_type
, compare<even_odd>
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
>::type multiset_type2;
multiset_type2 testset2 (&values[0], &values[0] + 6);
{ int init_values [] = { 5, 3, 1, 4, 2, 2 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset2.rbegin() ); }
BOOST_TEST (testset2.begin()->value_ == 2);
BOOST_TEST (testset2.rbegin()->value_ == 5);
}
//test: insert, const_iterator, const_reverse_iterator, erase, iterator_to:
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
void test_generic_multiset<ValueTraits, ContainerDefiner>::test_insert(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef typename ContainerDefiner
< value_type
, value_traits<ValueTraits>
, size_type<std::size_t>
, constant_time_size<value_type::constant_time_size>
>::type multiset_type;
multiset_type testset;
testset.insert(&values[0] + 2, &values[0] + 5);
{ int init_values [] = { 1, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset.begin() ); }
typename multiset_type::iterator i = testset.begin();
BOOST_TEST (i->value_ == 1);
i = testset.insert (i, values[0]);
BOOST_TEST (&*i == &values[0]);
{ int init_values [] = { 5, 4, 3, 1 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset.rbegin() ); }
i = testset.iterator_to (values[2]);
BOOST_TEST (&*i == &values[2]);
i = multiset_type::s_iterator_to (values[2]);
BOOST_TEST (&*i == &values[2]);
testset.erase(i);
{ int init_values [] = { 1, 3, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset.begin() ); }
}
//test: insert (seq-version), swap, erase (seq-version), size:
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
void test_generic_multiset<ValueTraits, ContainerDefiner>::test_swap(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef typename ContainerDefiner
< value_type
, value_traits<ValueTraits>
, size_type<std::size_t>
, constant_time_size<value_type::constant_time_size>
>::type multiset_type;
multiset_type testset1 (&values[0], &values[0] + 2);
multiset_type testset2;
testset2.insert (&values[0] + 2, &values[0] + 6);
testset1.swap (testset2);
{ int init_values [] = { 1, 2, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
{ int init_values [] = { 2, 3 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset2.begin() ); }
testset1.erase (testset1.iterator_to(values[5]), testset1.end());
BOOST_TEST (testset1.size() == 1);
BOOST_TEST (&*testset1.begin() == &values[3]);
}
//test: find, equal_range (lower_bound, upper_bound):
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
void test_generic_multiset<ValueTraits, ContainerDefiner>::test_find(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef typename ContainerDefiner
< value_type
, value_traits<ValueTraits>
, size_type<std::size_t>
, constant_time_size<value_type::constant_time_size>
>::type multiset_type;
multiset_type testset (values.begin(), values.end());
typedef typename multiset_type::iterator iterator;
value_type cmp_val;
cmp_val.value_ = 2;
iterator i = testset.find (cmp_val);
BOOST_TEST (i->value_ == 2);
BOOST_TEST ((++i)->value_ == 2);
std::pair<iterator,iterator> range = testset.equal_range (cmp_val);
BOOST_TEST (range.first->value_ == 2);
BOOST_TEST (range.second->value_ == 3);
BOOST_TEST (std::distance (range.first, range.second) == 2);
cmp_val.value_ = 7;
BOOST_TEST (testset.find (cmp_val) == testset.end());
}
}}} //namespace boost::intrusive::test
#include <boost/intrusive/detail/config_end.hpp>
test/generic_set_test.hpp
+225
View File
@@ -0,0 +1,225 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Olaf Krzikalla 2004-2006.
// (C) Copyright Ion Gaztanaga 2006-2007.
//
// 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 <vector>
#include <boost/intrusive/detail/config_begin.hpp>
#include "common_functors.hpp"
#include <boost/detail/lightweight_test.hpp>
#include <boost/intrusive/options.hpp>
#include "test_macros.hpp"
#include "test_container.hpp"
#include "generic_assoc_test.hpp"
namespace boost{
namespace intrusive{
namespace test{
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
struct test_generic_set
{
typedef typename ValueTraits::value_type value_type;
static void test_all();
static void test_sort(std::vector<value_type>& values);
static void test_insert(std::vector<value_type>& values);
static void test_swap(std::vector<value_type>& values);
static void test_find(std::vector<value_type>& values);
static void test_impl();
};
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
void test_generic_set<ValueTraits, ContainerDefiner>::test_all()
{
typedef typename ValueTraits::value_type value_type;
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
std::vector<value_type> values (6);
for (int i = 0; i < 6; ++i)
values[i].value_ = random_init[i];
typedef typename ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
>::type set_type;
{
set_type testset(values.begin(), values.end());
test::test_container(testset);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_common_unordered_and_associative_container(testset, values);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_associative_container(testset, values);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_unique_container(testset, values);
}
test_sort(values);
test_insert(values);
test_swap(values);
test_find(values);
test_impl();
test_generic_assoc<ValueTraits, ContainerDefiner>::test_all(values);
}
//test case due to an error in tree implementation:
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
void test_generic_set<ValueTraits, ContainerDefiner>::test_impl()
{
typedef typename ValueTraits::value_type value_type;
std::vector<value_type> values (5);
for (int i = 0; i < 5; ++i)
values[i].value_ = i;
typedef typename ValueTraits::value_type value_type;
typedef typename ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
>::type set_type;
set_type testset;
for (int i = 0; i < 5; ++i)
testset.insert (values[i]);
testset.erase (testset.iterator_to (values[0]));
testset.erase (testset.iterator_to (values[1]));
testset.insert (values[1]);
testset.erase (testset.iterator_to (values[2]));
testset.erase (testset.iterator_to (values[3]));
}
//test: constructor, iterator, clear, reverse_iterator, front, back, size:
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
void test_generic_set<ValueTraits, ContainerDefiner>::test_sort(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef typename ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
>::type set_type;
set_type testset1 (values.begin(), values.end());
{ int init_values [] = { 1, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
testset1.clear();
BOOST_TEST (testset1.empty());
typedef typename ValueTraits::value_type value_type;
typedef typename ContainerDefiner
< value_type
, compare<even_odd>
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
>::type set_type2;
set_type2 testset2 (&values[0], &values[0] + 6);
{ int init_values [] = { 5, 3, 1, 4, 2 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset2.rbegin() ); }
BOOST_TEST (testset2.begin()->value_ == 2);
BOOST_TEST (testset2.rbegin()->value_ == 5);
}
//test: insert, const_iterator, const_reverse_iterator, erase, s_iterator_to:
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
void test_generic_set<ValueTraits, ContainerDefiner>::test_insert(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef typename ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
>::type set_type;
set_type testset;
testset.insert(&values[0] + 2, &values[0] + 5);
const set_type& const_testset = testset;
{ int init_values [] = { 1, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, const_testset.begin() ); }
typename set_type::iterator i = testset.begin();
BOOST_TEST (i->value_ == 1);
i = testset.insert (i, values[0]);
BOOST_TEST (&*i == &values[0]);
{ int init_values [] = { 5, 4, 3, 1 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset.rbegin() ); }
i = testset.iterator_to (values[2]);
BOOST_TEST (&*i == &values[2]);
i = set_type::s_iterator_to(values[2]);
BOOST_TEST (&*i == &values[2]);
testset.erase (i);
{ int init_values [] = { 1, 3, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset.begin() ); }
}
//test: insert (seq-version), swap, erase (seq-version), size:
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
void test_generic_set<ValueTraits, ContainerDefiner>::test_swap(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef typename ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
>::type set_type;
set_type testset1 (&values[0], &values[0] + 2);
set_type testset2;
testset2.insert (&values[0] + 2, &values[0] + 6);
testset1.swap (testset2);
{ int init_values [] = { 1, 2, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
{ int init_values [] = { 2, 3 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset2.begin() ); }
testset1.erase (testset1.iterator_to(values[5]), testset1.end());
BOOST_TEST (testset1.size() == 1);
// BOOST_TEST (&testset1.front() == &values[3]);
BOOST_TEST (&*testset1.begin() == &values[3]);
}
//test: find, equal_range (lower_bound, upper_bound):
template<class ValueTraits, template <class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none, class = ::boost::intrusive::none> class ContainerDefiner>
void test_generic_set<ValueTraits, ContainerDefiner>::test_find(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef typename ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
>::type set_type;
set_type testset (values.begin(), values.end());
typedef typename set_type::iterator iterator;
value_type cmp_val;
cmp_val.value_ = 2;
iterator i = testset.find (cmp_val);
BOOST_TEST (i->value_ == 2);
BOOST_TEST ((++i)->value_ != 2);
std::pair<iterator,iterator> range = testset.equal_range (cmp_val);
BOOST_TEST (range.first->value_ == 2);
BOOST_TEST (range.second->value_ == 3);
BOOST_TEST (std::distance (range.first, range.second) == 1);
cmp_val.value_ = 7;
BOOST_TEST (testset.find (cmp_val) == testset.end());
}
}}} //namespace boost::intrusive::test
#include <boost/intrusive/detail/config_end.hpp>
test/itestvalue.hpp
+33 -2
View File
@@ -20,6 +20,7 @@
#include <boost/intrusive/unordered_set_hook.hpp>
#include <boost/intrusive/splay_set_hook.hpp>
#include <boost/intrusive/avl_set_hook.hpp>
#include <boost/intrusive/bs_set_hook.hpp>
#include <boost/intrusive/options.hpp>
#include <boost/functional/hash.hpp>
#include "smart_ptr.hpp"
@@ -61,6 +62,14 @@ template<class VoidPointer>
struct splay_set_auto_member_hook_type
{ typedef splay_set_member_hook<link_mode<auto_unlink>, void_pointer<VoidPointer> > type; };
template<class VoidPointer>
struct bs_set_base_hook_type
{ typedef bs_set_base_hook<void_pointer<VoidPointer> > type; };
template<class VoidPointer>
struct bs_set_member_hook_type
{ typedef bs_set_member_hook<void_pointer<VoidPointer> > type; };
template<class VoidPointer>
struct avl_set_base_hook_type
{ typedef avl_set_base_hook<void_pointer<VoidPointer> > type; };
@@ -115,7 +124,11 @@ struct uset_base_hook_type
template<class VoidPointer>
struct uset_auto_base_hook_type
{ typedef unordered_set_base_hook<link_mode<auto_unlink>, void_pointer<VoidPointer>, tag<my_tag> > type; };
{
typedef unordered_set_base_hook
< link_mode<auto_unlink>, void_pointer<VoidPointer>
, tag<my_tag>, store_hash<true> > type;
};
template<class VoidPointer>
struct uset_member_hook_type
@@ -123,7 +136,11 @@ struct uset_member_hook_type
template<class VoidPointer>
struct uset_auto_member_hook_type
{ typedef unordered_set_member_hook<link_mode<auto_unlink>, void_pointer<VoidPointer> > type; };
{
typedef unordered_set_member_hook
< link_mode<auto_unlink>, void_pointer<VoidPointer>
, store_hash<true> > type;
};
template<class VoidPointer, bool ConstantTimeSize>
struct testvalue
@@ -131,6 +148,7 @@ struct testvalue
, set_auto_base_hook_type<VoidPointer>::type
, splay_set_base_hook_type<VoidPointer>::type
, splay_set_auto_base_hook_type<VoidPointer>::type
, bs_set_base_hook_type<VoidPointer>::type
, avl_set_base_hook_type<VoidPointer>::type
, avl_set_auto_base_hook_type<VoidPointer>::type
, list_base_hook_type<VoidPointer>::type
@@ -150,6 +168,9 @@ struct testvalue
typedef typename splay_set_auto_member_hook_type<VoidPointer>::type splay_set_auto_member_hook_t;
typedef typename splay_set_member_hook_type<VoidPointer>::type splay_set_member_hook_t;
typedef typename bs_set_base_hook_type<VoidPointer>::type bs_set_base_hook_t;
typedef typename bs_set_member_hook_type<VoidPointer>::type bs_set_member_hook_t;
typedef typename avl_set_auto_base_hook_type<VoidPointer>::type avl_set_auto_base_hook_t;
typedef typename avl_set_base_hook_type<VoidPointer>::type avl_set_base_hook_t;
typedef typename avl_set_auto_member_hook_type<VoidPointer>::type avl_set_auto_member_hook_t;
@@ -178,6 +199,9 @@ struct testvalue
splay_set_member_hook_t splay_set_node_;
splay_set_auto_member_hook_t splay_set_auto_node_;
//ScapegoatSet members
bs_set_member_hook_t sg_set_node_;
//AvlSet members
avl_set_member_hook_t avl_set_node_;
avl_set_auto_member_hook_t avl_set_auto_node_;
@@ -224,6 +248,9 @@ struct testvalue
this->splay_set_node_ = src.splay_set_node_;
this->splay_set_auto_node_ = src.splay_set_auto_node_;
bs_set_base_hook_t::operator=(src);
this->sg_set_node_ = src.sg_set_node_;
avl_set_base_hook_t::operator=(src);
avl_set_auto_base_hook_t::operator=(src);
this->avl_set_node_ = src.avl_set_node_;
@@ -262,6 +289,10 @@ struct testvalue
splay_set_node_.swap_nodes(other.splay_set_node_);
splay_set_auto_node_.swap_nodes(other.splay_set_auto_node_);
//ScapeoatSet
bs_set_base_hook_t::swap_nodes(other);
sg_set_node_.swap_nodes(other.sg_set_node_);
//AvlSet
avl_set_base_hook_t::swap_nodes(other);
avl_set_auto_base_hook_t::swap_nodes(other);
test/make_functions_test.cpp
+1 -2
View File
@@ -68,8 +68,7 @@ int main()
Set my_set;
USet my_uset(USet::bucket_traits(buckets, 100));
//Now insert them in the reverse order
//in the base hook intrusive list
//Now insert them in containers
for(VectIt it(values.begin()), itend(values.end()); it != itend; ++it){
my_list.push_front(*it);
my_slist.push_front(*it);
test/multiset_test.cpp
+37 -289
View File
@@ -10,278 +10,51 @@
// See http://www.boost.org/libs/intrusive for documentation.
//
/////////////////////////////////////////////////////////////////////////////
#include <boost/intrusive/detail/config_begin.hpp>
#include <boost/intrusive/set.hpp>
#include <boost/intrusive/detail/pointer_to_other.hpp>
#include "itestvalue.hpp"
#include "smart_ptr.hpp"
#include "common_functors.hpp"
#include <vector>
#include <boost/detail/lightweight_test.hpp>
#include "test_macros.hpp"
#include "test_container.hpp"
#include "generic_multiset_test.hpp"
using namespace boost::intrusive;
template<class ValueTraits>
struct test_multiset
template< class ValueType
, class Option1 = boost::intrusive::none
, class Option2 = boost::intrusive::none
, class Option3 = boost::intrusive::none
>
struct GetContainer
{
typedef typename ValueTraits::value_type value_type;
static void test_all (std::vector<value_type>& values);
static void test_sort(std::vector<value_type>& values);
static void test_insert(std::vector<value_type>& values);
static void test_swap(std::vector<value_type>& values);
static void test_find(std::vector<value_type>& values);
static void test_impl();
static void test_clone(std::vector<value_type>& values);
static void test_container_from_end(std::vector<value_type>& values);
typedef boost::intrusive::multiset
< ValueType
, Option1
, Option2
, Option3
> type;
};
template<class ValueTraits>
void test_multiset<ValueTraits>::test_all (std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef multiset
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> multiset_type;
{
multiset_type testset(values.begin(), values.end());
test::test_container(testset);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_common_unordered_and_associative_container(testset, values);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_associative_container(testset, values);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_non_unique_container(testset, values);
}
test_sort(values);
test_insert(values);
test_swap(values);
test_find(values);
test_impl();
test_clone(values);
test_container_from_end(values);
}
//test case due to an error in tree implementation:
template<class ValueTraits>
void test_multiset<ValueTraits>::test_impl()
{
typedef typename ValueTraits::value_type value_type;
std::vector<value_type> values (5);
for (int i = 0; i < 5; ++i)
values[i].value_ = i;
typedef typename ValueTraits::value_type value_type;
typedef multiset
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> multiset_type;
multiset_type testset;
for (int i = 0; i < 5; ++i)
testset.insert (values[i]);
testset.erase (testset.iterator_to (values[0]));
testset.erase (testset.iterator_to (values[1]));
testset.insert (values[1]);
testset.erase (testset.iterator_to (values[2]));
testset.erase (testset.iterator_to (values[3]));
}
//test: constructor, iterator, clear, reverse_iterator, front, back, size:
template<class ValueTraits>
void test_multiset<ValueTraits>::test_sort(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef multiset
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> multiset_type;
multiset_type testset1 (values.begin(), values.end());
{ int init_values [] = { 1, 2, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
testset1.clear();
BOOST_TEST (testset1.empty());
typedef multiset
<value_type
, compare<even_odd>
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> multiset_type2;
multiset_type2 testset2 (&values[0], &values[0] + 6);
{ int init_values [] = { 5, 3, 1, 4, 2, 2 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset2.rbegin() ); }
BOOST_TEST (testset2.begin()->value_ == 2);
BOOST_TEST (testset2.rbegin()->value_ == 5);
}
//test: insert, const_iterator, const_reverse_iterator, erase, iterator_to:
template<class ValueTraits>
void test_multiset<ValueTraits>::test_insert(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef multiset
< value_type
, value_traits<ValueTraits>
, size_type<std::size_t>
, constant_time_size<value_type::constant_time_size>
> multiset_type;
multiset_type testset;
testset.insert(&values[0] + 2, &values[0] + 5);
{ int init_values [] = { 1, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset.begin() ); }
typename multiset_type::iterator i = testset.begin();
BOOST_TEST (i->value_ == 1);
i = testset.insert (i, values[0]);
BOOST_TEST (&*i == &values[0]);
{ int init_values [] = { 5, 4, 3, 1 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset.rbegin() ); }
i = testset.iterator_to (values[2]);
BOOST_TEST (&*i == &values[2]);
i = multiset_type::s_iterator_to (values[2]);
BOOST_TEST (&*i == &values[2]);
testset.erase(i);
{ int init_values [] = { 1, 3, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset.begin() ); }
}
//test: insert (seq-version), swap, erase (seq-version), size:
template<class ValueTraits>
void test_multiset<ValueTraits>::test_swap(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef multiset
< value_type
, value_traits<ValueTraits>
, size_type<std::size_t>
, constant_time_size<value_type::constant_time_size>
> multiset_type;
multiset_type testset1 (&values[0], &values[0] + 2);
multiset_type testset2;
testset2.insert (&values[0] + 2, &values[0] + 6);
testset1.swap (testset2);
{ int init_values [] = { 1, 2, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
{ int init_values [] = { 2, 3 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset2.begin() ); }
testset1.erase (testset1.iterator_to(values[5]), testset1.end());
BOOST_TEST (testset1.size() == 1);
BOOST_TEST (&*testset1.begin() == &values[3]);
}
//test: find, equal_range (lower_bound, upper_bound):
template<class ValueTraits>
void test_multiset<ValueTraits>::test_find(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef multiset
< value_type
, value_traits<ValueTraits>
, size_type<std::size_t>
, constant_time_size<value_type::constant_time_size>
> multiset_type;
multiset_type testset (values.begin(), values.end());
typedef typename multiset_type::iterator iterator;
value_type cmp_val;
cmp_val.value_ = 2;
iterator i = testset.find (cmp_val);
BOOST_TEST (i->value_ == 2);
BOOST_TEST ((++i)->value_ == 2);
std::pair<iterator,iterator> range = testset.equal_range (cmp_val);
BOOST_TEST (range.first->value_ == 2);
BOOST_TEST (range.second->value_ == 3);
BOOST_TEST (std::distance (range.first, range.second) == 2);
cmp_val.value_ = 7;
BOOST_TEST (testset.find (cmp_val) == testset.end());
}
template<class ValueTraits>
void test_multiset<ValueTraits>
::test_clone(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef multiset
< value_type
, value_traits<ValueTraits>
, size_type<std::size_t>
, constant_time_size<value_type::constant_time_size>
> multiset_type;
multiset_type testmultiset1 (&values[0], &values[0] + values.size());
multiset_type testmultiset2;
testmultiset2.clone_from(testmultiset1, test::new_cloner<value_type>(), test::delete_disposer<value_type>());
BOOST_TEST (testmultiset2 == testmultiset1);
testmultiset2.clear_and_dispose(test::delete_disposer<value_type>());
BOOST_TEST (testmultiset2.empty());
}
template<class ValueTraits>
void test_multiset<ValueTraits>
::test_container_from_end(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef multiset
< value_type
, value_traits<ValueTraits>
, size_type<std::size_t>
, constant_time_size<value_type::constant_time_size>
> multiset_type;
multiset_type testmultiset (&values[0], &values[0] + values.size());
BOOST_TEST (testmultiset == multiset_type::container_from_end_iterator(testmultiset.end()));
BOOST_TEST (testmultiset == multiset_type::container_from_end_iterator(testmultiset.cend()));
}
template<class VoidPointer, bool constant_time_size>
class test_main_template
{
public:
int operator()()
{
using namespace boost::intrusive;
typedef testvalue<VoidPointer, constant_time_size> value_type;
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
std::vector<testvalue<VoidPointer, constant_time_size> > data (6);
for (int i = 0; i < 6; ++i)
data[i].value_ = random_init[i];
test_multiset < typename detail::get_base_value_traits
test::test_generic_multiset < typename detail::get_base_value_traits
< value_type
, typename value_type::set_base_hook_t
>::type
>::test_all(data);
test_multiset < typename detail::get_member_value_traits
, GetContainer
>::test_all();
test::test_generic_multiset < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::set_member_hook_t
, &value_type::set_node_
>
>::type
>::test_all(data);
, GetContainer
>::test_all();
return 0;
}
};
@@ -292,78 +65,53 @@ class test_main_template<VoidPointer, false>
public:
int operator()()
{
using namespace boost::intrusive;
typedef testvalue<VoidPointer, false> value_type;
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
std::vector<testvalue<VoidPointer, false> > data (6);
for (int i = 0; i < 6; ++i)
data[i].value_ = random_init[i];
test_multiset < typename detail::get_base_value_traits
test::test_generic_multiset < typename detail::get_base_value_traits
< value_type
, typename value_type::set_base_hook_t
>::type
>::test_all(data);
, GetContainer
>::test_all();
test_multiset < typename detail::get_member_value_traits
test::test_generic_multiset < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::set_member_hook_t
, &value_type::set_node_
>
>::type
>::test_all(data);
, GetContainer
>::test_all();
test_multiset < typename detail::get_base_value_traits
test::test_generic_multiset < typename detail::get_base_value_traits
< value_type
, typename value_type::set_auto_base_hook_t
>::type
>::test_all(data);
, GetContainer
>::test_all();
test_multiset < typename detail::get_member_value_traits
test::test_generic_multiset < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::set_auto_member_hook_t
, &value_type::set_auto_node_
>
>::type
>::test_all(data);
, GetContainer
>::test_all();
return 0;
}
};
//Explicit instantiations of non-counted classes
//template class multiset
// <set_base_raw, std::less<set_base_raw::value_type>, false>;
//template class multiset
// <set_member_raw, std::less<set_member_raw::value_type>, false>;
//template class multiset
// <set_auto_base_raw, std::less<set_auto_base_raw::value_type>, false>;
//template class multiset
// <set_auto_member_raw, std::less<set_auto_member_raw::value_type>, false>;
//template class multiset
// <set_base_smart, std::less<set_base_smart::value_type>, false>;
//template class multiset
// <set_member_smart, std::less<set_member_smart::value_type>, false>;
//template class multiset
// <set_auto_base_smart, std::less<set_auto_base_smart::value_type>, false>;
//template class multiset
// <set_auto_member_smart, std::less<set_auto_member_smart::value_type>, false>;
//Explicit instantiation of counted classes
//template class multiset
// <set_base_raw_t, std::less<set_base_raw_t::value_type>, true>;
//template class multiset
// <set_member_raw_t, std::less<set_member_raw_t::value_type>, true>;
//template class multiset
// <set_base_smart_t, std::less<set_base_smart_t::value_type>, true>;
//template class multiset
// <set_member_smart_t, std::less<set_member_smart_t::value_type>, true>;
int main( int, char* [] )
{
test_main_template<void*, false>()();
test_main_template<smart_ptr<void>, false>()();
test_main_template<boost::intrusive::smart_ptr<void>, false>()();
test_main_template<void*, true>()();
test_main_template<smart_ptr<void>, true>()();
test_main_template<boost::intrusive::smart_ptr<void>, true>()();
return boost::report_errors();
}
#include <boost/intrusive/detail/config_end.hpp>
test/set_test.cpp
+35 -257
View File
@@ -12,272 +12,49 @@
/////////////////////////////////////////////////////////////////////////////
#include <boost/intrusive/detail/config_begin.hpp>
#include <boost/intrusive/set.hpp>
#include <boost/intrusive/detail/pointer_to_other.hpp>
#include "itestvalue.hpp"
#include "smart_ptr.hpp"
#include "common_functors.hpp"
#include <vector>
#include <boost/detail/lightweight_test.hpp>
#include "test_macros.hpp"
#include "test_container.hpp"
#include "generic_set_test.hpp"
using namespace boost::intrusive;
template<class ValueTraits>
struct test_set
template< class ValueType
, class Option1 = boost::intrusive::none
, class Option2 = boost::intrusive::none
, class Option3 = boost::intrusive::none
>
struct GetContainer
{
typedef typename ValueTraits::value_type value_type;
static void test_all(std::vector<value_type>& values);
static void test_sort(std::vector<value_type>& values);
static void test_insert(std::vector<value_type>& values);
static void test_swap(std::vector<value_type>& values);
static void test_find(std::vector<value_type>& values);
static void test_impl();
static void test_clone(std::vector<value_type>& values);
static void test_container_from_end(std::vector<value_type>& values);
typedef boost::intrusive::set
< ValueType
, Option1
, Option2
, Option3
> type;
};
template<class ValueTraits>
void test_set<ValueTraits>::test_all(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef set
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> set_type;
{
set_type testset(values.begin(), values.end());
test::test_container(testset);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_common_unordered_and_associative_container(testset, values);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_associative_container(testset, values);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_unique_container(testset, values);
}
test_sort(values);
test_insert(values);
test_swap(values);
test_find(values);
test_impl();
test_clone(values);
test_container_from_end(values);
}
//test case due to an error in tree implementation:
template<class ValueTraits>
void test_set<ValueTraits>::test_impl()
{
typedef typename ValueTraits::value_type value_type;
std::vector<value_type> values (5);
for (int i = 0; i < 5; ++i)
values[i].value_ = i;
typedef typename ValueTraits::value_type value_type;
typedef set
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> set_type;
set_type testset;
for (int i = 0; i < 5; ++i)
testset.insert (values[i]);
testset.erase (testset.iterator_to (values[0]));
testset.erase (testset.iterator_to (values[1]));
testset.insert (values[1]);
testset.erase (testset.iterator_to (values[2]));
testset.erase (testset.iterator_to (values[3]));
}
//test: constructor, iterator, clear, reverse_iterator, front, back, size:
template<class ValueTraits>
void test_set<ValueTraits>::test_sort(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef set
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> set_type;
set_type testset1 (values.begin(), values.end());
{ int init_values [] = { 1, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
testset1.clear();
BOOST_TEST (testset1.empty());
typedef typename ValueTraits::value_type value_type;
typedef set
< value_type
, compare<even_odd>
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> set_type2;
set_type2 testset2 (&values[0], &values[0] + 6);
{ int init_values [] = { 5, 3, 1, 4, 2 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset2.rbegin() ); }
BOOST_TEST (testset2.begin()->value_ == 2);
BOOST_TEST (testset2.rbegin()->value_ == 5);
}
//test: insert, const_iterator, const_reverse_iterator, erase, s_iterator_to:
template<class ValueTraits>
void test_set<ValueTraits>::test_insert(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef set
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> set_type;
set_type testset;
testset.insert(&values[0] + 2, &values[0] + 5);
const set_type& const_testset = testset;
{ int init_values [] = { 1, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, const_testset.begin() ); }
typename set_type::iterator i = testset.begin();
BOOST_TEST (i->value_ == 1);
i = testset.insert (i, values[0]);
BOOST_TEST (&*i == &values[0]);
{ int init_values [] = { 5, 4, 3, 1 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset.rbegin() ); }
i = testset.iterator_to (values[2]);
BOOST_TEST (&*i == &values[2]);
i = set_type::s_iterator_to(values[2]);
BOOST_TEST (&*i == &values[2]);
testset.erase (i);
{ int init_values [] = { 1, 3, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset.begin() ); }
}
//test: insert (seq-version), swap, erase (seq-version), size:
template<class ValueTraits>
void test_set<ValueTraits>::test_swap(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef set
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> set_type;
set_type testset1 (&values[0], &values[0] + 2);
set_type testset2;
testset2.insert (&values[0] + 2, &values[0] + 6);
testset1.swap (testset2);
{ int init_values [] = { 1, 2, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
{ int init_values [] = { 2, 3 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset2.begin() ); }
testset1.erase (testset1.iterator_to(values[5]), testset1.end());
BOOST_TEST (testset1.size() == 1);
// BOOST_TEST (&testset1.front() == &values[3]);
BOOST_TEST (&*testset1.begin() == &values[3]);
}
//test: find, equal_range (lower_bound, upper_bound):
template<class ValueTraits>
void test_set<ValueTraits>::test_find(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef set
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> set_type;
set_type testset (values.begin(), values.end());
typedef typename set_type::iterator iterator;
value_type cmp_val;
cmp_val.value_ = 2;
iterator i = testset.find (cmp_val);
BOOST_TEST (i->value_ == 2);
BOOST_TEST ((++i)->value_ != 2);
std::pair<iterator,iterator> range = testset.equal_range (cmp_val);
BOOST_TEST (range.first->value_ == 2);
BOOST_TEST (range.second->value_ == 3);
BOOST_TEST (std::distance (range.first, range.second) == 1);
cmp_val.value_ = 7;
BOOST_TEST (testset.find (cmp_val) == testset.end());
}
template<class ValueTraits>
void test_set<ValueTraits>
::test_clone(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef set
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> set_type;
set_type testset1 (&values[0], &values[0] + values.size());
set_type testset2;
testset2.clone_from(testset1, test::new_cloner<value_type>(), test::delete_disposer<value_type>());
BOOST_TEST (testset2 == testset1);
testset2.clear_and_dispose(test::delete_disposer<value_type>());
BOOST_TEST (testset2.empty());
}
template<class ValueTraits>
void test_set<ValueTraits>
::test_container_from_end(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef set
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> set_type;
set_type testset (&values[0], &values[0] + values.size());
BOOST_TEST (testset == set_type::container_from_end_iterator(testset.end()));
BOOST_TEST (testset == set_type::container_from_end_iterator(testset.cend()));
}
template<class VoidPointer, bool constant_time_size>
class test_main_template
{
public:
int operator()()
{
using namespace boost::intrusive;
typedef testvalue<VoidPointer, constant_time_size> value_type;
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
std::vector<testvalue<VoidPointer, constant_time_size> > data (6);
for (int i = 0; i < 6; ++i)
data[i].value_ = random_init[i];
test_set < typename detail::get_base_value_traits
test::test_generic_set < typename detail::get_base_value_traits
< value_type
, typename value_type::set_base_hook_t
>::type
>::test_all(data);
test_set < typename detail::get_member_value_traits
, GetContainer
>::test_all();
test::test_generic_set < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::set_member_hook_t
, &value_type::set_node_
>
>::type
>::test_all(data);
, GetContainer
>::test_all();
return 0;
}
};
@@ -288,41 +65,42 @@ class test_main_template<VoidPointer, false>
public:
int operator()()
{
using namespace boost::intrusive;
typedef testvalue<VoidPointer, false> value_type;
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
std::vector<testvalue<VoidPointer, false> > data (6);
for (int i = 0; i < 6; ++i)
data[i].value_ = random_init[i];
test_set < typename detail::get_base_value_traits
test::test_generic_set < typename detail::get_base_value_traits
< value_type
, typename value_type::set_base_hook_t
>::type
>::test_all(data);
, GetContainer
>::test_all();
test_set < typename detail::get_member_value_traits
test::test_generic_set < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::set_member_hook_t
, &value_type::set_node_
>
>::type
>::test_all(data);
, GetContainer
>::test_all();
test_set < typename detail::get_base_value_traits
test::test_generic_set < typename detail::get_base_value_traits
< value_type
, typename value_type::set_auto_base_hook_t
>::type
>::test_all(data);
, GetContainer
>::test_all();
test_set < typename detail::get_member_value_traits
test::test_generic_set < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::set_auto_member_hook_t
, &value_type::set_auto_node_
>
>::type
>::test_all(data);
, GetContainer
>::test_all();
return 0;
}
@@ -332,9 +110,9 @@ int main( int, char* [] )
{
test_main_template<void*, false>()();
test_main_template<smart_ptr<void>, false>()();
test_main_template<boost::intrusive::smart_ptr<void>, false>()();
test_main_template<void*, true>()();
test_main_template<smart_ptr<void>, true>()();
test_main_template<boost::intrusive::smart_ptr<void>, true>()();
return boost::report_errors();
}
#include <boost/intrusive/detail/config_end.hpp>
test/sg_multiset_test.cpp
+108
View File
@@ -0,0 +1,108 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Olaf Krzikalla 2004-2006.
// (C) Copyright Ion Gaztanaga 2006-2007.
//
// 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/detail/config_begin.hpp>
#include <boost/intrusive/sg_set.hpp>
#include "itestvalue.hpp"
#include "smart_ptr.hpp"
#include "generic_multiset_test.hpp"
namespace boost { namespace intrusive { namespace test {
template<class T, class O1, class O2, class O3, class O4>
struct has_rebalance<boost::intrusive::sg_multiset<T, O1, O2, O3, O4> >
{
static const bool value = true;
};
}}}
template< class ValueType
, class Option1 = boost::intrusive::none
, class Option2 = boost::intrusive::none
, class Option3 = boost::intrusive::none
>
struct GetContainer
{
typedef boost::intrusive::sg_multiset
< ValueType
, Option1
, Option2
, Option3
> type;
};
template< class ValueType
, class Option1 = boost::intrusive::none
, class Option2 = boost::intrusive::none
, class Option3 = boost::intrusive::none
>
struct GetContainerFixedAlpha
{
typedef boost::intrusive::sg_multiset
< ValueType
, Option1
, Option2
, Option3
, boost::intrusive::floating_point<false>
> type;
};
template<class VoidPointer>
class test_main_template
{
public:
int operator()()
{
using namespace boost::intrusive;
typedef testvalue<VoidPointer, true> value_type;
test::test_generic_multiset < typename detail::get_base_value_traits
< value_type
, typename value_type::bs_set_base_hook_t
>::type
, GetContainer
>::test_all();
test::test_generic_multiset < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::bs_set_member_hook_t
, &value_type::sg_set_node_
>
>::type
, GetContainer
>::test_all();
test::test_generic_multiset < typename detail::get_base_value_traits
< value_type
, typename value_type::bs_set_base_hook_t
>::type
, GetContainerFixedAlpha
>::test_all();
test::test_generic_multiset < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::bs_set_member_hook_t
, &value_type::sg_set_node_
>
>::type
, GetContainerFixedAlpha
>::test_all();
return 0;
}
};
int main( int, char* [] )
{
test_main_template<void*>()();
test_main_template<boost::intrusive::smart_ptr<void> >()();
return boost::report_errors();
}
test/sg_set_test.cpp
+109
View File
@@ -0,0 +1,109 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2007.
//
// 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/detail/config_begin.hpp>
#include <boost/intrusive/sg_set.hpp>
#include "itestvalue.hpp"
#include "smart_ptr.hpp"
#include "generic_set_test.hpp"
namespace boost { namespace intrusive { namespace test {
template<class T, class O1, class O2, class O3, class O4>
struct has_rebalance<boost::intrusive::sg_set<T, O1, O2, O3, O4> >
{
static const bool value = true;
};
}}}
template< class ValueType
, class Option1 = boost::intrusive::none
, class Option2 = boost::intrusive::none
, class Option3 = boost::intrusive::none
>
struct GetContainer
{
typedef boost::intrusive::sg_set
< ValueType
, Option1
, Option2
, Option3
> type;
};
template< class ValueType
, class Option1 = boost::intrusive::none
, class Option2 = boost::intrusive::none
, class Option3 = boost::intrusive::none
>
struct GetContainerFixedAlpha
{
typedef boost::intrusive::sg_set
< ValueType
, Option1
, Option2
, Option3
, boost::intrusive::floating_point<false>
> type;
};
template<class VoidPointer>
class test_main_template
{
public:
int operator()()
{
using namespace boost::intrusive;
typedef testvalue<VoidPointer, true> value_type;
test::test_generic_set < typename detail::get_base_value_traits
< value_type
, typename value_type::bs_set_base_hook_t
>::type
, GetContainer
>::test_all();
test::test_generic_set < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::bs_set_member_hook_t
, &value_type::sg_set_node_
>
>::type
, GetContainer
>::test_all();
test::test_generic_set < typename detail::get_base_value_traits
< value_type
, typename value_type::bs_set_base_hook_t
>::type
, GetContainerFixedAlpha
>::test_all();
test::test_generic_set < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::bs_set_member_hook_t
, &value_type::sg_set_node_
>
>::type
, GetContainerFixedAlpha
>::test_all();
return 0;
}
};
int main( int, char* [] )
{
test_main_template<void*>()();
test_main_template<boost::intrusive::smart_ptr<void> >()();
return boost::report_errors();
}
#include <boost/intrusive/detail/config_end.hpp>
test/splay_multiset_test.cpp
+74 -405
View File
@@ -10,18 +10,12 @@
// See http://www.boost.org/libs/intrusive for documentation.
//
/////////////////////////////////////////////////////////////////////////////
#include <boost/intrusive/detail/config_begin.hpp>
#include <boost/intrusive/splay_set.hpp>
#include <boost/intrusive/detail/pointer_to_other.hpp>
#include "itestvalue.hpp"
#include "smart_ptr.hpp"
#include "common_functors.hpp"
#include <vector>
#include <boost/detail/lightweight_test.hpp>
#include "test_macros.hpp"
#include "test_container.hpp"
#include <set>
#include "generic_multiset_test.hpp"
namespace boost { namespace intrusive { namespace test {
@@ -31,327 +25,34 @@ struct has_const_overloads<boost::intrusive::splay_multiset<T, O1, O2, O3, O4> >
static const bool value = false;
};
}}}
using namespace boost::intrusive;
template<class ValueTraits>
struct test_splay_multiset
template<class T, class O1, class O2, class O3, class O4>
struct has_splay<boost::intrusive::splay_multiset<T, O1, O2, O3, O4> >
{
typedef typename ValueTraits::value_type value_type;
static void test_all (std::vector<value_type>& values, bool splay);
static void test_sort(std::vector<value_type>& values, bool splay);
static void test_insert(std::vector<value_type>& values, bool splay);
static void test_swap(std::vector<value_type>& values, bool splay);
static void test_find(std::vector<value_type>& values, bool splay);
static void test_splay_up(std::vector<value_type>& values);
static void test_splay_down(std::vector<value_type>& values);
static void test_impl(bool splay);
static void test_clone(std::vector<value_type>& values, bool splay);
static void test_container_from_end(std::vector<value_type>& values, bool splay);
static const bool value = true;
};
template<class ValueTraits>
void test_splay_multiset<ValueTraits>::test_all
(std::vector<typename ValueTraits::value_type>& values, bool splay)
template<class T, class O1, class O2, class O3, class O4>
struct has_rebalance<boost::intrusive::splay_multiset<T, O1, O2, O3, O4> >
{
typedef typename ValueTraits::value_type value_type;
typedef splay_multiset
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> splay_multiset_type;
{
splay_multiset_type testset(values.begin(), values.end());
test::test_container(testset);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_common_unordered_and_associative_container(testset, values);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_associative_container(testset, values);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_non_unique_container(testset, values);
}
test_sort(values, splay);
test_insert(values, splay);
test_swap(values, splay);
test_find(values, splay);
test_splay_up(values);
test_splay_down(values);
test_impl(splay);
test_clone(values, splay);
test_container_from_end(values, splay);
}
static const bool value = true;
};
//test case due to an error in tree implementation:
template<class ValueTraits>
void test_splay_multiset<ValueTraits>::test_impl(bool splay)
}}}
template< class ValueType
, class Option1 = boost::intrusive::none
, class Option2 = boost::intrusive::none
, class Option3 = boost::intrusive::none
>
struct GetContainer
{
typedef typename ValueTraits::value_type value_type;
std::vector<value_type> values (5);
for (int i = 0; i < 5; ++i)
values[i].value_ = i;
typedef typename ValueTraits::value_type value_type;
typedef splay_multiset
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> multiset_type;
multiset_type testset;
for (int i = 0; i < 5; ++i)
testset.insert (values[i]);
testset.erase (testset.iterator_to (values[0]));
testset.erase (testset.iterator_to (values[1]));
testset.insert (values[1]);
testset.erase (testset.iterator_to (values[2]));
testset.erase (testset.iterator_to (values[3]));
}
//test: constructor, iterator, clear, reverse_iterator, front, back, size:
template<class ValueTraits>
void test_splay_multiset<ValueTraits>::test_sort
(std::vector<typename ValueTraits::value_type>& values, bool splay)
{
typedef typename ValueTraits::value_type value_type;
typedef splay_multiset
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> multiset_type;
multiset_type testset1 (values.begin(), values.end());
{ int init_values [] = { 1, 2, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
testset1.clear();
BOOST_TEST (testset1.empty());
typedef splay_multiset
<value_type
, compare<even_odd>
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> multiset_type2;
multiset_type2 testset2 (&values[0], &values[0] + 6);
{ int init_values [] = { 5, 3, 1, 4, 2, 2 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset2.rbegin() ); }
BOOST_TEST (testset2.begin()->value_ == 2);
BOOST_TEST (testset2.rbegin()->value_ == 5);
}
//test: insert, const_iterator, const_reverse_iterator, erase, iterator_to:
template<class ValueTraits>
void test_splay_multiset<ValueTraits>::test_insert
(std::vector<typename ValueTraits::value_type>& values, bool splay)
{
typedef typename ValueTraits::value_type value_type;
typedef splay_multiset
< value_type
, value_traits<ValueTraits>
, size_type<std::size_t>
, constant_time_size<value_type::constant_time_size>
> multiset_type;
multiset_type testset;
testset.insert(&values[0] + 2, &values[0] + 5);
{ int init_values [] = { 1, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset.begin() ); }
typename multiset_type::iterator i = testset.begin();
BOOST_TEST (i->value_ == 1);
i = testset.insert (i, values[0]);
BOOST_TEST (&*i == &values[0]);
{ int init_values [] = { 5, 4, 3, 1 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset.rbegin() ); }
i = testset.iterator_to (values[2]);
BOOST_TEST (&*i == &values[2]);
i = multiset_type::s_iterator_to (values[2]);
BOOST_TEST (&*i == &values[2]);
testset.erase(i);
{ int init_values [] = { 1, 3, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset.begin() ); }
}
//test: insert (seq-version), swap, erase (seq-version), size:
template<class ValueTraits>
void test_splay_multiset<ValueTraits>::test_swap
(std::vector<typename ValueTraits::value_type>& values, bool splay)
{
typedef typename ValueTraits::value_type value_type;
typedef splay_multiset
< value_type
, value_traits<ValueTraits>
, size_type<std::size_t>
, constant_time_size<value_type::constant_time_size>
> multiset_type;
multiset_type testset1 (&values[0], &values[0] + 2);
multiset_type testset2;
testset2.insert (&values[0] + 2, &values[0] + 6);
{ int init_values [] = { 1, 2, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset2.begin() ); }
{ int init_values [] = { 2, 3 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
testset1.swap (testset2);
{ int init_values [] = { 1, 2, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
{ int init_values [] = { 2, 3 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset2.begin() ); }
testset1.erase (testset1.iterator_to(values[5]), testset1.end());
BOOST_TEST (testset1.size() == 1);
BOOST_TEST (&*testset1.begin() == &values[3]);
}
template<class ValueTraits>
void test_splay_multiset<ValueTraits>::test_splay_up
(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef splay_multiset
< value_type
, value_traits<ValueTraits>
, size_type<std::size_t>
, constant_time_size<value_type::constant_time_size>
> multiset_type;
typedef typename multiset_type::iterator iterator;
typedef std::multiset<value_type> orig_multiset_t;
std::size_t num_values;
std::multiset<value_type> original_testset (values.begin(), values.end());
num_values = original_testset.size();
for(std::size_t i = 0; i != num_values; ++i){
multiset_type testset (values.begin(), values.end());
{
iterator it = testset.begin();
for(std::size_t j = 0; j != i; ++j, ++it){}
testset.splay_up(it);
}
BOOST_TEST (testset.size() == num_values);
iterator it = testset.begin();
for( typename orig_multiset_t::const_iterator origit = original_testset.begin()
, origitend = original_testset.end()
; origit != origitend
; ++origit, ++it){
BOOST_TEST(*origit == *it);
}
}
}
template<class ValueTraits>
void test_splay_multiset<ValueTraits>::test_splay_down
(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef splay_multiset
< value_type
, value_traits<ValueTraits>
, size_type<std::size_t>
, constant_time_size<value_type::constant_time_size>
> multiset_type;
typedef typename multiset_type::iterator iterator;
typedef std::multiset<value_type> orig_multiset_t;
std::size_t num_values;
std::multiset<value_type> original_testset (values.begin(), values.end());
num_values = original_testset.size();
for(std::size_t i = 0; i != num_values; ++i){
multiset_type testset (values.begin(), values.end());
{
iterator it = testset.begin();
for(std::size_t j = 0; j != i; ++j, ++it){}
BOOST_TEST(*it == *testset.splay_down(*it));
}
BOOST_TEST (testset.size() == num_values);
iterator it = testset.begin();
for( typename orig_multiset_t::const_iterator origit = original_testset.begin()
, origitend = original_testset.end()
; origit != origitend
; ++origit, ++it){
BOOST_TEST(*origit == *it);
}
}
}
//test: find, equal_range (lower_bound, upper_bound):
template<class ValueTraits>
void test_splay_multiset<ValueTraits>::test_find
(std::vector<typename ValueTraits::value_type>& values, bool splay)
{
typedef typename ValueTraits::value_type value_type;
typedef splay_multiset
< value_type
, value_traits<ValueTraits>
, size_type<std::size_t>
, constant_time_size<value_type::constant_time_size>
> multiset_type;
multiset_type testset (values.begin(), values.end());
typedef typename multiset_type::iterator iterator;
value_type cmp_val;
cmp_val.value_ = 2;
iterator i = testset.find (cmp_val);
BOOST_TEST (i->value_ == 2);
BOOST_TEST ((++i)->value_ == 2);
std::pair<iterator,iterator> range = testset.equal_range (cmp_val);
BOOST_TEST (range.first->value_ == 2);
BOOST_TEST (range.second->value_ == 3);
BOOST_TEST (std::distance (range.first, range.second) == 2);
cmp_val.value_ = 7;
BOOST_TEST (testset.find (cmp_val) == testset.end());
}
template<class ValueTraits>
void test_splay_multiset<ValueTraits>::test_clone
(std::vector<typename ValueTraits::value_type>& values, bool splay)
{
typedef typename ValueTraits::value_type value_type;
typedef splay_multiset
< value_type
, value_traits<ValueTraits>
, size_type<std::size_t>
, constant_time_size<value_type::constant_time_size>
> multiset_type;
multiset_type testmultiset1 (&values[0], &values[0] + values.size());
multiset_type testmultiset2;
testmultiset2.clone_from(testmultiset1, test::new_cloner<value_type>(), test::delete_disposer<value_type>());
BOOST_TEST (testmultiset2 == testmultiset1);
testmultiset2.clear_and_dispose(test::delete_disposer<value_type>());
BOOST_TEST (testmultiset2.empty());
}
template<class ValueTraits>
void test_splay_multiset<ValueTraits>::test_container_from_end
(std::vector<typename ValueTraits::value_type>& values, bool splay)
{
typedef typename ValueTraits::value_type value_type;
typedef splay_multiset
< value_type
, value_traits<ValueTraits>
, size_type<std::size_t>
, constant_time_size<value_type::constant_time_size>
> multiset_type;
multiset_type testmultiset (&values[0], &values[0] + values.size());
BOOST_TEST (testmultiset == multiset_type::container_from_end_iterator(testmultiset.end()));
BOOST_TEST (testmultiset == multiset_type::container_from_end_iterator(testmultiset.cend()));
}
typedef boost::intrusive::splay_multiset
< ValueType
, Option1
, Option2
, Option3
> type;
};
template<class VoidPointer, bool constant_time_size>
class test_main_template
@@ -359,27 +60,24 @@ class test_main_template
public:
int operator()()
{
for(int n = 0; n < 2; ++n){
typedef testvalue<VoidPointer, constant_time_size> value_type;
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
std::vector<testvalue<VoidPointer, constant_time_size> > data (6);
for (int i = 0; i < 6; ++i)
data[i].value_ = random_init[i];
using namespace boost::intrusive;
typedef testvalue<VoidPointer, constant_time_size> value_type;
test_splay_multiset < typename detail::get_base_value_traits
< value_type
, typename value_type::splay_set_base_hook_t
>::type
>::test_all(data, 0 != (n%2));
test_splay_multiset < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::splay_set_member_hook_t
, &value_type::splay_set_node_
>
>::type
>::test_all(data, 0 != (n%2));
}
test::test_generic_multiset < typename detail::get_base_value_traits
< value_type
, typename value_type::splay_set_base_hook_t
>::type
, GetContainer
>::test_all();
test::test_generic_multiset < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::splay_set_member_hook_t
, &value_type::splay_set_node_
>
>::type
, GetContainer
>::test_all();
return 0;
}
};
@@ -390,80 +88,51 @@ class test_main_template<VoidPointer, false>
public:
int operator()()
{
for(int n = 0; n < 2; ++n){
typedef testvalue<VoidPointer, false> value_type;
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
std::vector<testvalue<VoidPointer, false> > data (6);
for (int i = 0; i < 6; ++i)
data[i].value_ = random_init[i];
using namespace boost::intrusive;
typedef testvalue<VoidPointer, false> value_type;
test_splay_multiset < typename detail::get_base_value_traits
< value_type
, typename value_type::splay_set_base_hook_t
>::type
>::test_all(data, 0 != (n%2));
test::test_generic_multiset < typename detail::get_base_value_traits
< value_type
, typename value_type::splay_set_base_hook_t
>::type
, GetContainer
>::test_all();
test_splay_multiset < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::splay_set_member_hook_t
, &value_type::splay_set_node_
>
>::type
>::test_all(data, 0 != (n%2));
test::test_generic_multiset < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::splay_set_member_hook_t
, &value_type::splay_set_node_
>
>::type
, GetContainer
>::test_all();
test_splay_multiset < typename detail::get_base_value_traits
< value_type
, typename value_type::splay_set_auto_base_hook_t
>::type
>::test_all(data, 0 != (n%2));
test::test_generic_multiset < typename detail::get_base_value_traits
< value_type
, typename value_type::splay_set_auto_base_hook_t
>::type
, GetContainer
>::test_all();
test_splay_multiset < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::splay_set_auto_member_hook_t
, &value_type::splay_set_auto_node_
>
>::type
>::test_all(data, 0 != (n%2));
}
test::test_generic_multiset < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::splay_set_auto_member_hook_t
, &value_type::splay_set_auto_node_
>
>::type
, GetContainer
>::test_all();
return 0;
}
};
//Explicit instantiations of non-counted classes
//template class multiset
// <set_base_raw, std::less<set_base_raw::value_type>, false>;
//template class multiset
// <set_member_raw, std::less<set_member_raw::value_type>, false>;
//template class multiset
// <set_auto_base_raw, std::less<set_auto_base_raw::value_type>, false>;
//template class multiset
// <set_auto_member_raw, std::less<set_auto_member_raw::value_type>, false>;
//template class multiset
// <set_base_smart, std::less<set_base_smart::value_type>, false>;
//template class multiset
// <set_member_smart, std::less<set_member_smart::value_type>, false>;
//template class multiset
// <set_auto_base_smart, std::less<set_auto_base_smart::value_type>, false>;
//template class multiset
// <set_auto_member_smart, std::less<set_auto_member_smart::value_type>, false>;
//Explicit instantiation of counted classes
//template class multiset
// <set_base_raw_t, std::less<set_base_raw_t::value_type>, true>;
//template class multiset
// <set_member_raw_t, std::less<set_member_raw_t::value_type>, true>;
//template class multiset
// <set_base_smart_t, std::less<set_base_smart_t::value_type>, true>;
//template class multiset
// <set_member_smart_t, std::less<set_member_smart_t::value_type>, true>;
int main( int, char* [] )
{
test_main_template<void*, false>()();
test_main_template<smart_ptr<void>, false>()();
test_main_template<boost::intrusive::smart_ptr<void>, false>()();
test_main_template<void*, true>()();
test_main_template<smart_ptr<void>, true>()();
test_main_template<boost::intrusive::smart_ptr<void>, true>()();
return boost::report_errors();
}
test/splay_set_test.cpp
+44 -331
View File
@@ -11,15 +11,9 @@
/////////////////////////////////////////////////////////////////////////////
#include <boost/intrusive/detail/config_begin.hpp>
#include <boost/intrusive/splay_set.hpp>
#include <boost/intrusive/detail/pointer_to_other.hpp>
#include "itestvalue.hpp"
#include "smart_ptr.hpp"
#include "common_functors.hpp"
#include <vector>
#include <boost/detail/lightweight_test.hpp>
#include "test_macros.hpp"
#include "test_container.hpp"
#include <set>
#include "generic_set_test.hpp"
namespace boost { namespace intrusive { namespace test {
@@ -29,315 +23,34 @@ struct has_const_overloads<boost::intrusive::splay_set<T, O1, O2, O3, O4> >
static const bool value = false;
};
}}}
using namespace boost::intrusive;
template<class ValueTraits>
struct test_splay_set
template<class T, class O1, class O2, class O3, class O4>
struct has_splay<boost::intrusive::splay_set<T, O1, O2, O3, O4> >
{
typedef typename ValueTraits::value_type value_type;
static void test_all(std::vector<value_type>& values);
static void test_sort(std::vector<value_type>& values);
static void test_insert(std::vector<value_type>& values);
static void test_swap(std::vector<value_type>& values);
static void test_find(std::vector<value_type>& values);
static void test_splay_up(std::vector<value_type>& values);
static void test_splay_down(std::vector<value_type>& values);
static void test_impl();
static void test_clone(std::vector<value_type>& values);
static void test_container_from_end(std::vector<value_type>& values);
static const bool value = true;
};
template<class ValueTraits>
void test_splay_set<ValueTraits>::test_all(std::vector<typename ValueTraits::value_type>& values)
template<class T, class O1, class O2, class O3, class O4>
struct has_rebalance<boost::intrusive::splay_set<T, O1, O2, O3, O4> >
{
typedef typename ValueTraits::value_type value_type;
typedef splay_set
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> splay_set_type;
{
splay_set_type testset(values.begin(), values.end());
test::test_container(testset);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_common_unordered_and_associative_container(testset, values);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_associative_container(testset, values);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_unique_container(testset, values);
}
static const bool value = true;
};
test_sort(values);
test_insert(values);
test_swap(values);
test_find(values);
test_splay_up(values);
test_splay_down(values);
test_impl();
test_clone(values);
test_container_from_end(values);
}
}}}
//test case due to an error in tree implementation:
template<class ValueTraits>
void test_splay_set<ValueTraits>::test_impl()
template< class ValueType
, class Option1 = boost::intrusive::none
, class Option2 = boost::intrusive::none
, class Option3 = boost::intrusive::none
>
struct GetContainer
{
typedef typename ValueTraits::value_type value_type;
std::vector<value_type> values (5);
for (int i = 0; i < 5; ++i)
values[i].value_ = i;
typedef typename ValueTraits::value_type value_type;
typedef splay_set
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> splay_set_type;
splay_set_type testset;
for (int i = 0; i < 5; ++i)
testset.insert (values[i]);
testset.erase (testset.iterator_to (values[0]));
testset.erase (testset.iterator_to (values[1]));
testset.insert (values[1]);
testset.erase (testset.iterator_to (values[2]));
testset.erase (testset.iterator_to (values[3]));
}
//test: constructor, iterator, clear, reverse_iterator, front, back, size:
template<class ValueTraits>
void test_splay_set<ValueTraits>::test_sort(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef splay_set
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> splay_set_type;
splay_set_type testset1 (values.begin(), values.end());
{ int init_values [] = { 1, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
testset1.clear();
BOOST_TEST (testset1.empty());
typedef typename ValueTraits::value_type value_type;
typedef splay_set
< value_type
, compare<even_odd>
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> set_type2;
set_type2 testset2 (&values[0], &values[0] + 6);
{ int init_values [] = { 5, 3, 1, 4, 2 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset2.rbegin() ); }
BOOST_TEST (testset2.begin()->value_ == 2);
BOOST_TEST (testset2.rbegin()->value_ == 5);
}
//test: insert, const_iterator, const_reverse_iterator, erase, s_iterator_to:
template<class ValueTraits>
void test_splay_set<ValueTraits>::test_insert(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef splay_set
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> splay_set_type;
splay_set_type testset;
testset.insert(&values[0] + 2, &values[0] + 5);
const splay_set_type& const_testset = testset;
{ int init_values [] = { 1, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, const_testset.begin() ); }
typename splay_set_type::iterator i = testset.begin();
BOOST_TEST (i->value_ == 1);
i = testset.insert (i, values[0]);
BOOST_TEST (&*i == &values[0]);
{ int init_values [] = { 5, 4, 3, 1 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset.rbegin() ); }
i = testset.iterator_to (values[2]);
BOOST_TEST (&*i == &values[2]);
i = splay_set_type::s_iterator_to(values[2]);
BOOST_TEST (&*i == &values[2]);
testset.erase (i);
{ int init_values [] = { 1, 3, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset.begin() ); }
}
//test: insert (seq-version), swap, erase (seq-version), size:
template<class ValueTraits>
void test_splay_set<ValueTraits>::test_swap(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef splay_set
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> splay_set_type;
splay_set_type testset1 (&values[0], &values[0] + 2);
splay_set_type testset2;
testset2.insert (&values[0] + 2, &values[0] + 6);
testset1.swap (testset2);
{ int init_values [] = { 1, 2, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
{ int init_values [] = { 2, 3 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset2.begin() ); }
testset1.erase (testset1.iterator_to(values[5]), testset1.end());
BOOST_TEST (testset1.size() == 1);
// BOOST_TEST (&testset1.front() == &values[3]);
BOOST_TEST (&*testset1.begin() == &values[3]);
}
template<class ValueTraits>
void test_splay_set<ValueTraits>::test_splay_up
(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef splay_set
< value_type
, value_traits<ValueTraits>
, size_type<std::size_t>
, constant_time_size<value_type::constant_time_size>
> set_type;
typedef typename set_type::iterator iterator;
typedef std::set<value_type> orig_set_t;
std::size_t num_values;
std::set<value_type> original_testset (values.begin(), values.end());
num_values = original_testset.size();
for(std::size_t i = 0; i != num_values; ++i){
set_type testset (values.begin(), values.end());
{
iterator it = testset.begin();
for(std::size_t j = 0; j != i; ++j, ++it){}
testset.splay_up(it);
}
BOOST_TEST (testset.size() == num_values);
iterator it = testset.begin();
for( typename orig_set_t::const_iterator origit = original_testset.begin()
, origitend = original_testset.end()
; origit != origitend
; ++origit, ++it){
BOOST_TEST(*origit == *it);
}
}
}
template<class ValueTraits>
void test_splay_set<ValueTraits>::test_splay_down
(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef splay_set
< value_type
, value_traits<ValueTraits>
, size_type<std::size_t>
, constant_time_size<value_type::constant_time_size>
> set_type;
typedef typename set_type::iterator iterator;
typedef std::set<value_type> orig_set_t;
std::size_t num_values;
std::set<value_type> original_testset (values.begin(), values.end());
num_values = original_testset.size();
for(std::size_t i = 0; i != num_values; ++i){
set_type testset (values.begin(), values.end());
BOOST_TEST(testset.size() == num_values);
{
iterator it = testset.begin();
for(std::size_t j = 0; j != i; ++j, ++it){}
BOOST_TEST(*it == *testset.splay_down(*it));
}
BOOST_TEST (testset.size() == num_values);
iterator it = testset.begin();
for( typename orig_set_t::const_iterator origit = original_testset.begin()
, origitend = original_testset.end()
; origit != origitend
; ++origit, ++it){
BOOST_TEST(*origit == *it);
}
}
}
//test: find, equal_range (lower_bound, upper_bound):
template<class ValueTraits>
void test_splay_set<ValueTraits>::test_find(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef splay_set
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> splay_set_type;
splay_set_type testset (values.begin(), values.end());
typedef typename splay_set_type::iterator iterator;
value_type cmp_val;
cmp_val.value_ = 2;
iterator i = testset.find (cmp_val);
BOOST_TEST (i->value_ == 2);
BOOST_TEST ((++i)->value_ != 2);
std::pair<iterator,iterator> range = testset.equal_range (cmp_val);
BOOST_TEST (range.first->value_ == 2);
BOOST_TEST (range.second->value_ == 3);
BOOST_TEST (std::distance (range.first, range.second) == 1);
cmp_val.value_ = 7;
BOOST_TEST (testset.find (cmp_val) == testset.end());
}
template<class ValueTraits>
void test_splay_set<ValueTraits>
::test_clone(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef splay_set
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> splay_set_type;
splay_set_type testset1 (&values[0], &values[0] + values.size());
splay_set_type testset2;
testset2.clone_from(testset1, test::new_cloner<value_type>(), test::delete_disposer<value_type>());
BOOST_TEST (testset2 == testset1);
testset2.clear_and_dispose(test::delete_disposer<value_type>());
BOOST_TEST (testset2.empty());
}
template<class ValueTraits>
void test_splay_set<ValueTraits>
::test_container_from_end(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type value_type;
typedef splay_set
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> splay_set_type;
splay_set_type testset (&values[0], &values[0] + values.size());
BOOST_TEST (testset == splay_set_type::container_from_end_iterator(testset.end()));
BOOST_TEST (testset == splay_set_type::container_from_end_iterator(testset.cend()));
}
typedef boost::intrusive::splay_set
< ValueType
, Option1
, Option2
, Option3
> type;
};
template<class VoidPointer, bool constant_time_size>
class test_main_template
@@ -345,25 +58,24 @@ class test_main_template
public:
int operator()()
{
using namespace boost::intrusive;
typedef testvalue<VoidPointer, constant_time_size> value_type;
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
std::vector<testvalue<VoidPointer, constant_time_size> > data (6);
for (int i = 0; i < 6; ++i)
data[i].value_ = random_init[i];
test_splay_set < typename detail::get_base_value_traits
test::test_generic_set < typename detail::get_base_value_traits
< value_type
, typename value_type::splay_set_base_hook_t
>::type
>::test_all(data);
test_splay_set < typename detail::get_member_value_traits
, GetContainer
>::test_all();
test::test_generic_set < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::splay_set_member_hook_t
, &value_type::splay_set_node_
>
>::type
>::test_all(data);
, GetContainer
>::test_all();
return 0;
}
};
@@ -374,41 +86,42 @@ class test_main_template<VoidPointer, false>
public:
int operator()()
{
using namespace boost::intrusive;
typedef testvalue<VoidPointer, false> value_type;
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
std::vector<testvalue<VoidPointer, false> > data (6);
for (int i = 0; i < 6; ++i)
data[i].value_ = random_init[i];
test_splay_set < typename detail::get_base_value_traits
test::test_generic_set < typename detail::get_base_value_traits
< value_type
, typename value_type::splay_set_base_hook_t
>::type
>::test_all(data);
, GetContainer
>::test_all();
test_splay_set < typename detail::get_member_value_traits
test::test_generic_set < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::splay_set_member_hook_t
, &value_type::splay_set_node_
>
>::type
>::test_all(data);
, GetContainer
>::test_all();
test_splay_set < typename detail::get_base_value_traits
test::test_generic_set < typename detail::get_base_value_traits
< value_type
, typename value_type::splay_set_auto_base_hook_t
>::type
>::test_all(data);
, GetContainer
>::test_all();
test_splay_set < typename detail::get_member_value_traits
test::test_generic_set < typename detail::get_member_value_traits
< value_type
, member_hook< value_type
, typename value_type::splay_set_auto_member_hook_t
, &value_type::splay_set_auto_node_
>
>::type
>::test_all(data);
, GetContainer
>::test_all();
return 0;
}
@@ -417,9 +130,9 @@ class test_main_template<VoidPointer, false>
int main( int, char* [] )
{
test_main_template<void*, false>()();
test_main_template<smart_ptr<void>, false>()();
test_main_template<boost::intrusive::smart_ptr<void>, false>()();
test_main_template<void*, true>()();
test_main_template<smart_ptr<void>, true>()();
test_main_template<boost::intrusive::smart_ptr<void>, true>()();
return boost::report_errors();
}
#include <boost/intrusive/detail/config_end.hpp>
test/stateful_value_traits_test.cpp
+1 -2
View File
@@ -117,8 +117,7 @@ int main()
, slist_traits(values, uset_hook_array)
);
//Now insert them in the reverse order
//in the base hook intrusive list
//Now insert them in containers
for(MyClass * it(&values[0]), *itend(&values[NumElements])
; it != itend
; ++it){
test/test_container.hpp
+2 -2
View File
@@ -185,7 +185,7 @@ void test_associative_container_invariants(Container & c, Data & d, boost::intru
}
template< class Container, class Data >
void test_associative_container_invariants(Container & c, Data & d, boost::intrusive::detail::false_type)
void test_associative_container_invariants(Container &, Data &, boost::intrusive::detail::false_type)
{}
template< class Container, class Data >
@@ -245,7 +245,7 @@ void test_unordered_associative_container_invariants(Container & c, Data & d, bo
}
template< class Container, class Data >
void test_unordered_associative_container_invariants(Container & c, Data & d, boost::intrusive::detail::false_type)
void test_unordered_associative_container_invariants(Container &, Data &, boost::intrusive::detail::false_type)
{}
template< class Container, class Data >