void test_generic_set<ValueTraits, ContainerDefiner>::test_swap(value_cont_type& values)
{
typedef typename ValueTraits::value_type value_type;
typedef ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> definer_function;
typedef typename definer_function::type set_type;
set_type testset1 (values.begin(), values.begin() + 2);
set_type testset2;
testset2.insert (values.begin() + 2, values.begin() + 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]);
}
void test_generic_set<ValueTraits, ContainerDefiner>::test_sort(value_cont_type& values)
{
typedef typename ValueTraits::value_type value_type;
typedef ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> definer_function;
typedef typename definer_function::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 ContainerDefiner
< value_type
, compare<even_odd>
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> definer_function2;
typedef typename definer_function2::type set_type2;
set_type2 testset2 (values.begin(), values.begin() + 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);
}
void test_generic_assoc<ValueTraits, ContainerDefiner>::test_splay_down
(value_cont_type& values, detail::true_type)
{
typedef typename ContainerDefiner::template container
<>::type assoc_type;
typedef typename assoc_type::iterator iterator;
typedef value_cont_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 = value_cont_type(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);
}
}
}
void test_generic_multiset<ValueTraits, ContainerDefiner>::test_insert(value_cont_type& values)
{
typedef typename ValueTraits::value_type value_type;
typedef ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> definer_function;
typedef typename definer_function::type multiset_type;
multiset_type testset;
testset.insert(values.begin() + 2, values.begin() + 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() ); }
}
void test_generic_assoc<ValueTraits, ContainerDefiner>
::test_container_from_end(value_cont_type& values, detail::true_type)
{
typedef typename ContainerDefiner::template container
<>::type assoc_type;
assoc_type testset (values.begin(), values.begin() + values.size());
BOOST_TEST (testset == assoc_type::container_from_end_iterator(testset.end()));
BOOST_TEST (testset == assoc_type::container_from_end_iterator(testset.cend()));
}
void test_generic_assoc<ValueTraits, ContainerDefiner>::test_rebalance
(value_cont_type& values, detail::true_type)
{
typedef typename ContainerDefiner::template container
<>::type assoc_type;
typedef value_cont_type orig_set_t;
orig_set_t original_testset;
{
assoc_type testset (values.begin(), values.end());
original_testset.assign(testset.begin(), testset.end());
}
{
assoc_type testset(values.begin(), values.end());
testset.rebalance();
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());
}
}
}
void test_generic_set<ValueTraits, ContainerDefiner>::test_insert_advanced
(value_cont_type& values, detail::false_type)
{
typedef typename ValueTraits::value_type value_type;
typedef ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> definer_function;
typedef typename definer_function::type set_type;
{
set_type testset;
testset.insert(values.begin(), values.begin() + values.size());
value_type v(1);
typename set_type::insert_commit_data data;
BOOST_TEST (!testset.insert_check(v, testset.value_comp(), data).second);
BOOST_TEST (!testset.insert_check(testset.begin(), v, testset.value_comp(), data).second);
}
}
void test_generic_assoc<ValueTraits, ContainerDefiner>::
test_container_from_iterator(value_cont_type& values, detail::true_type)
{
typedef typename ContainerDefiner::template container
<>::type assoc_type;
assoc_type testset(values.begin(), values.end());
typedef typename assoc_type::iterator it_type;
typedef typename assoc_type::const_iterator cit_type;
typedef typename assoc_type::size_type sz_type;
sz_type sz = testset.size();
for(it_type b(testset.begin()), e(testset.end()); b != e; ++b)
{
assoc_type &s = assoc_type::container_from_iterator(b);
const assoc_type &cs = assoc_type::container_from_iterator(cit_type(b));
BOOST_TEST(&s == &cs);
BOOST_TEST(&s == &testset);
s.erase(b);
BOOST_TEST(testset.size() == (sz-1));
s.insert(*b);
BOOST_TEST(testset.size() == sz);
}
}
void test_generic_assoc<ValueTraits, ContainerDefiner>
::test_clone(value_cont_type& values)
{
{
typedef typename ContainerDefiner::template container
<>::type assoc_type;
assoc_type testset1 (values.begin(), values.begin() + values.size());
assoc_type testset2;
typedef typename assoc_type::size_type size_type;
size_type const testset1_oldsize = testset1.size();
testset2.clone_from(testset1, test::new_cloner<value_type>(), test::delete_disposer<value_type>());
BOOST_TEST (testset1.size() == testset1_oldsize);
BOOST_TEST (testset2 == testset1);
testset2.clear_and_dispose(test::delete_disposer<value_type>());
BOOST_TEST (testset2.empty());
//Now test move clone
testset2.clone_from(boost::move(testset1), test::new_nonconst_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());
}
}
void test_generic_set<ValueTraits, ContainerDefiner>::test_find(value_cont_type& values)
{
typedef typename ValueTraits::value_type value_type;
typedef ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> definer_function;
typedef typename definer_function::type set_type;
set_type testset (values.begin(), values.end());
typedef typename set_type::iterator iterator;
{
//value_type cmp_val;
value_cont_type cmp_val_cont(1);
reference cmp_val = cmp_val_cont.front();
(&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 (boost::intrusive::iterator_distance (range.first, range.second) == 1);
(&cmp_val)->value_ = 7;
BOOST_TEST (testset.find (cmp_val) == testset.end());
}
{
typename search_const_container<set_type>::type &const_testset = testset;
std::pair<iterator,iterator> range;
std::pair<typename search_const_iterator<set_type>::type
,typename search_const_iterator<set_type>::type> const_range;
//value_type cmp_val_lower, cmp_val_upper;
value_cont_type cmp_val_cont(2);
reference cmp_val_lower = cmp_val_cont.front();
reference cmp_val_upper = cmp_val_cont.back();
{
(&cmp_val_lower)->value_ = 1;
(&cmp_val_upper)->value_ = 2;
//left-closed, right-closed
range = testset.bounded_range (cmp_val_lower, cmp_val_upper, true, true);
BOOST_TEST (range.first->value_ == 1);
BOOST_TEST (range.second->value_ == 3);
BOOST_TEST (boost::intrusive::iterator_distance (range.first, range.second) == 2);
}
{
(&cmp_val_lower)->value_ = 1;
(&cmp_val_upper)->value_ = 2;
const_range = const_testset.bounded_range (cmp_val_lower, cmp_val_upper, true, false);
BOOST_TEST (const_range.first->value_ == 1);
BOOST_TEST (const_range.second->value_ == 2);
BOOST_TEST (boost::intrusive::iterator_distance (const_range.first, const_range.second) == 1);
(&cmp_val_lower)->value_ = 1;
(&cmp_val_upper)->value_ = 3;
range = testset.bounded_range (cmp_val_lower, cmp_val_upper, true, false);
BOOST_TEST (range.first->value_ == 1);
BOOST_TEST (range.second->value_ == 3);
BOOST_TEST (boost::intrusive::iterator_distance (range.first, range.second) == 2);
}
{
(&cmp_val_lower)->value_ = 1;
(&cmp_val_upper)->value_ = 2;
const_range = const_testset.bounded_range (cmp_val_lower, cmp_val_upper, false, true);
BOOST_TEST (const_range.first->value_ == 2);
BOOST_TEST (const_range.second->value_ == 3);
BOOST_TEST (boost::intrusive::iterator_distance (const_range.first, const_range.second) == 1);
}
{
(&cmp_val_lower)->value_ = 1;
(&cmp_val_upper)->value_ = 2;
range = testset.bounded_range (cmp_val_lower, cmp_val_upper, false, false);
BOOST_TEST (range.first->value_ == 2);
BOOST_TEST (range.second->value_ == 2);
BOOST_TEST (boost::intrusive::iterator_distance (range.first, range.second) == 0);
}
{
(&cmp_val_lower)->value_ = 5;
(&cmp_val_upper)->value_ = 6;
const_range = const_testset.bounded_range (cmp_val_lower, cmp_val_upper, true, false);
BOOST_TEST (const_range.first->value_ == 5);
BOOST_TEST (const_range.second == const_testset.end());
BOOST_TEST (boost::intrusive::iterator_distance (const_range.first, const_range.second) == 1);
}
}
}
void test_generic_assoc<ValueTraits, ContainerDefiner>::test_insert_before
(value_cont_type& values, detail::true_type)
{
typedef typename ContainerDefiner::template container
<>::type assoc_type;
{
assoc_type testset;
typedef typename value_cont_type::iterator vec_iterator;
for(vec_iterator it(values.begin()), itend(values.end())
; it != itend
; ++it){
testset.push_back(*it);
}
BOOST_TEST(testset.size() == values.size());
TEST_INTRUSIVE_SEQUENCE_EXPECTED(values, testset.begin());
}
{
assoc_type testset;
typedef typename value_cont_type::iterator vec_iterator;
for(vec_iterator it(--values.end()); true; --it){
testset.push_front(*it);
if(it == values.begin()){
break;
}
}
BOOST_TEST(testset.size() == values.size());
TEST_INTRUSIVE_SEQUENCE_EXPECTED(values, testset.begin());
}
{
assoc_type testset;
typedef typename value_cont_type::iterator vec_iterator;
typename assoc_type::iterator it_pos =
testset.insert_before(testset.end(), *values.rbegin());
testset.insert_before(testset.begin(), *values.begin());
for(vec_iterator it(++values.begin()), itend(--values.end())
; it != itend
; ++it){
testset.insert_before(it_pos, *it);
}
BOOST_TEST(testset.size() == values.size());
TEST_INTRUSIVE_SEQUENCE_EXPECTED(values, testset.begin());
}
}
