Add some tests for the unordered associative containers.

[SVN r2954]

test/helpers/invariants.hpp

@@ -0,0 +1,82 @@
+
+//  Copyright Daniel James 2006. Use, modification, and distribution are
+//  subject to 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)
+
+// This header contains metafunctions/functions to get the equivalent
+// associative container for an unordered container, and compare the contents.
+
+#if !defined(BOOST_UNORDERED_TEST_HELPERS_INVARIANT_HEADER)
+#define BOOST_UNORDERED_TEST_HELPERS_INVARIANT_HEADER
+
+#include <set>
+#include "./metafunctions.hpp"
+#include "./helpers.hpp"
+
+namespace test
+{
+    template <class X>
+    void check_equivalent_keys(X const& x1)
+    {
+        typename X::key_equal eq = x1.key_eq();
+        typedef typename X::key_type key_type;
+        std::set<key_type> found_;
+
+        typename X::const_iterator it = x1.begin(), end = x1.end();
+        typename X::size_type size = 0;
+        while(it != end) {
+            // First test that the current key has not occured before, required
+            // to test either that keys are unique or that equivalent keys are
+            // adjacent. (6.3.1/6)
+            key_type key = get_key<X>(*it);
+            if(found_.find(key) != found_.end())
+                BOOST_ERROR("Elements with equivalent keys aren't adjacent.");
+            found_.insert(key);
+
+            // Iterate over equivalent keys, counting them.
+            unsigned int count = 0;
+            do {
+                ++it;
+                ++count;
+                ++size;
+            } while(it != end && eq(get_key<X>(*it), key));
+
+            // If the container has unique keys, test that there's only one.
+            // Since the previous test makes sure that all equivalent keys are
+            // adjacent, this is all the equivalent keys - so the test is
+            // sufficient. (6.3.1/6 again).
+            if(test::has_unique_keys<X>::value && count != 1)
+                BOOST_ERROR("Non-unique key.");
+
+            if(x1.count(key) != count)
+                BOOST_ERROR("Incorrect output of count.");
+
+            // Check that the keys are in the correct bucket and are adjacent in
+            // the bucket.
+            typename X::size_type bucket = x1.bucket(key);
+            typename X::const_local_iterator lit = x1.begin(bucket), lend = x1.end(bucket);
+            for(; lit != lend && !eq(get_key<X>(*lit), key); ++lit) continue;
+            if(lit == lend)
+                BOOST_ERROR("Unable to find element with a local_iterator");
+            unsigned int count2 = 0;
+            for(; lit != lend && eq(get_key<X>(*lit), key); ++lit) ++count2;
+            if(count != count2)
+                BOOST_ERROR("Element count doesn't match local_iterator.");
+            for(; lit != lend; ++lit) {
+                if(eq(get_key<X>(*lit), key)) {
+                    BOOST_ERROR("Non-adjacent element with equivalent key in bucket.");
+                    break;
+                }
+            }
+        };
+
+        // Finally, check that size matches up.
+        if(x1.size() != size)
+            BOOST_ERROR("x1.size() doesn't match actual size.");
+        if(static_cast<float>(size) / x1.bucket_count() != x1.load_factor())
+            BOOST_ERROR("x1.load_factor() doesn't match actual load_factor.");
+    }
+}
+
+#endif
+