From 05f7c37f54a7c57ec9c31918b2814c34eb0f5e4c Mon Sep 17 00:00:00 2001 From: Daniel James Date: Fri, 7 Sep 2012 19:51:10 +0000 Subject: [PATCH] Unordered: Merge tests to release [SVN r80435] --- test/helpers/random_values.hpp | 28 +++++++++++------------ test/helpers/test.hpp | 18 ++++++++++----- test/unordered/assign_tests.cpp | 6 ++--- test/unordered/bucket_tests.cpp | 10 +++++++-- test/unordered/constructor_tests.cpp | 10 ++++----- test/unordered/copy_tests.cpp | 9 +++----- test/unordered/erase_tests.cpp | 3 +-- test/unordered/find_tests.cpp | 5 ++--- test/unordered/insert_tests.cpp | 23 +++++++------------ test/unordered/load_factor_tests.cpp | 23 +++++++++++-------- test/unordered/move_tests.cpp | 27 +++++++++++++---------- test/unordered/rehash_tests.cpp | 33 +++++++++++++++------------- test/unordered/swap_tests.cpp | 32 ++++++++++++++++----------- 13 files changed, 121 insertions(+), 106 deletions(-) diff --git a/test/helpers/random_values.hpp b/test/helpers/random_values.hpp index 18e0eae9..46eeb392 100644 --- a/test/helpers/random_values.hpp +++ b/test/helpers/random_values.hpp @@ -33,14 +33,15 @@ namespace test void fill(T& x, std::size_t len) { value_type* value_ptr = 0; int* int_ptr = 0; + len += x.size(); - for(std::size_t i = 0; i < len; ++i) { + for (std::size_t i = 0; i < len; ++i) { value_type value = generate(value_ptr); - for(int count = - type_ == generate_collisions ? - generate(int_ptr) % 10 : 1; - count; --count) { + int count = type_ == generate_collisions ? + 1 + (generate(int_ptr) % 5) : 1; + + for(int i = 0; i < count; ++i) { x.push_back(value); } } @@ -64,16 +65,15 @@ namespace test mapped_type* mapped_ptr = 0; int* int_ptr = 0; - for(std::size_t i = 0; i < len; ++i) { + for (std::size_t i = 0; i < len; ++i) { key_type key = generate(key_ptr); - for(int count = - type_ == generate_collisions ? - generate(int_ptr) % 10 : 1; - count; --count) { - x.push_back( - std::pair( - key, generate(mapped_ptr))); + int count = type_ == generate_collisions ? + 1 + (generate(int_ptr) % 5) : 1; + + for(int i = 0; i < count; ++i) { + x.push_back(std::pair( + key, generate(mapped_ptr))); } } } @@ -106,7 +106,7 @@ namespace test random_values(int count, test::random_generator const& generator = test::default_generator) { - static test::unordered_generator gen(generator); + test::unordered_generator gen(generator); gen.fill(*this, count); } }; diff --git a/test/helpers/test.hpp b/test/helpers/test.hpp index 54c75614..dea6e0ea 100644 --- a/test/helpers/test.hpp +++ b/test/helpers/test.hpp @@ -76,21 +76,29 @@ namespace test { // Run test with every combination of the parameters (a sequence of sequences) #define UNORDERED_TEST(name, parameters) \ - BOOST_PP_SEQ_FOR_EACH_PRODUCT(UNORDERED_TEST_OP, ((name)) parameters) \ + BOOST_PP_SEQ_FOR_EACH_PRODUCT(UNORDERED_TEST_OP, \ + ((name))((1)) parameters) \ + +#define UNORDERED_TEST_REPEAT(name, n, parameters) \ + BOOST_PP_SEQ_FOR_EACH_PRODUCT(UNORDERED_TEST_OP, \ + ((name))((n)) parameters) \ #define UNORDERED_TEST_OP(r, product) \ UNORDERED_TEST_OP2( \ - BOOST_PP_SEQ_HEAD(product), \ - BOOST_PP_SEQ_TAIL(product)) \ + BOOST_PP_SEQ_ELEM(0, product), \ + BOOST_PP_SEQ_ELEM(1, product), \ + BOOST_PP_SEQ_TAIL(BOOST_PP_SEQ_TAIL(product))) \ -#define UNORDERED_TEST_OP2(name, params) \ +#define UNORDERED_TEST_OP2(name, n, params) \ UNORDERED_AUTO_TEST( \ BOOST_PP_SEQ_FOLD_LEFT(UNORDERED_TEST_OP_JOIN, name, params)) \ { \ - name BOOST_PP_SEQ_TO_TUPLE(params); \ + for (int i = 0; i < n; ++i) \ + name BOOST_PP_SEQ_TO_TUPLE(params); \ } \ #define UNORDERED_TEST_OP_JOIN(s, state, elem) \ BOOST_PP_CAT(state, BOOST_PP_CAT(_, elem)) \ + #endif diff --git a/test/unordered/assign_tests.cpp b/test/unordered/assign_tests.cpp index 0c2aec04..e66967c6 100644 --- a/test/unordered/assign_tests.cpp +++ b/test/unordered/assign_tests.cpp @@ -25,8 +25,7 @@ namespace assign_tests { test::seed_t initialize_seed(96785); template -void assign_tests1(T*, - test::random_generator generator = test::default_generator) +void assign_tests1(T*, test::random_generator generator) { BOOST_DEDUCED_TYPENAME T::hasher hf; BOOST_DEDUCED_TYPENAME T::key_equal eq; @@ -68,8 +67,7 @@ void assign_tests1(T*, } template -void assign_tests2(T*, - test::random_generator generator = test::default_generator) +void assign_tests2(T*, test::random_generator generator) { BOOST_DEDUCED_TYPENAME T::hasher hf1(1); BOOST_DEDUCED_TYPENAME T::hasher hf2(2); diff --git a/test/unordered/bucket_tests.cpp b/test/unordered/bucket_tests.cpp index 93dfe1bd..58d9be30 100644 --- a/test/unordered/bucket_tests.cpp +++ b/test/unordered/bucket_tests.cpp @@ -24,7 +24,7 @@ namespace bucket_tests { test::seed_t initialize_seed(54635); template -void tests(X* = 0, test::random_generator generator = test::default_generator) +void tests(X*, test::random_generator generator) { test::check_instances check_; @@ -85,7 +85,13 @@ boost::unordered_multimap >* test_multimap; -UNORDERED_TEST(tests, ((test_multimap_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap))) +using test::default_generator; +using test::generate_collisions; + +UNORDERED_TEST(tests, + ((test_multimap_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap)) + ((default_generator)(generate_collisions)) +) } diff --git a/test/unordered/constructor_tests.cpp b/test/unordered/constructor_tests.cpp index 7d311f26..ba065bf1 100644 --- a/test/unordered/constructor_tests.cpp +++ b/test/unordered/constructor_tests.cpp @@ -21,8 +21,7 @@ namespace constructor_tests { test::seed_t initialize_seed(356730); template -void constructor_tests1(T*, - test::random_generator generator = test::default_generator) +void constructor_tests1(T*, test::random_generator generator) { BOOST_DEDUCED_TYPENAME T::hasher hf; BOOST_DEDUCED_TYPENAME T::key_equal eq; @@ -173,8 +172,7 @@ void constructor_tests1(T*, } template -void constructor_tests2(T*, - test::random_generator const& generator = test::default_generator) +void constructor_tests2(T*, test::random_generator const& generator) { BOOST_DEDUCED_TYPENAME T::hasher hf; BOOST_DEDUCED_TYPENAME T::hasher hf1(1); @@ -383,8 +381,7 @@ void constructor_tests2(T*, } template -void map_constructor_test(T* = 0, - test::random_generator const& generator = test::default_generator) +void map_constructor_test(T*, test::random_generator const& generator) { std::cerr<<"map_constructor_test\n"; @@ -434,6 +431,7 @@ UNORDERED_TEST(constructor_tests2, UNORDERED_TEST(map_constructor_test, ((test_map_std_alloc)(test_map)(test_multimap)) + ((default_generator)(generate_collisions)) ) #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) diff --git a/test/unordered/copy_tests.cpp b/test/unordered/copy_tests.cpp index 08c58baa..80616105 100644 --- a/test/unordered/copy_tests.cpp +++ b/test/unordered/copy_tests.cpp @@ -22,8 +22,7 @@ namespace copy_tests { template -void copy_construct_tests1(T*, - test::random_generator const& generator = test::default_generator) +void copy_construct_tests1(T*, test::random_generator const& generator) { typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type; @@ -82,11 +81,8 @@ void copy_construct_tests1(T*, } template -void copy_construct_tests2(T* ptr, - test::random_generator const& generator = test::default_generator) +void copy_construct_tests2(T*, test::random_generator const& generator) { - copy_construct_tests1(ptr); - BOOST_DEDUCED_TYPENAME T::hasher hf(1); BOOST_DEDUCED_TYPENAME T::key_equal eq(1); BOOST_DEDUCED_TYPENAME T::allocator_type al(1); @@ -208,6 +204,7 @@ UNORDERED_TEST(copy_construct_tests1, ( (test_set_select_copy)(test_multiset_select_copy)(test_map_select_copy)(test_multimap_select_copy) (test_set_no_select_copy)(test_multiset_no_select_copy)(test_map_no_select_copy)(test_multimap_no_select_copy) ) + ((default_generator)(generate_collisions)) ) UNORDERED_TEST(copy_construct_tests2, ( diff --git a/test/unordered/erase_tests.cpp b/test/unordered/erase_tests.cpp index 3d6c3ef2..c634b890 100644 --- a/test/unordered/erase_tests.cpp +++ b/test/unordered/erase_tests.cpp @@ -24,8 +24,7 @@ namespace erase_tests test::seed_t initialize_seed(85638); template -void erase_tests1(Container*, - test::random_generator generator = test::default_generator) +void erase_tests1(Container*, test::random_generator generator) { std::cerr<<"Erase by key.\n"; { diff --git a/test/unordered/find_tests.cpp b/test/unordered/find_tests.cpp index a7efaa1c..c3d58828 100644 --- a/test/unordered/find_tests.cpp +++ b/test/unordered/find_tests.cpp @@ -20,7 +20,7 @@ namespace find_tests test::seed_t initialize_seed(78937); template -void find_tests1(X*, test::random_generator generator = test::default_generator) +void find_tests1(X*, test::random_generator generator) { typedef BOOST_DEDUCED_TYPENAME X::iterator iterator; @@ -115,8 +115,7 @@ struct compatible_predicate }; template -void find_compatible_keys_test(X*, - test::random_generator generator = test::default_generator) +void find_compatible_keys_test(X*, test::random_generator generator) { typedef BOOST_DEDUCED_TYPENAME X::iterator iterator; typedef BOOST_DEDUCED_TYPENAME test::random_values::iterator diff --git a/test/unordered/insert_tests.cpp b/test/unordered/insert_tests.cpp index e63c1ed2..2f063161 100644 --- a/test/unordered/insert_tests.cpp +++ b/test/unordered/insert_tests.cpp @@ -24,8 +24,7 @@ namespace insert_tests { test::seed_t initialize_seed(243432); template -void unique_insert_tests1(X*, - test::random_generator generator = test::default_generator) +void unique_insert_tests1(X*, test::random_generator generator) { test::check_instances check_; @@ -63,8 +62,7 @@ void unique_insert_tests1(X*, } template -void equivalent_insert_tests1(X*, - test::random_generator generator = test::default_generator) +void equivalent_insert_tests1(X*, test::random_generator generator) { std::cerr<<"insert(value) tests for containers with equivalent keys.\n"; @@ -97,8 +95,7 @@ void equivalent_insert_tests1(X*, } template -void insert_tests2(X*, - test::random_generator generator = test::default_generator) +void insert_tests2(X*, test::random_generator generator) { typedef BOOST_DEDUCED_TYPENAME test::ordered tracker_type; typedef BOOST_DEDUCED_TYPENAME X::iterator iterator; @@ -266,8 +263,7 @@ void insert_tests2(X*, #if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES) template -void unique_emplace_tests1(X*, - test::random_generator generator = test::default_generator) +void unique_emplace_tests1(X*, test::random_generator generator) { typedef BOOST_DEDUCED_TYPENAME X::iterator iterator; typedef test::ordered ordered; @@ -303,8 +299,7 @@ void unique_emplace_tests1(X*, } template -void equivalent_emplace_tests1(X*, - test::random_generator generator = test::default_generator) +void equivalent_emplace_tests1(X*, test::random_generator generator) { std::cerr<<"emplace(value) tests for containers with equivalent keys.\n"; @@ -336,7 +331,7 @@ void equivalent_emplace_tests1(X*, #endif template -void map_tests(X*, test::random_generator generator = test::default_generator) +void map_tests(X*, test::random_generator generator) { std::cerr<<"map tests.\n"; @@ -366,8 +361,7 @@ void map_tests(X*, test::random_generator generator = test::default_generator) // value type. template -void map_insert_range_test1(X*, - test::random_generator generator = test::default_generator) +void map_insert_range_test1(X*, test::random_generator generator) { std::cerr<<"map_insert_range_test1\n"; @@ -388,8 +382,7 @@ void map_insert_range_test1(X*, } template -void map_insert_range_test2(X*, - test::random_generator generator = test::default_generator) +void map_insert_range_test2(X*, test::random_generator generator) { std::cerr<<"map_insert_range_test2\n"; diff --git a/test/unordered/load_factor_tests.cpp b/test/unordered/load_factor_tests.cpp index 92d56947..6dbd7967 100644 --- a/test/unordered/load_factor_tests.cpp +++ b/test/unordered/load_factor_tests.cpp @@ -23,7 +23,7 @@ namespace load_factor_tests test::seed_t initialize_seed(783656); template -void set_load_factor_tests(X* = 0) +void set_load_factor_tests(X*) { X x; @@ -37,8 +37,7 @@ void set_load_factor_tests(X* = 0) } template -void insert_test(X*, float mlf, - test::random_generator generator = test::default_generator) +void insert_test(X*, float mlf, test::random_generator generator) { X x; x.max_load_factor(mlf); @@ -58,16 +57,18 @@ void insert_test(X*, float mlf, } template -void load_factor_insert_tests(X* ptr = 0) +void load_factor_insert_tests(X* ptr, test::random_generator generator) { - insert_test(ptr, 1.0f); - insert_test(ptr, 0.1f); - insert_test(ptr, 100.0f); + insert_test(ptr, 1.0f, generator); + insert_test(ptr, 0.1f, generator); + insert_test(ptr, 100.0f, generator); - insert_test(ptr, (std::numeric_limits::min)()); + insert_test(ptr, (std::numeric_limits::min)(), + generator); if(std::numeric_limits::has_infinity) - insert_test(ptr, std::numeric_limits::infinity()); + insert_test(ptr, std::numeric_limits::infinity(), + generator); } boost::unordered_set* int_set_ptr; @@ -75,12 +76,16 @@ boost::unordered_multiset* int_multiset_ptr; boost::unordered_map* int_map_ptr; boost::unordered_multimap* int_multimap_ptr; +using test::default_generator; +using test::generate_collisions; + UNORDERED_TEST(set_load_factor_tests, ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr)) ) UNORDERED_TEST(load_factor_insert_tests, ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr)) + ((default_generator)(generate_collisions)) ) } diff --git a/test/unordered/move_tests.cpp b/test/unordered/move_tests.cpp index 7a3c84d3..8866f826 100644 --- a/test/unordered/move_tests.cpp +++ b/test/unordered/move_tests.cpp @@ -57,8 +57,7 @@ namespace move_tests } template - void move_construct_tests1(T* ptr, - test::random_generator const& generator = test::default_generator) + void move_construct_tests1(T* ptr, test::random_generator const& generator) { BOOST_DEDUCED_TYPENAME T::hasher hf; BOOST_DEDUCED_TYPENAME T::key_equal eq; @@ -91,8 +90,7 @@ namespace move_tests } template - void move_assign_tests1(T*, - test::random_generator const& generator = test::default_generator) + void move_assign_tests1(T*, test::random_generator const& generator) { { test::check_instances check_; @@ -110,8 +108,7 @@ namespace move_tests } template - void move_construct_tests2(T*, - test::random_generator const& generator = test::default_generator) + void move_construct_tests2(T*, test::random_generator const& generator) { BOOST_DEDUCED_TYPENAME T::hasher hf(1); BOOST_DEDUCED_TYPENAME T::key_equal eq(1); @@ -161,13 +158,17 @@ namespace move_tests BOOST_TEST(count == test::global_object_count); #elif defined(BOOST_HAS_NRVO) BOOST_TEST( - test::global_object_count.constructions - count.constructions <= - (test::is_set::value ? 25 : 50)); + static_cast(test::global_object_count.constructions + - count.constructions) <= + (test::is_set::value ? 1 : 2) * + (test::has_unique_keys::value ? 25 : v.size())); BOOST_TEST(count.instances == test::global_object_count.instances); #else BOOST_TEST( - test::global_object_count.constructions - count.constructions <= - (test::is_set::value ? 50 : 100)); + static_cast(test::global_object_count.constructions + - count.constructions) <= + (test::is_set::value ? 2 : 4) * + (test::has_unique_keys::value ? 25 : v.size())); BOOST_TEST(count.instances == test::global_object_count.instances); #endif test::check_container(y, v); @@ -180,8 +181,7 @@ namespace move_tests } template - void move_assign_tests2(T*, - test::random_generator const& generator = test::default_generator) + void move_assign_tests2(T*, test::random_generator const& generator) { BOOST_DEDUCED_TYPENAME T::hasher hf(1); BOOST_DEDUCED_TYPENAME T::key_equal eq(1); @@ -376,6 +376,7 @@ boost::unordered_multimap -void rehash_empty_test1(X* = 0) +void rehash_empty_test1(X*) { X x; @@ -38,8 +39,7 @@ void rehash_empty_test1(X* = 0) } template -void rehash_empty_test2(X* = 0, - test::random_generator generator = test::default_generator) +void rehash_empty_test2(X*, test::random_generator generator) { test::random_values v(1000, generator); test::ordered tracker; @@ -57,8 +57,7 @@ void rehash_empty_test2(X* = 0, } template -void rehash_empty_test3(X* = 0, - test::random_generator generator = test::default_generator) +void rehash_empty_test3(X*, test::random_generator generator) { test::random_values v(1000, generator); test::ordered tracker; @@ -77,8 +76,7 @@ void rehash_empty_test3(X* = 0, template -void rehash_test1(X* = 0, - test::random_generator generator = test::default_generator) +void rehash_test1(X*, test::random_generator generator) { test::random_values v(1000, generator); test::ordered tracker; @@ -101,8 +99,7 @@ void rehash_test1(X* = 0, } template -void reserve_test1(X* = 0, - test::random_generator generator = test::default_generator) +void reserve_test1(X*, test::random_generator generator) { for (int random_mlf = 0; random_mlf < 2; ++random_mlf) { @@ -116,11 +113,10 @@ void reserve_test1(X* = 0, X x; x.max_load_factor(random_mlf ? static_cast(std::rand() % 1000) / 500.0f + 0.5f : 1.0f); - // For the current standard this should reserve i+1, I've // submitted a defect report and will assume it's a defect // for now. - x.reserve(i); + x.reserve(test::has_unique_keys::value ? i : v.size()); // Insert an element before the range insert, otherwise there are // no iterators to invalidate in the range insert, and it can @@ -138,8 +134,7 @@ void reserve_test1(X* = 0, } template -void reserve_test2(X* = 0, - test::random_generator generator = test::default_generator) +void reserve_test2(X*, test::random_generator generator) { for (int random_mlf = 0; random_mlf < 2; ++random_mlf) { @@ -154,9 +149,9 @@ void reserve_test2(X* = 0, x.max_load_factor(random_mlf ? static_cast(std::rand() % 1000) / 500.0f + 0.5f : 1.0f); - x.reserve(i); - std::size_t bucket_count = x.bucket_count(); + x.reserve(test::has_unique_keys::value ? i : v.size()); + std::size_t bucket_count = x.bucket_count(); for (typename test::random_values::iterator it = v.begin(); it != v.end(); ++it) { @@ -174,23 +169,31 @@ boost::unordered_multiset* int_multiset_ptr; boost::unordered_map* int_map_ptr; boost::unordered_multimap* int_multimap_ptr; +using test::default_generator; +using test::generate_collisions; + UNORDERED_TEST(rehash_empty_test1, ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr)) ) UNORDERED_TEST(rehash_empty_test2, ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr)) + ((default_generator)(generate_collisions)) ) UNORDERED_TEST(rehash_empty_test3, ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr)) + ((default_generator)(generate_collisions)) ) UNORDERED_TEST(rehash_test1, ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr)) + ((default_generator)(generate_collisions)) ) UNORDERED_TEST(reserve_test1, ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr)) + ((default_generator)(generate_collisions)) ) UNORDERED_TEST(reserve_test2, ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr)) + ((default_generator)(generate_collisions)) ) } diff --git a/test/unordered/swap_tests.cpp b/test/unordered/swap_tests.cpp index bd686eb7..d967af03 100644 --- a/test/unordered/swap_tests.cpp +++ b/test/unordered/swap_tests.cpp @@ -40,7 +40,7 @@ void swap_test_impl(X& x1, X& x2) } template -void swap_tests1(X*, test::random_generator generator = test::default_generator) +void swap_tests1(X*, test::random_generator generator) { { test::check_instances check_; @@ -76,10 +76,9 @@ void swap_tests1(X*, test::random_generator generator = test::default_generator) } template -void swap_tests2(X* ptr = 0, - test::random_generator generator = test::default_generator) +void swap_tests2(X* ptr, test::random_generator generator) { - swap_tests1(ptr); + swap_tests1(ptr, generator); typedef BOOST_DEDUCED_TYPENAME X::hasher hasher; typedef BOOST_DEDUCED_TYPENAME X::key_equal key_equal; @@ -205,6 +204,9 @@ bool is_propagate(T*) return T::allocator_type::is_propagate_on_swap; } +using test::default_generator; +using test::generate_collisions; + UNORDERED_AUTO_TEST(check_traits) { BOOST_TEST(!is_propagate(test_set)); @@ -213,17 +215,21 @@ UNORDERED_AUTO_TEST(check_traits) } UNORDERED_TEST(swap_tests1, ( - (test_map_std_alloc) - (test_set)(test_multiset)(test_map)(test_multimap) - (test_set_prop_swap)(test_multiset_prop_swap)(test_map_prop_swap)(test_multimap_prop_swap) - (test_set_no_prop_swap)(test_multiset_no_prop_swap)(test_map_no_prop_swap)(test_multimap_no_prop_swap) -)) + (test_map_std_alloc) + (test_set)(test_multiset)(test_map)(test_multimap) + (test_set_prop_swap)(test_multiset_prop_swap)(test_map_prop_swap)(test_multimap_prop_swap) + (test_set_no_prop_swap)(test_multiset_no_prop_swap)(test_map_no_prop_swap)(test_multimap_no_prop_swap) + ) + ((default_generator)(generate_collisions)) +) UNORDERED_TEST(swap_tests2, ( - (test_set)(test_multiset)(test_map)(test_multimap) - (test_set_prop_swap)(test_multiset_prop_swap)(test_map_prop_swap)(test_multimap_prop_swap) - (test_set_no_prop_swap)(test_multiset_no_prop_swap)(test_map_no_prop_swap)(test_multimap_no_prop_swap) -)) + (test_set)(test_multiset)(test_map)(test_multimap) + (test_set_prop_swap)(test_multiset_prop_swap)(test_map_prop_swap)(test_multimap_prop_swap) + (test_set_no_prop_swap)(test_multiset_no_prop_swap)(test_map_no_prop_swap)(test_multimap_no_prop_swap) + ) + ((default_generator)(generate_collisions)) +) } RUN_TESTS()