Unordered: Fix some issues with the tests.

[SVN r80416]

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) {
+            while(x.size() < len) {
                 value_type value = generate(value_ptr);
 
-                for(int count =
+                int count = type_ == generate_collisions ?
-                    type_ == generate_collisions ?
+                    1 + (generate(int_ptr) % 10) : 1;
-                    generate(int_ptr) % 10 : 1;
+
-                    count; --count) {
+                for(int i = 0; i < count; ++i) {
                     x.push_back(value);
                 }
             }
@@ -63,17 +64,17 @@ namespace test
             key_type* key_ptr = 0;
             mapped_type* mapped_ptr = 0;
             int* int_ptr = 0;
+            len += x.size();
 
-            for(std::size_t i = 0; i < len; ++i) {
+            while(x.size() < len) {
                 key_type key = generate(key_ptr);
 
-                for(int count =
+                int count = type_ == generate_collisions ?
-                    type_ == generate_collisions ?
+                    1 + (generate(int_ptr) % 10) : 1;
-                    generate(int_ptr) % 10 : 1;
+
-                    count; --count) {
+                for(int i = 0; i < count; ++i) {
-                    x.push_back(
+                    x.push_back(std::pair<key_type const, mapped_type>(
-                        std::pair<key_type const, mapped_type>(
+                        key, generate(mapped_ptr)));
-                            key, generate(mapped_ptr)));
                 }
             }
         }
@@ -106,7 +107,7 @@ namespace test
         random_values(int count, test::random_generator const& generator =
             test::default_generator)
         {
-            static test::unordered_generator<X> gen(generator);
+            test::unordered_generator<X> gen(generator);
             gen.fill(*this, count);
         }
     };

test/unordered/assign_tests.cpp

@@ -25,8 +25,7 @@ namespace assign_tests {
 test::seed_t initialize_seed(96785);
 
 template <class T>
-void assign_tests1(T*,
+void assign_tests1(T*, test::random_generator generator)
-    test::random_generator generator = test::default_generator)
 {
     BOOST_DEDUCED_TYPENAME T::hasher hf;
     BOOST_DEDUCED_TYPENAME T::key_equal eq;
@@ -68,8 +67,7 @@ void assign_tests1(T*,
 }
 
 template <class T>
-void assign_tests2(T*,
+void assign_tests2(T*, test::random_generator generator)
-    test::random_generator generator = test::default_generator)
 {
     BOOST_DEDUCED_TYPENAME T::hasher hf1(1);
     BOOST_DEDUCED_TYPENAME T::hasher hf2(2);

test/unordered/bucket_tests.cpp

@@ -24,7 +24,7 @@ namespace bucket_tests {
 test::seed_t initialize_seed(54635);
 
 template <class X>
-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::object, test::object,
     test::hash, test::equal_to,
     test::allocator2<test::object> >* 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))
+)
 
 }
 

test/unordered/constructor_tests.cpp

@@ -21,8 +21,7 @@ namespace constructor_tests {
 test::seed_t initialize_seed(356730);
 
 template <class T>
-void constructor_tests1(T*,
+void constructor_tests1(T*, test::random_generator generator)
-    test::random_generator generator = test::default_generator)
 {
     BOOST_DEDUCED_TYPENAME T::hasher hf;
     BOOST_DEDUCED_TYPENAME T::key_equal eq;
@@ -173,8 +172,7 @@ void constructor_tests1(T*,
 }
 
 template <class T>
-void constructor_tests2(T*,
+void constructor_tests2(T*, test::random_generator const& generator)
-    test::random_generator const& generator = test::default_generator)
 {
     BOOST_DEDUCED_TYPENAME T::hasher hf;
     BOOST_DEDUCED_TYPENAME T::hasher hf1(1);
@@ -383,8 +381,7 @@ void constructor_tests2(T*,
 }
 
 template <class T>
-void map_constructor_test(T* = 0,
+void map_constructor_test(T*, test::random_generator const& generator)
-    test::random_generator const& generator = test::default_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)

test/unordered/copy_tests.cpp

@@ -22,8 +22,7 @@ namespace copy_tests
 {
 
 template <class T>
-void copy_construct_tests1(T*,
+void copy_construct_tests1(T*, test::random_generator const& generator)
-    test::random_generator const& generator = test::default_generator)
 {
     typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
 
@@ -82,11 +81,8 @@ void copy_construct_tests1(T*,
 }
 
 template <class T>
-void copy_construct_tests2(T* ptr,
+void copy_construct_tests2(T*, test::random_generator const& generator)
-    test::random_generator const& generator = test::default_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, (

test/unordered/erase_tests.cpp

@@ -24,8 +24,7 @@ namespace erase_tests
 test::seed_t initialize_seed(85638);
 
 template <class Container>
-void erase_tests1(Container*,
+void erase_tests1(Container*, test::random_generator generator)
-    test::random_generator generator = test::default_generator)
 {
     std::cerr<<"Erase by key.\n";
     {

test/unordered/find_tests.cpp

@@ -20,7 +20,7 @@ namespace find_tests
 test::seed_t initialize_seed(78937);
 
 template <class X>
-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 <class X>
-void find_compatible_keys_test(X*,
+void find_compatible_keys_test(X*, test::random_generator generator)
-    test::random_generator generator = test::default_generator)
 {
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
     typedef BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator

test/unordered/insert_tests.cpp

@@ -24,8 +24,7 @@ namespace insert_tests {
 test::seed_t initialize_seed(243432);
 
 template <class X>
-void unique_insert_tests1(X*,
+void unique_insert_tests1(X*, test::random_generator generator)
-    test::random_generator generator = test::default_generator)
 {
     test::check_instances check_;
 
@@ -63,8 +62,7 @@ void unique_insert_tests1(X*,
 }
 
 template <class X>
-void equivalent_insert_tests1(X*,
+void equivalent_insert_tests1(X*, test::random_generator generator)
-    test::random_generator generator = test::default_generator)
 {
     std::cerr<<"insert(value) tests for containers with equivalent keys.\n";
 
@@ -97,8 +95,7 @@ void equivalent_insert_tests1(X*,
 }
 
 template <class X>
-void insert_tests2(X*,
+void insert_tests2(X*, test::random_generator generator)
-    test::random_generator generator = test::default_generator)
 {
     typedef BOOST_DEDUCED_TYPENAME test::ordered<X> 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 <class X>
-void unique_emplace_tests1(X*,
+void unique_emplace_tests1(X*, test::random_generator generator)
-    test::random_generator generator = test::default_generator)
 {
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
     typedef test::ordered<X> ordered;
@@ -303,8 +299,7 @@ void unique_emplace_tests1(X*,
 }
 
 template <class X>
-void equivalent_emplace_tests1(X*,
+void equivalent_emplace_tests1(X*, test::random_generator generator)
-    test::random_generator generator = test::default_generator)
 {
     std::cerr<<"emplace(value) tests for containers with equivalent keys.\n";
 
@@ -336,7 +331,7 @@ void equivalent_emplace_tests1(X*,
 #endif
 
 template <class X>
-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 <class X>
-void map_insert_range_test1(X*,
+void map_insert_range_test1(X*, test::random_generator generator)
-    test::random_generator generator = test::default_generator)
 {
     std::cerr<<"map_insert_range_test1\n";
 
@@ -388,8 +382,7 @@ void map_insert_range_test1(X*,
 }
 
 template <class X>
-void map_insert_range_test2(X*,
+void map_insert_range_test2(X*, test::random_generator generator)
-    test::random_generator generator = test::default_generator)
 {
     std::cerr<<"map_insert_range_test2\n";
 

test/unordered/load_factor_tests.cpp

@@ -23,7 +23,7 @@ namespace load_factor_tests
 test::seed_t initialize_seed(783656);
 
 template <class X>
-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 <class X>
-void insert_test(X*, float mlf,
+void insert_test(X*, float mlf, test::random_generator generator)
-    test::random_generator generator = test::default_generator)
 {
     X x;
     x.max_load_factor(mlf);
@@ -58,16 +57,18 @@ void insert_test(X*, float mlf,
 }
 
 template <class X>
-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, 1.0f, generator);
-    insert_test(ptr, 0.1f);
+    insert_test(ptr, 0.1f, generator);
-    insert_test(ptr, 100.0f);
+    insert_test(ptr, 100.0f, generator);
 
-    insert_test(ptr, (std::numeric_limits<float>::min)());
+    insert_test(ptr, (std::numeric_limits<float>::min)(),
+        generator);
 
     if(std::numeric_limits<float>::has_infinity)
-        insert_test(ptr, std::numeric_limits<float>::infinity());
+        insert_test(ptr, std::numeric_limits<float>::infinity(),
+            generator);
 }
 
 boost::unordered_set<int>* int_set_ptr;
@@ -75,12 +76,16 @@ boost::unordered_multiset<int>* int_multiset_ptr;
 boost::unordered_map<int, int>* int_map_ptr;
 boost::unordered_multimap<int, int>* 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))
 )
 
 }

test/unordered/move_tests.cpp

@@ -57,8 +57,7 @@ namespace move_tests
     }
 
     template <class T>
-    void move_construct_tests1(T* ptr,
+    void move_construct_tests1(T* ptr, test::random_generator const& generator)
-        test::random_generator const& generator = test::default_generator)
     {
         BOOST_DEDUCED_TYPENAME T::hasher hf;
         BOOST_DEDUCED_TYPENAME T::key_equal eq;
@@ -91,8 +90,7 @@ namespace move_tests
     }
 
     template <class T>
-    void move_assign_tests1(T*,
+    void move_assign_tests1(T*, test::random_generator const& generator)
-        test::random_generator const& generator = test::default_generator)
     {
         {
             test::check_instances check_;
@@ -110,8 +108,7 @@ namespace move_tests
     }
 
     template <class T>
-    void move_construct_tests2(T*,
+    void move_construct_tests2(T*, test::random_generator const& generator)
-            test::random_generator const& generator = test::default_generator)
     {
         BOOST_DEDUCED_TYPENAME T::hasher hf(1);
         BOOST_DEDUCED_TYPENAME T::key_equal eq(1);
@@ -180,8 +177,7 @@ namespace move_tests
     }
 
     template <class T>
-    void move_assign_tests2(T*,
+    void move_assign_tests2(T*, test::random_generator const& generator)
-        test::random_generator const& generator = test::default_generator)
     {
         BOOST_DEDUCED_TYPENAME T::hasher hf(1);
         BOOST_DEDUCED_TYPENAME T::key_equal eq(1);
@@ -376,6 +372,7 @@ boost::unordered_multimap<test::object, test::object,
             (test_set_prop_move)(test_multiset_prop_move)(test_map_prop_move)(test_multimap_prop_move)
             (test_set_no_prop_move)(test_multiset_no_prop_move)(test_map_no_prop_move)(test_multimap_no_prop_move)
         )
+        ((default_generator)(generate_collisions))
     )
     UNORDERED_TEST(move_assign_tests1, (
             (test_map_std_alloc)
@@ -383,19 +380,21 @@ boost::unordered_multimap<test::object, test::object,
             (test_set_prop_move)(test_multiset_prop_move)(test_map_prop_move)(test_multimap_prop_move)
             (test_set_no_prop_move)(test_multiset_no_prop_move)(test_map_no_prop_move)(test_multimap_no_prop_move)
         )
+        ((default_generator)(generate_collisions))
     )
-    UNORDERED_TEST_REPEAT(move_construct_tests2, 50, (
+    UNORDERED_TEST(move_construct_tests2, (
             (test_set)(test_multiset)(test_map)(test_multimap)
             (test_set_prop_move)(test_multiset_prop_move)(test_map_prop_move)(test_multimap_prop_move)
             (test_set_no_prop_move)(test_multiset_no_prop_move)(test_map_no_prop_move)(test_multimap_no_prop_move)
         )
         ((default_generator)(generate_collisions))
     )
-    UNORDERED_TEST_REPEAT(move_assign_tests2, 50, (
+    UNORDERED_TEST(move_assign_tests2, (
             (test_set)(test_multiset)(test_map)(test_multimap)
             (test_set_prop_move)(test_multiset_prop_move)(test_map_prop_move)(test_multimap_prop_move)
             (test_set_no_prop_move)(test_multiset_no_prop_move)(test_map_no_prop_move)(test_multimap_no_prop_move)
         )
+        ((default_generator)(generate_collisions))
     )
 }
 

test/unordered/rehash_tests.cpp

@@ -26,7 +26,7 @@ bool postcondition(X const& x, BOOST_DEDUCED_TYPENAME X::size_type n)
 }
 
 template <class X>
-void rehash_empty_test1(X* = 0)
+void rehash_empty_test1(X*)
 {
     X x;
 
@@ -38,8 +38,7 @@ void rehash_empty_test1(X* = 0)
 }
 
 template <class X>
-void rehash_empty_test2(X* = 0,
+void rehash_empty_test2(X*, test::random_generator generator)
-    test::random_generator generator = test::default_generator)
 {
     test::random_values<X> v(1000, generator);
     test::ordered<X> tracker;
@@ -57,8 +56,7 @@ void rehash_empty_test2(X* = 0,
 }
 
 template <class X>
-void rehash_empty_test3(X* = 0,
+void rehash_empty_test3(X*, test::random_generator generator)
-    test::random_generator generator = test::default_generator)
 {
     test::random_values<X> v(1000, generator);
     test::ordered<X> tracker;
@@ -77,8 +75,7 @@ void rehash_empty_test3(X* = 0,
 
 
 template <class X>
-void rehash_test1(X* = 0,
+void rehash_test1(X*, test::random_generator generator)
-    test::random_generator generator = test::default_generator)
 {
     test::random_values<X> v(1000, generator);
     test::ordered<X> tracker;
@@ -101,8 +98,7 @@ void rehash_test1(X* = 0,
 }
 
 template <class X>
-void reserve_test1(X* = 0,
+void reserve_test1(X*, test::random_generator generator)
-    test::random_generator generator = test::default_generator)
 {
     for (int random_mlf = 0; random_mlf < 2; ++random_mlf)
     {
@@ -116,11 +112,10 @@ void reserve_test1(X* = 0,
             X x;
             x.max_load_factor(random_mlf ?
                 static_cast<float>(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(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 +133,7 @@ void reserve_test1(X* = 0,
 }
 
 template <class X>
-void reserve_test2(X* = 0,
+void reserve_test2(X*, test::random_generator generator)
-    test::random_generator generator = test::default_generator)
 {
     for (int random_mlf = 0; random_mlf < 2; ++random_mlf)
     {
@@ -154,7 +148,7 @@ void reserve_test2(X* = 0,
             x.max_load_factor(random_mlf ?
                 static_cast<float>(std::rand() % 1000) / 500.0f + 0.5f : 1.0f);
 
-            x.reserve(i);
+            x.reserve(v.size());
             std::size_t bucket_count = x.bucket_count();
 
             for (typename test::random_values<X>::iterator it = v.begin();
@@ -174,23 +168,31 @@ boost::unordered_multiset<int>* int_multiset_ptr;
 boost::unordered_map<int, int>* int_map_ptr;
 boost::unordered_multimap<int, int>* 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))
 )
 
 }

test/unordered/swap_tests.cpp

@@ -40,7 +40,7 @@ void swap_test_impl(X& x1, X& x2)
 }
 
 template <class X>
-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 <class X>
-void swap_tests2(X* ptr = 0,
+void swap_tests2(X* ptr, test::random_generator generator)
-    test::random_generator generator = test::default_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_map_std_alloc)
-    (test_set)(test_multiset)(test_map)(test_multimap)
+        (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_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_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)(test_multiset)(test_map)(test_multimap)
-    (test_set_prop_swap)(test_multiset_prop_swap)(test_map_prop_swap)(test_multimap_prop_swap)
+        (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_no_prop_swap)(test_multiset_no_prop_swap)(test_map_no_prop_swap)(test_multimap_no_prop_swap)
-))
+    )
+    ((default_generator)(generate_collisions))
+)
 
 }
 RUN_TESTS()