Update the unordered tests. Several changes including extra erase tests. The newer version of the containers have a hairy erase implementation, so need to test all the special cases. Also, a few extra tests here and there, avoid a couple of warnings and remove some old TODOs.

[SVN r3341]

test/unordered/Jamfile.v2

@@ -19,6 +19,7 @@ test-suite unordered-tests
         [ run assign_tests.cpp ]
         [ run insert_tests.cpp ]
         [ run erase_tests.cpp ]
+        [ run erase_equiv_tests.cpp ]
         [ run find_tests.cpp ]
         [ run bucket_tests.cpp ]
         [ run load_factor_tests.cpp ]

test/unordered/assign_tests.cpp

@@ -61,7 +61,6 @@ void assign_tests2(T* = 0)
 
     std::cerr<<"assign_tests2.1\n";
     {
-        // TODO: Need to generate duplicates...
         test::random_values<T> v(1000);
         T x1(v.begin(), v.end(), 0, hf1, eq1);
         T x2(0, hf2, eq2);
@@ -73,7 +72,6 @@ void assign_tests2(T* = 0)
 
     std::cerr<<"assign_tests2.2\n";
     {
-        // TODO: Need to generate duplicates...
         test::random_values<T> v1(100), v2(100);
         T x1(v1.begin(), v1.end(), 0, hf1, eq1, al1);
         T x2(v2.begin(), v2.end(), 0, hf2, eq2, al2);

test/unordered/constructor_tests.cpp

@@ -11,6 +11,7 @@
 #include "../helpers/tracker.hpp"
 #include "../helpers/equivalent.hpp"
 #include "../helpers/input_iterator.hpp"
+#include "../helpers/invariants.hpp"
 
 #include <iostream>
 
@@ -29,6 +30,7 @@ void constructor_tests1(T* = 0)
         BOOST_TEST(test::equivalent(x.hash_function(), hf));
         BOOST_TEST(test::equivalent(x.key_eq(), eq));
         BOOST_TEST(test::equivalent(x.get_allocator(), al));
+        test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 2\n";
@@ -39,6 +41,7 @@ void constructor_tests1(T* = 0)
         BOOST_TEST(test::equivalent(x.hash_function(), hf));
         BOOST_TEST(test::equivalent(x.key_eq(), eq));
         BOOST_TEST(test::equivalent(x.get_allocator(), al));
+        test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 3\n";
@@ -49,6 +52,7 @@ void constructor_tests1(T* = 0)
         BOOST_TEST(test::equivalent(x.hash_function(), hf));
         BOOST_TEST(test::equivalent(x.key_eq(), eq));
         BOOST_TEST(test::equivalent(x.get_allocator(), al));
+        test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 4\n";
@@ -58,6 +62,7 @@ void constructor_tests1(T* = 0)
         BOOST_TEST(test::equivalent(x.hash_function(), hf));
         BOOST_TEST(test::equivalent(x.key_eq(), eq));
         BOOST_TEST(test::equivalent(x.get_allocator(), al));
+        test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 5\n";
@@ -69,6 +74,7 @@ void constructor_tests1(T* = 0)
         BOOST_TEST(test::equivalent(x.key_eq(), eq));
         BOOST_TEST(test::equivalent(x.get_allocator(), al));
         test::check_container(x, v);
+        test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 6\n";
@@ -80,6 +86,7 @@ void constructor_tests1(T* = 0)
         BOOST_TEST(test::equivalent(x.key_eq(), eq));
         BOOST_TEST(test::equivalent(x.get_allocator(), al));
         test::check_container(x, v);
+        test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 7\n";
@@ -91,6 +98,7 @@ void constructor_tests1(T* = 0)
         BOOST_TEST(test::equivalent(x.key_eq(), eq));
         BOOST_TEST(test::equivalent(x.get_allocator(), al));
         test::check_container(x, v);
+        test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 8\n";
@@ -101,6 +109,7 @@ void constructor_tests1(T* = 0)
         BOOST_TEST(test::equivalent(x.key_eq(), eq));
         BOOST_TEST(test::equivalent(x.get_allocator(), al));
         test::check_container(x, v);
+        test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 9\n";
@@ -111,6 +120,7 @@ void constructor_tests1(T* = 0)
         BOOST_TEST(test::equivalent(x.hash_function(), hf));
         BOOST_TEST(test::equivalent(x.key_eq(), eq));
         BOOST_TEST(test::equivalent(x.get_allocator(), al));
+        test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 10\n";
@@ -122,6 +132,7 @@ void constructor_tests1(T* = 0)
         BOOST_TEST(test::equivalent(x.key_eq(), eq));
         BOOST_TEST(test::equivalent(x.get_allocator(), al));
         test::check_container(x, v);
+        test::check_equivalent_keys(x);
     }
 }
 
