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

Introducing allocator_traits and pointer_traits changes into several libraries.

Browse Source 
[SVN r76107]
This commit is contained in:
Ion Gaztañaga
2011-12-22 20:15:57 +00:00
parent 8a53a5af27
commit b6ca309fe2
24 changed files with 1269 additions and 189 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/unordered_multiset_test.cpp
+97 -33
View File
@@ -12,7 +12,7 @@
/////////////////////////////////////////////////////////////////////////////
#include <boost/intrusive/detail/config_begin.hpp>
#include <boost/intrusive/unordered_set.hpp>
#include <boost/intrusive/detail/pointer_to_other.hpp>
#include <boost/intrusive/pointer_traits.hpp>
#include "itestvalue.hpp"
#include "smart_ptr.hpp"
#include "common_functors.hpp"
@@ -102,7 +102,9 @@ void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash, Incremental>:
{
typedef typename unordered_multiset_type::bucket_traits bucket_traits;
typename unordered_multiset_type::bucket_type buckets [BucketSize];
unordered_multiset_type testset(bucket_traits(buckets, BucketSize));
unordered_multiset_type testset
(bucket_traits(pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets[0]), BucketSize));
testset.insert(values.begin(), values.end());
test::test_container(testset);
testset.clear();
@@ -145,7 +147,9 @@ void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash, Incremental>
values[i].value_ = i;
typename unordered_multiset_type::bucket_type buckets [BucketSize];
unordered_multiset_type testset(bucket_traits(buckets, BucketSize));
unordered_multiset_type testset(bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets[0]), BucketSize));
for (int i = 0; i < 5; ++i)
testset.insert (values[i]);
@@ -175,7 +179,10 @@ void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash, Incremental>
typedef typename unordered_multiset_type::bucket_traits bucket_traits;
typename unordered_multiset_type::bucket_type buckets [BucketSize];
unordered_multiset_type testset1(values.begin(), values.end(), bucket_traits(buckets, BucketSize));
unordered_multiset_type testset1
(values.begin(), values.end(), bucket_traits
(pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets[0]), BucketSize));
if(Incremental){
{ int init_values [] = { 4, 5, 1, 2, 2, 3 };
@@ -206,7 +213,9 @@ void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash, Incremental>
typedef typename unordered_multiset_type::bucket_traits bucket_traits;
typedef typename unordered_multiset_type::iterator iterator;
typename unordered_multiset_type::bucket_type buckets [BucketSize];
unordered_multiset_type testset(bucket_traits(buckets, BucketSize));
unordered_multiset_type testset(bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets[0]), BucketSize));
testset.insert(&values[0] + 2, &values[0] + 5);
@@ -244,7 +253,9 @@ void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash, Incremental>
//Now with a single bucket
typename unordered_multiset_type::bucket_type single_bucket[1];
unordered_multiset_type testset2(bucket_traits(single_bucket, 1));
unordered_multiset_type testset2(bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(single_bucket[0]), 1));
testset2.insert(&values[0], &values[0] + values.size());
BOOST_TEST (testset2.erase(5) == 1);
BOOST_TEST (testset2.erase(2) == 2);
@@ -286,7 +297,9 @@ void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash, Incremental>
//Now with a single bucket
typename unordered_multiset_type::bucket_type single_bucket[1];
unordered_multiset_type testset2(bucket_traits(single_bucket, 1));
unordered_multiset_type testset2(bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(single_bucket[0]), 1));
testset2.insert(&values[0], &values[0] + values.size());
BOOST_TEST (testset2.erase(5) == 1);
BOOST_TEST (testset2.erase(2) == 2);
@@ -305,7 +318,9 @@ void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash, Incremental>
std::vector<typename ValueTraits::value_type> data (random_size);
for (unsigned int j = 0; j < random_size; ++j)
data[j].value_ = random_init[j];
unordered_multiset_type testset_new(bucket_traits(single_bucket, 1));
unordered_multiset_type testset_new(bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(single_bucket[0]), 1));
testset_new.insert(&data[0], &data[0]+max);
testset_new.erase(testset_new.iterator_to(data[i]));
BOOST_TEST (testset_new.size() == (max -1));
@@ -332,7 +347,8 @@ void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash, Incremental>
unordered_multiset_type testset
( &random_init[0]
, &random_init[0] + random_init.size()
, bucket_traits(buckets, NumBucketSize));
, bucket_traits(pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets[0]), NumBucketSize));
BOOST_TEST (testset.size() == random_init.size());
@@ -394,8 +410,12 @@ void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash, Incremental>:
typename unordered_multiset_type::bucket_type buckets [BucketSize];
typename unordered_multiset_type::bucket_type buckets2 [BucketSize];
unordered_multiset_type testset1(&values[0], &values[0] + 2, bucket_traits(buckets, BucketSize));
unordered_multiset_type testset2(bucket_traits(buckets2, BucketSize));
unordered_multiset_type testset1(&values[0], &values[0] + 2,
bucket_traits(pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets[0]), BucketSize));
unordered_multiset_type testset2(bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets2[0]), BucketSize));
testset2.insert (&values[0] + 2, &values[0] + 6);
testset1.swap (testset2);
@@ -445,7 +465,9 @@ void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash, Incremental>
//Build a uset
typename unordered_multiset_type::bucket_type buckets1 [BucketSize];
typename unordered_multiset_type::bucket_type buckets2 [BucketSize*2];
unordered_multiset_type testset1(&values[0], &values[0] + values.size(), bucket_traits(buckets1, BucketSize));
unordered_multiset_type testset1(&values[0], &values[0] + values.size(),
bucket_traits(pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets1[0]), BucketSize));
//Test current state
BOOST_TEST(testset1.split_count() == BucketSize/2);
{ int init_values [] = { 4, 5, 1, 2, 2, 3 };
@@ -472,21 +494,27 @@ void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash, Incremental>
//Try incremental hashing specifying a new bucket traits pointing to the same array
//
//This incremental rehash should fail because the new size is not twice the original
BOOST_TEST(testset1.incremental_rehash(bucket_traits(buckets1, BucketSize)) == false);
BOOST_TEST(testset1.incremental_rehash(bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets1[0]), BucketSize)) == false);
BOOST_TEST(testset1.split_count() == BucketSize);
{ int init_values [] = { 1, 2, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
//This incremental rehash should success because the new size is twice the original
//and split_count is the same as the old bucket count
BOOST_TEST(testset1.incremental_rehash(bucket_traits(buckets1, BucketSize*2)) == true);
BOOST_TEST(testset1.incremental_rehash(bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets1[0]), BucketSize*2)) == true);
BOOST_TEST(testset1.split_count() == BucketSize);
{ int init_values [] = { 1, 2, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
//This incremental rehash should also success because the new size is half the original
//and split_count is the same as the new bucket count
BOOST_TEST(testset1.incremental_rehash(bucket_traits(buckets1, BucketSize)) == true);
BOOST_TEST(testset1.incremental_rehash(bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets1[0]), BucketSize)) == true);
BOOST_TEST(testset1.split_count() == BucketSize);
{ int init_values [] = { 1, 2, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
@@ -495,39 +523,51 @@ void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash, Incremental>
//Try incremental hashing specifying a new bucket traits pointing to the same array
//
//This incremental rehash should fail because the new size is not twice the original
BOOST_TEST(testset1.incremental_rehash(bucket_traits(buckets2, BucketSize)) == false);
BOOST_TEST(testset1.incremental_rehash(bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets2[0]), BucketSize)) == false);
BOOST_TEST(testset1.split_count() == BucketSize);
{ int init_values [] = { 1, 2, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
//This incremental rehash should success because the new size is twice the original
//and split_count is the same as the old bucket count
BOOST_TEST(testset1.incremental_rehash(bucket_traits(buckets2, BucketSize*2)) == true);
BOOST_TEST(testset1.incremental_rehash(bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets2[0]), BucketSize*2)) == true);
BOOST_TEST(testset1.split_count() == BucketSize);
{ int init_values [] = { 1, 2, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
//This incremental rehash should also success because the new size is half the original
//and split_count is the same as the new bucket count
BOOST_TEST(testset1.incremental_rehash(bucket_traits(buckets1, BucketSize)) == true);
BOOST_TEST(testset1.incremental_rehash(bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets1[0]), BucketSize)) == true);
BOOST_TEST(testset1.split_count() == BucketSize);
{ int init_values [] = { 1, 2, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
//Full shrink rehash
testset1.rehash(bucket_traits(buckets1, 4));
testset1.rehash(bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets1[0]), 4));
BOOST_TEST (testset1.size() == values.size());
BOOST_TEST (testset1.incremental_rehash() == false);
{ int init_values [] = { 4, 5, 1, 2, 2, 3 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
//Full shrink rehash again
testset1.rehash(bucket_traits(buckets1, 2));
testset1.rehash(bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets1[0]), 2));
BOOST_TEST (testset1.size() == values.size());
BOOST_TEST (testset1.incremental_rehash() == false);
{ int init_values [] = { 2, 2, 4, 3, 5, 1 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
//Full growing rehash
testset1.rehash(bucket_traits(buckets1, BucketSize));
testset1.rehash(bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets1[0]), BucketSize));
BOOST_TEST (testset1.size() == values.size());
BOOST_TEST (testset1.incremental_rehash() == false);
{ int init_values [] = { 1, 2, 2, 3, 4, 5 };
@@ -575,29 +615,39 @@ void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash, Incremental>
typename unordered_multiset_type::bucket_type buckets2 [2];
typename unordered_multiset_type::bucket_type buckets3 [BucketSize*2];
unordered_multiset_type testset1(&values[0], &values[0] + 6, bucket_traits(buckets1, BucketSize));
unordered_multiset_type testset1(&values[0], &values[0] + 6, bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets1[0]), BucketSize));
BOOST_TEST (testset1.size() == values.size());
{ int init_values [] = { 1, 2, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
testset1.rehash(bucket_traits(buckets2, 2));
testset1.rehash(bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets2[0]), 2));
BOOST_TEST (testset1.size() == values.size());
{ int init_values [] = { 4, 2, 2, 5, 3, 1 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
testset1.rehash(bucket_traits(buckets3, BucketSize*2));
testset1.rehash(bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets3[0]), BucketSize*2));
BOOST_TEST (testset1.size() == values.size());
{ int init_values [] = { 1, 2, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
//Now rehash reducing the buckets
testset1.rehash(bucket_traits(buckets3, 2));
testset1.rehash(bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets3[0]), 2));
BOOST_TEST (testset1.size() == values.size());
{ int init_values [] = { 4, 2, 2, 5, 3, 1 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
//Now rehash increasing the buckets
testset1.rehash(bucket_traits(buckets3, BucketSize*2));
testset1.rehash(bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets3[0]), BucketSize*2));
BOOST_TEST (testset1.size() == values.size());
{ int init_values [] = { 1, 2, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
@@ -620,7 +670,9 @@ void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash, Incremental>:
typedef typename unordered_multiset_type::bucket_traits bucket_traits;
typename unordered_multiset_type::bucket_type buckets[BucketSize];
unordered_multiset_type testset(values.begin(), values.end(), bucket_traits(buckets, BucketSize));
unordered_multiset_type testset(values.begin(), values.end(), bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets[0]), BucketSize));
typedef typename unordered_multiset_type::iterator iterator;
@@ -658,8 +710,12 @@ void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash, Incremental>
//Test with equal bucket arrays
typename unordered_multiset_type::bucket_type buckets1 [BucketSize];
typename unordered_multiset_type::bucket_type buckets2 [BucketSize];
unordered_multiset_type testset1 (values.begin(), values.end(), bucket_traits(buckets1, BucketSize));
unordered_multiset_type testset2 (bucket_traits(buckets2, BucketSize));
unordered_multiset_type testset1 (values.begin(), values.end(), bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets1[0]), BucketSize));
unordered_multiset_type testset2 (bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets2[0]), BucketSize));
testset2.clone_from(testset1, test::new_cloner<value_type>(), test::delete_disposer<value_type>());
//Ordering is not guarantee in the cloning so insert data in a set and test
@@ -675,8 +731,12 @@ void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash, Incremental>
//Test with bigger source bucket arrays
typename unordered_multiset_type::bucket_type buckets1 [BucketSize*2];
typename unordered_multiset_type::bucket_type buckets2 [BucketSize];
unordered_multiset_type testset1 (values.begin(), values.end(), bucket_traits(buckets1, BucketSize*2));
unordered_multiset_type testset2 (bucket_traits(buckets2, BucketSize));
unordered_multiset_type testset1 (values.begin(), values.end(), bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets1[0]), BucketSize*2));
unordered_multiset_type testset2 (bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets2[0]), BucketSize));
testset2.clone_from(testset1, test::new_cloner<value_type>(), test::delete_disposer<value_type>());
//Ordering is not guarantee in the cloning so insert data in a set and test
@@ -692,8 +752,12 @@ void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash, Incremental>
//Test with smaller source bucket arrays
typename unordered_multiset_type::bucket_type buckets1 [BucketSize];
typename unordered_multiset_type::bucket_type buckets2 [BucketSize*2];
unordered_multiset_type testset1 (values.begin(), values.end(), bucket_traits(buckets1, BucketSize));
unordered_multiset_type testset2 (bucket_traits(buckets2, BucketSize*2));
unordered_multiset_type testset1 (values.begin(), values.end(), bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets1[0]), BucketSize));
unordered_multiset_type testset2 (bucket_traits(
pointer_traits<typename unordered_multiset_type::bucket_ptr>::
pointer_to(buckets2[0]), BucketSize*2));
testset2.clone_from(testset1, test::new_cloner<value_type>(), test::delete_disposer<value_type>());
//Ordering is not guaranteed in the cloning so insert data in a set and test