More insert and erase tests

test/unordered/erase_tests.cpp

@@ -16,7 +16,7 @@
 #include "../helpers/equivalent.hpp"
 #include "../helpers/helpers.hpp"
 #include "../helpers/invariants.hpp"
-
+#include <vector>
 #include <iostream>
 
 namespace erase_tests
@@ -27,6 +27,9 @@ test::seed_t initialize_seed(85638);
 template <class Container>
 void erase_tests1(Container*, test::random_generator generator)
 {
+    typedef BOOST_DEDUCED_TYPENAME Container::iterator iterator;
+    typedef BOOST_DEDUCED_TYPENAME Container::const_iterator c_iterator;
+
     std::cerr<<"Erase by key.\n";
     {
         test::check_instances check_;
@@ -60,8 +63,7 @@ void erase_tests1(Container*, test::random_generator generator)
             BOOST_DEDUCED_TYPENAME Container::key_type
                 key = test::get_key<Container>(*x.begin());
             std::size_t count = x.count(key);
-            BOOST_DEDUCED_TYPENAME Container::iterator
-                pos = x.erase(x.begin());
+            iterator pos = x.erase(x.begin());
             --size;
             BOOST_TEST(pos == x.begin());
             BOOST_TEST(x.count(key) == count - 1);
@@ -83,7 +85,7 @@ void erase_tests1(Container*, test::random_generator generator)
         {
             using namespace std;
             int index = rand() % (int) x.size();
-            BOOST_DEDUCED_TYPENAME Container::const_iterator prev, pos, next;
+            c_iterator prev, pos, next;
             if(index == 0) {
                 prev = pos = x.begin();
             }
@@ -138,6 +140,45 @@ void erase_tests1(Container*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
+    std::cerr<<"erase(random ranges).\n";
+    {
+        test::check_instances check_;
+        Container x;
+
+        for (int i = 0; i < 100; ++i) {
+            test::random_values<Container> v(1000, generator);
+            x.insert(v.begin(), v.end());
+
+            // Note that erase only invalidates the erased iterators.
+            std::vector<c_iterator> iterators;
+            for(c_iterator it = x.cbegin(); it != x.cend(); ++it) {
+                iterators.push_back(it);
+            }
+            iterators.push_back(x.cend());
+
+            while(iterators.size() > 1) {
+                int start = rand() % (int) iterators.size();
+                int length = rand() % (int) (iterators.size() - start);
+                x.erase(iterators[start], iterators[start + length]);
+                iterators.erase(
+                        boost::next(iterators.begin(), start),
+                        boost::next(iterators.begin(), start + length));
+
+                BOOST_TEST(x.size() == iterators.size() - 1);
+                BOOST_DEDUCED_TYPENAME std::vector<c_iterator>::const_iterator
+                    i2 = iterators.begin();
+                for(c_iterator i1 = x.cbegin(); i1 != x.cend(); ++i1) {
+                    BOOST_TEST(i1 == *i2);
+                    ++i2;
+                }
+                BOOST_TEST(x.cend() == *i2);
+
+                test::check_equivalent_keys(x);
+            }
+            BOOST_TEST(x.empty());
+        }
+    }
+
     std::cerr<<"quick_erase(begin()).\n";
     {
         test::check_instances check_;

test/unordered/insert_tests.cpp

@@ -128,6 +128,7 @@ void insert_tests2(X*, test::random_generator generator)
                 BOOST_TEST(x.bucket_count() == old_bucket_count);
         }
 
+        tracker.compare(x);
         test::check_equivalent_keys(x);
     }
 
@@ -157,6 +158,7 @@ void insert_tests2(X*, test::random_generator generator)
                 BOOST_TEST(x.bucket_count() == old_bucket_count);
         }
 
+        tracker.compare(x);
         test::check_equivalent_keys(x);
     }
 
@@ -186,6 +188,7 @@ void insert_tests2(X*, test::random_generator generator)
                 BOOST_TEST(x.bucket_count() == old_bucket_count);
         }
 
+        tracker.compare(x);
         test::check_equivalent_keys(x);
     }
 
@@ -213,6 +216,7 @@ void insert_tests2(X*, test::random_generator generator)
                 BOOST_TEST(x.bucket_count() == old_bucket_count);
         }
 
+        tracker.compare(x);
         test::check_equivalent_keys(x);
     }
 
@@ -292,6 +296,42 @@ void insert_tests2(X*, test::random_generator generator)
 
         test::check_equivalent_keys(x);
     }
+
+    std::cerr<<"insert various ranges.\n";
+
+    {
+        for (int i = 0; i < 100; ++i) {
+            X x;
+            test::ordered<X> tracker = test::create_ordered(x);
+
+            test::random_values<X> v(1000, generator);
+
+            for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator
+                    it = v.begin(); it != v.end();)
+            {
+                BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
+                float b = x.max_load_factor();
+
+                BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator
+                    next = it;
+                for (int j = rand() % 20; j > 0; ++j) {
+                    ++next;
+                    if (next == v.end()) { break; }
+                }
+
+                x.insert(it, next);
+                tracker.insert(it, next);
+                it = next;
+
+                tracker.compare(x); // Slow, but I can't see any other way.
+
+                if(static_cast<double>(x.size()) <= b * static_cast<double>(old_bucket_count))
+                    BOOST_TEST(x.bucket_count() == old_bucket_count);
+            }
+
+            test::check_equivalent_keys(x);
+        }
+    }
 }
 
 template <class X>
@@ -327,6 +367,7 @@ void unique_emplace_tests1(X*, test::random_generator generator)
             BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
+    tracker.compare(x);
     test::check_equivalent_keys(x);
 }
 
@@ -357,6 +398,7 @@ void equivalent_emplace_tests1(X*, test::random_generator generator)
             BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
+    tracker.compare(x);
     test::check_equivalent_keys(x);
 }
 
@@ -386,8 +428,8 @@ void move_emplace_tests(X*, test::random_generator generator)
             BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
-    test::check_equivalent_keys(x);
     tracker.compare(x);
+    test::check_equivalent_keys(x);
 }
 
 template <class X>
@@ -449,6 +491,7 @@ void map_tests(X*, test::random_generator generator)
             BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
 
+    tracker.compare(x);
     test::check_equivalent_keys(x);   
 }