mirror of
https://github.com/boostorg/unordered.git
synced 2025-10-08 05:31:00 +02:00
1c606980ec
It seems my defect report was accepted at some point, and they tweaked the requirements involving bucket counts. This also makes it possible to have a bucket count of 0, which I think wasn't allowed in the past. I don't think I'll change this implementation to do so, but I'd like to be able to run these tests against standard implementations, so I'm starting to take that into account. I believe these changes were made after the C++14 standard, but I've always been tracking the draft standards, so that doesn't really matter.
128 lines
4.5 KiB
C++
128 lines
4.5 KiB
C++
|
|
// Copyright 2006-2009 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)
|
|
|
|
// 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 <cmath>
|
|
#include "./metafunctions.hpp"
|
|
#include "./helpers.hpp"
|
|
|
|
#if defined(BOOST_MSVC)
|
|
#pragma warning(push)
|
|
#pragma warning(disable:4127) // conditional expression is constant
|
|
#pragma warning(disable:4267) // conversion from 'size_t' to 'unsigned int',
|
|
// possible loss of data
|
|
#endif
|
|
|
|
namespace test
|
|
{
|
|
template <class X>
|
|
void check_equivalent_keys(X const& x1)
|
|
{
|
|
BOOST_DEDUCED_TYPENAME X::key_equal eq = x1.key_eq();
|
|
typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
|
|
std::set<key_type, std::less<key_type> > found_;
|
|
|
|
BOOST_DEDUCED_TYPENAME X::const_iterator
|
|
it = x1.begin(), end = x1.end();
|
|
BOOST_DEDUCED_TYPENAME X::size_type size = 0;
|
|
while(it != end) {
|
|
// First test that the current key has not occurred 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_.insert(key).second)
|
|
BOOST_ERROR("Elements with equivalent keys aren't adjacent.");
|
|
|
|
// 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.");
|
|
std::cerr<<x1.count(key)<<","<<count<<"\n";
|
|
}
|
|
|
|
// Check that the keys are in the correct bucket and are
|
|
// adjacent in the bucket.
|
|
BOOST_DEDUCED_TYPENAME X::size_type bucket = x1.bucket(key);
|
|
BOOST_DEDUCED_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;
|
|
}
|
|
}
|
|
};
|
|
|
|
// Check that size matches up.
|
|
|
|
if(x1.size() != size) {
|
|
BOOST_ERROR("x1.size() doesn't match actual size.");
|
|
std::cout<<x1.size()<<"/"<<size<<std::endl;
|
|
}
|
|
|
|
// Check the load factor.
|
|
|
|
float load_factor = size == 0 ? 0 :
|
|
static_cast<float>(size) / static_cast<float>(x1.bucket_count());
|
|
using namespace std;
|
|
if(fabs(x1.load_factor() - load_factor) > x1.load_factor() / 64)
|
|
BOOST_ERROR("x1.load_factor() doesn't match actual load_factor.");
|
|
|
|
// Check that size in the buckets matches up.
|
|
|
|
BOOST_DEDUCED_TYPENAME X::size_type bucket_size = 0;
|
|
|
|
for (BOOST_DEDUCED_TYPENAME X::size_type
|
|
i = 0; i < x1.bucket_count(); ++i)
|
|
{
|
|
for (BOOST_DEDUCED_TYPENAME X::const_local_iterator
|
|
begin2 = x1.begin(i), end2 = x1.end(i);
|
|
begin2 != end2; ++begin2)
|
|
{
|
|
++bucket_size;
|
|
}
|
|
}
|
|
|
|
if(x1.size() != bucket_size) {
|
|
BOOST_ERROR("x1.size() doesn't match bucket size.");
|
|
std::cout<<x1.size()<<"/"<<bucket_size<<std::endl;
|
|
}
|
|
}
|
|
}
|
|
|
|
#if defined(BOOST_MSVC)
|
|
#pragma warning(pop)
|
|
#endif
|
|
|
|
#endif
|
|
|