forked from boostorg/unordered
Daniel James
b1ba0f65c8
https://svn.boost.org/svn/boost/branches/unordered/trunk ........ r42880 | danieljames | 2008-01-20 16:10:43 +0000 (Sun, 20 Jan 2008) | 17 lines Simplify the tests a little: Add a parameter to random_values to control what sort of values it generates. This means that instead of using equivalent_object to test collisions (which was a total hack) we now just need another parameter. This requires some meta programming to act differently for maps and sets. Because of this pairs no longer need to be generated so remove the code for doing that (which doesn't work on some compilers). Remove the generator object, just call generate directly. Remove some of the tests using int containers, they didn't really add to anthing other than the compile time (some tests are timing out). ........ [SVN r42882]
117 lines
4.0 KiB
C++
117 lines
4.0 KiB
C++
|
|
// Copyright 2006-2007 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)
|
|
|
|
#include <boost/unordered_set.hpp>
|
|
#include <boost/unordered_map.hpp>
|
|
#include <boost/detail/lightweight_test.hpp>
|
|
#include "../objects/test.hpp"
|
|
#include "../helpers/random_values.hpp"
|
|
#include "../helpers/tracker.hpp"
|
|
#include "../helpers/equivalent.hpp"
|
|
#include "../helpers/invariants.hpp"
|
|
|
|
test::seed_t seed(9063);
|
|
|
|
template <class T>
|
|
void copy_construct_tests1(T*, test::random_generator const& generator = test::default_generator)
|
|
{
|
|
BOOST_DEDUCED_TYPENAME T::hasher hf;
|
|
BOOST_DEDUCED_TYPENAME T::key_equal eq;
|
|
BOOST_DEDUCED_TYPENAME T::allocator_type al;
|
|
|
|
{
|
|
T x;
|
|
T y(x);
|
|
BOOST_TEST(y.empty());
|
|
BOOST_TEST(test::equivalent(y.hash_function(), hf));
|
|
BOOST_TEST(test::equivalent(y.key_eq(), eq));
|
|
BOOST_TEST(test::equivalent(y.get_allocator(), al));
|
|
BOOST_TEST(x.max_load_factor() == y.max_load_factor());
|
|
test::check_equivalent_keys(y);
|
|
}
|
|
|
|
{
|
|
test::random_values<T> v(1000);
|
|
|
|
T x(v.begin(), v.end());
|
|
T y(x);
|
|
test::unordered_equivalence_tester<T> equivalent(x);
|
|
equivalent(y);
|
|
test::check_equivalent_keys(y);
|
|
}
|
|
|
|
{
|
|
// In this test I drop the original containers max load factor, so it
|
|
// is much lower than the load factor. The hash table is not allowed
|
|
// to rehash, but the destination container should probably allocate
|
|
// enough buckets to decrease the load factor appropriately.
|
|
test::random_values<T> v(1000);
|
|
T x(v.begin(), v.end());
|
|
x.max_load_factor(x.load_factor() / 4);
|
|
T y(x);
|
|
test::unordered_equivalence_tester<T> equivalent(x);
|
|
equivalent(y);
|
|
// This isn't guaranteed:
|
|
BOOST_TEST(y.load_factor() < y.max_load_factor());
|
|
test::check_equivalent_keys(y);
|
|
}
|
|
}
|
|
|
|
template <class T>
|
|
void copy_construct_tests2(T* ptr, test::random_generator const& generator = test::default_generator)
|
|
{
|
|
copy_construct_tests1(ptr);
|
|
|
|
BOOST_DEDUCED_TYPENAME T::hasher hf(1);
|
|
BOOST_DEDUCED_TYPENAME T::key_equal eq(1);
|
|
BOOST_DEDUCED_TYPENAME T::allocator_type al(1);
|
|
|
|
{
|
|
T x(10000, hf, eq, al);
|
|
T y(x);
|
|
BOOST_TEST(y.empty());
|
|
BOOST_TEST(test::equivalent(y.hash_function(), hf));
|
|
BOOST_TEST(test::equivalent(y.key_eq(), eq));
|
|
BOOST_TEST(test::equivalent(y.get_allocator(), al));
|
|
BOOST_TEST(x.max_load_factor() == y.max_load_factor());
|
|
test::check_equivalent_keys(y);
|
|
}
|
|
|
|
{
|
|
test::random_values<T> v(1000);
|
|
|
|
T x(v.begin(), v.end(), 0, hf, eq, al);
|
|
T y(x);
|
|
test::unordered_equivalence_tester<T> equivalent(x);
|
|
equivalent(y);
|
|
test::check_equivalent_keys(y);
|
|
}
|
|
}
|
|
|
|
int main()
|
|
{
|
|
boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_set;
|
|
boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multiset;
|
|
boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_map;
|
|
boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multimap;
|
|
|
|
copy_construct_tests1(test_set);
|
|
copy_construct_tests1(test_multiset);
|
|
copy_construct_tests1(test_map);
|
|
copy_construct_tests1(test_multimap);
|
|
|
|
copy_construct_tests2(test_set);
|
|
copy_construct_tests2(test_multiset);
|
|
copy_construct_tests2(test_map);
|
|
copy_construct_tests2(test_multimap);
|
|
|
|
copy_construct_tests2(test_set, test::generate_collisions);
|
|
copy_construct_tests2(test_multiset, test::generate_collisions);
|
|
copy_construct_tests2(test_map, test::generate_collisions);
|
|
copy_construct_tests2(test_multimap, test::generate_collisions);
|
|
|
|
return boost::report_errors();
|
|
}
|