// 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) #include #include #include #include "../objects/test.hpp" #include "../helpers/random_values.hpp" #include "../helpers/tracker.hpp" #include "../helpers/equivalent.hpp" #include "../helpers/invariants.hpp" template void copy_construct_tests1(T* = 0) { typename T::hasher hf; typename T::key_equal eq; { 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(x.max_load_factor() == y.max_load_factor()); test::check_equivalent_keys(y); } { test::random_values v(1000); T x(v.begin(), v.end()); T y(x); test::unordered_equivalence_tester 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. Although, // I don't think it has to. test::random_values v(1000); T x(v.begin(), v.end()); x.max_load_factor(x.load_factor() / 4); T y(x); test::unordered_equivalence_tester equivalent(x); equivalent(y); // I don't think this is guaranteed: BOOST_TEST(y.load_factor() < y.max_load_factor()); test::check_equivalent_keys(y); } } template void copy_construct_tests2(T* ptr = 0) { copy_construct_tests1(ptr); typename T::hasher hf(1); typename T::key_equal eq(1); { // TODO: I could check how many buckets y has, it should be lower (QOI issue). T x(10000, hf, eq); 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(x.max_load_factor() == y.max_load_factor()); test::check_equivalent_keys(y); } { // TODO: Invariant checks are especially important here. test::random_values v(1000); T x(v.begin(), v.end(), 0, hf, eq); T y(x); test::unordered_equivalence_tester equivalent(x); equivalent(y); test::check_equivalent_keys(y); } } int main() { copy_construct_tests1((boost::unordered_set*) 0); copy_construct_tests1((boost::unordered_multiset*) 0); copy_construct_tests1((boost::unordered_map*) 0); copy_construct_tests1((boost::unordered_multimap*) 0); copy_construct_tests2((boost::unordered_set >*) 0); copy_construct_tests2((boost::unordered_multiset >*) 0); copy_construct_tests2((boost::unordered_map >*) 0); copy_construct_tests2((boost::unordered_multimap >*) 0); return boost::report_errors(); }