@@ -145,6 +156,7 @@ void constructor_tests2(T* = 0)
         BOOST_TEST(test::equivalent(x.hash_function(), hf1));
         BOOST_TEST(test::equivalent(x.key_eq(), eq1));
         BOOST_TEST(test::equivalent(x.get_allocator(), al));
+        test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 2\n";
@@ -155,6 +167,7 @@ void constructor_tests2(T* = 0)
         BOOST_TEST(test::equivalent(x.hash_function(), hf1));
         BOOST_TEST(test::equivalent(x.key_eq(), eq));
         BOOST_TEST(test::equivalent(x.get_allocator(), al));
+        test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 3\n";
@@ -165,6 +178,7 @@ void constructor_tests2(T* = 0)
         BOOST_TEST(test::equivalent(x.key_eq(), eq1));
         BOOST_TEST(test::equivalent(x.get_allocator(), al));
         test::check_container(x, v);
+        test::check_equivalent_keys(x);
     }
 
     std::cerr<<"Construct 4\n";
@@ -176,6 +190,7 @@ void constructor_tests2(T* = 0)
         BOOST_TEST(test::equivalent(x.key_eq(), eq));
         BOOST_TEST(test::equivalent(x.get_allocator(), al));
         test::check_container(x, v);
+        test::check_equivalent_keys(x);
     }
 
 
@@ -186,6 +201,8 @@ void constructor_tests2(T* = 0)
         T y(x.begin(), x.end(), 0, hf1, eq1, al2);
         test::check_container(x, v);
         test::check_container(y, x);
+        test::check_equivalent_keys(x);
+        test::check_equivalent_keys(y);
     }
 
     std::cerr<<"Construct 6\n";
@@ -195,6 +212,8 @@ void constructor_tests2(T* = 0)
         T y(x.begin(), x.end(), 0, hf, eq);
         test::check_container(x, v);
         test::check_container(y, x);
+        test::check_equivalent_keys(x);
+        test::check_equivalent_keys(y);
     }
 
     std::cerr<<"Construct 7\n";
@@ -204,6 +223,8 @@ void constructor_tests2(T* = 0)
         T y(x.begin(), x.end(), 0, hf2, eq2);
         test::check_container(x, v);
         test::check_container(y, x);
+        test::check_equivalent_keys(x);
+        test::check_equivalent_keys(y);
     }
 
     std::cerr<<"Construct 8 - from input iterator\n";
@@ -213,9 +234,26 @@ void constructor_tests2(T* = 0)
         T y(test::input_iterator(x.begin()), test::input_iterator(x.end()), 0, hf2, eq2);
         test::check_container(x, v);
         test::check_container(y, x);
+        test::check_equivalent_keys(x);
+        test::check_equivalent_keys(y);
     }
 }
 
