mirror of
https://github.com/boostorg/unordered.git
synced 2025-05-12 05:51:44 +00:00
83 lines
3.2 KiB
C++
83 lines
3.2 KiB
C++
|
|
// 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
|
|
|