+template <class T>
+void map_constructor_test(T* = 0)
+{
+    std::cerr<<"map_constructor_test\n";
+
+    typedef std::list<std::pair<typename T::key_type, typename T::mapped_type> > list;
+    test::random_values<T> v(1000);
+    list l(v.begin(), v.end());
+
+    T x(l.begin(), l.end());
+
+    test::check_container(x, v);
+    test::check_equivalent_keys(x);
+}
+
 int main()
 {
     std::cerr<<"Test1 unordered_set<int>\n";
@@ -245,5 +283,10 @@ int main()
     std::cerr<<"Test2 unordered_multimap<test::object, test::object>\n";
     constructor_tests2((boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
 
+    std::cerr<<"Map Test unordered_map<test::object, test::object>\n";
+    map_constructor_test((boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
+    std::cerr<<"Map Test unordered_multimap<test::object, test::object>\n";
+    map_constructor_test((boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
+
     return boost::report_errors();
 }

test/unordered/copy_tests.cpp

@@ -67,7 +67,6 @@ void copy_construct_tests2(T* ptr = 0)
     typename T::allocator_type al(1);
 
     {
-        // TODO: I could check how many buckets y has, it should be lower (QOI issue).
         T x(10000, hf, eq, al);
         T y(x);
         BOOST_TEST(y.empty());
@@ -79,7 +78,6 @@ void copy_construct_tests2(T* ptr = 0)
     }
 
     {
-        // TODO: Invariant checks are especially important here.
         test::random_values<T> v(1000);
 
         T x(v.begin(), v.end(), 0, hf, eq, al);

test/unordered/erase_equiv_tests.cpp

@@ -0,0 +1,195 @@
+
+// Copyright 2006 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// The code for erasing elements from containers with equivalent keys is very
+// hairy with several tricky edge cases - so explicitly test each one.
+
+#include <boost/unordered_map.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <list>
+#include <set>
+#include <iostream>
+#include <iterator>
+#include <boost/next_prior.hpp>
+#include "../objects/test.hpp"
+
+struct write_pair_type
+{
+    template <class X1, class X2>
+    void operator()(std::pair<X1, X2> const& x) const
+    {
+        std::cout<<"("<<x.first<<","<<x.second<<")";
+    }
+} write_pair;
+
+template <class Container>
+void write_container(Container const& x)
+{
+    std::for_each(x.begin(), x.end(), write_pair);
+    std::cout<<"\n";
+}
+
+// Make everything collide - for testing erase in a single bucket.
+struct collision_hash
+{
+    int operator()(int) const { return 0; }
+};
+
+// For testing erase in 2 buckets.
+struct collision2_hash
+{
+    int operator()(int x) const { return x & 1; }
+};
+
+typedef boost::unordered_multimap<int, int,
+    collision_hash, std::equal_to<int>,
+    test::allocator<std::pair<int const, int> > > collide_map;
+typedef boost::unordered_multimap<int, int,
+    collision2_hash, std::equal_to<int>,
+    test::allocator<std::pair<int const, int> > > collide_map2;
+typedef collide_map::value_type pair;
+typedef std::list<pair> list;
+
+
+void empty_range_tests()
+{
+    collide_map x;
+    x.erase(x.begin(), x.end());
+    x.erase(x.begin(), x.begin());
+    x.erase(x.end(), x.end());
+}
+
+void single_item_tests()
+{
+    list init;
+    init.push_back(pair(1,1));
+
+    collide_map x(init.begin(), init.end());
+    x.erase(x.begin(), x.begin());
+    BOOST_TEST(x.count(1) == 1 && x.size() == 1);
+    x.erase(x.end(), x.end());
+    BOOST_TEST(x.count(1) == 1 && x.size() == 1);
+    x.erase(x.begin(), x.end());
+    BOOST_TEST(x.count(1) == 0 && x.size() == 0);
+}
+
+void two_equivalent_item_tests()
+{
+    list init;
+    init.push_back(pair(1,1));
+    init.push_back(pair(1,2));
+
+    {
+        collide_map x(init.begin(), init.end());
+        x.erase(x.begin(), x.end());
+        BOOST_TEST(x.count(1) == 0 && x.size() == 0);
+    }
+
+    {
+        collide_map x(init.begin(), init.end());
+        int value = boost::next(x.begin())->second;
+        x.erase(x.begin(), boost::next(x.begin()));
+        BOOST_TEST(x.count(1) == 1 && x.size() == 1 &&
+            x.begin()->first == 1 && x.begin()->second == value);
+    }
+
+    {
+        collide_map x(init.begin(), init.end());
+        int value = x.begin()->second;
+        x.erase(boost::next(x.begin()), x.end());
+        BOOST_TEST(x.count(1) == 1 && x.size() == 1 &&
+                x.begin()->first == 1 && x.begin()->second == value);
+    }
+}
+
+// At this point I got bored and wrote more automated tests...
+
+template<class Range1, class Range2>
+bool compare(Range1 const& x, Range2 const& y)
+{
+    list a(x.begin(), x.end());
+    list b(y.begin(), y.end());
+    a.sort();
+    b.sort();
+    return a == b;
+}
+
+template <class Container>
+bool general_erase_range_test(Container& x, int start, int end)
+{
+    list l(x.begin(), x.end());
+    l.erase(boost::next(l.begin(), start), boost::next(l.begin(), end));
+    x.erase(boost::next(x.begin(), start), boost::next(x.begin(), end));
+    return compare(l, x);
+}
+
+template <class Container>
+void erase_subrange_tests(Container const& x)
+{
+    for(std::size_t length = 0; length < x.size(); ++length) {
+        for(std::size_t position = 0; position < x.size() - length; ++position) {
+            Container y(x);
+            list init(y.begin(), y.end());
+            if(!general_erase_range_test(y, position, position + length)) {
+                BOOST_ERROR("general_erase_range_test failed.");
+                std::cout<<"Erase: ["<<position<<","<<position + length<<")\n";
+                write_container(init);
+                write_container(y);
+            }
+        }
+    }
+}
+
+template <class Container>
+void x_by_y_erase_range_tests(Container*, int values, int duplicates)
+{
+    Container y;
+
+    for(int i = 0; i < values; ++i) {
+        for(int j = 0; j < duplicates; ++j) {
+            y.insert(pair(i, j));
+        }
+    }
+
+    std::cout<<"Values: "<<values<<", Duplicates: "<<duplicates<<"\n";
+    erase_subrange_tests(y);
+}
+
+template <class Container>
+void exhaustive_erase_tests(Container* x, int num_values,
+        int num_duplicated)
+{
+    for(int i = 0; i < num_values; ++i) {
+        for(int j = 0; j < num_duplicated; ++j) {
+            x_by_y_erase_range_tests(x, i, j);
+        }
+    }
+}
+
+void exhaustive_collide_tests() 
+{
+    std::cout<<"exhaustive_collide_tests:\n";
+    collide_map m;
+    exhaustive_erase_tests((collide_map*) 0, 4, 4);
+    std::cout<<"\n";
+}
+
+void exhaustive_collide2_tests() 
+{
+    std::cout<<"exhaustive_collide2_tests:\n";
+    exhaustive_erase_tests((collide_map2*) 0, 8, 4);
+    std::cout<<"\n";
+}
+
+int main()
+{
+    empty_range_tests();
+    single_item_tests();
+    two_equivalent_item_tests();
+    exhaustive_collide_tests();
+    exhaustive_collide2_tests();
+
+    return boost::report_errors();
+}

test/unordered/erase_tests.cpp

@@ -105,8 +105,6 @@ void erase_tests1(Container* = 0)
         BOOST_TEST(x.erase(x.begin(), x.end()) == x.begin());
     }
 
-    // TODO: More range erase tests.
-
     std::cerr<<"clear().\n";
     {
         test::random_values<Container> v(500);

test/unordered/insert_tests.cpp

@@ -196,8 +196,8 @@ void insert_tests2(X* = 0)
 
         test::random_values<X> v(1000);
         x.insert(v.begin(), v.end());
-        test::check_container(x, v);
 
+        test::check_container(x, v);
         test::check_equivalent_keys(x);
     }
 
@@ -218,6 +218,8 @@ void insert_tests2(X* = 0)
 template <class X>
 void map_tests(X* = 0)
 {
+    std::cerr<<"map tests.\n";
+
     X x;
     test::ordered<X> tracker = test::create_ordered(x);
 
@@ -240,6 +242,20 @@ void map_tests(X* = 0)
     test::check_equivalent_keys(x);   
 }
 
+template <class X>
+void associative_insert_range_test(X* = 0)
+{
+    std::cerr<<"associative_insert_range_test\n";
+
+    typedef std::list<std::pair<typename X::key_type, typename X::mapped_type> > list;
+    test::random_values<X> v(1000);
+    list l(v.begin(), v.end());
+
+    X x; x.insert(l.begin(), l.end());
+
+    test::check_equivalent_keys(x);
+}
+
 int main()
 {
     unique_insert_tests1((boost::unordered_set<int>*) 0);
@@ -265,5 +281,8 @@ int main()
     map_tests((boost::unordered_map<int, int>*) 0);
     map_tests((boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
 
+    associative_insert_range_test((boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
+    associative_insert_range_test((boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
+
     return boost::report_errors();
 }