boost_mirror/unordered
1
0
Fork 0
mirror of https://github.com/boostorg/unordered.git synced 2025-05-12 14:01:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use Boost.Test's minimal test library for unordered & hash. It's closer to

Browse Source 
Boster.Test which makes it easier to switch to take advantage of Boost.Test's
extra testing facilities.

Merged revisions 44420 via svnmerge from 
https://svn.boost.org/svn/boost/branches/unordered/trunk

........
  r44420 | danieljames | 2008-04-14 19:02:03 +0100 (Mon, 14 Apr 2008) | 1 line
  
  Use Boost.Test's minimal test library.
........


[SVN r44487]
This commit is contained in:
Daniel James 2008-04-17 07:39:24 +00:00
parent cf529e496a
commit 9cfee57633
23 changed files with 282 additions and 285 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
test/exception/erase_exception_tests.cpp
View File

@ -25,7 +25,7 @@ struct erase_test_base : public test::exception_base
void check(T const& x) const { void check(T const& x) const {
std::string scope(test::scope); std::string scope(test::scope);
UNORDERED_CHECK(scope.find("hash::") != std::string::npos || BOOST_CHECK(scope.find("hash::") != std::string::npos ||
scope.find("equal_to::") != std::string::npos || scope.find("equal_to::") != std::string::npos ||
scope == "operator==(object, object)"); scope == "operator==(object, object)");

14
test/exception/insert_exception_tests.cpp
View File

@ -109,10 +109,10 @@ struct insert_test_rehash1 : public insert_test_base<T>
size_type bucket_count = x.bucket_count(); size_type bucket_count = x.bucket_count();
size_type initial_elements = static_cast<size_type>( size_type initial_elements = static_cast<size_type>(
ceil(bucket_count * (double) x.max_load_factor()) - 1); ceil(bucket_count * (double) x.max_load_factor()) - 1);
UNORDERED_REQUIRE(initial_elements < this->values.size()); BOOST_REQUIRE(initial_elements < this->values.size());
x.insert(this->values.begin(), x.insert(this->values.begin(),
boost::next(this->values.begin(), initial_elements)); boost::next(this->values.begin(), initial_elements));
UNORDERED_REQUIRE(bucket_count == x.bucket_count()); BOOST_REQUIRE(bucket_count == x.bucket_count());
return x; return x;
} }
@ -131,7 +131,7 @@ struct insert_test_rehash1 : public insert_test_base<T>
// This isn't actually a failure, but it means the test isn't doing its // This isn't actually a failure, but it means the test isn't doing its
// job. // job.
UNORDERED_REQUIRE(x.bucket_count() != bucket_count); BOOST_REQUIRE(x.bucket_count() != bucket_count);
} }
}; };
@ -154,7 +154,7 @@ struct insert_test_rehash2 : public insert_test_rehash1<T>
// This isn't actually a failure, but it means the test isn't doing its // This isn't actually a failure, but it means the test isn't doing its
// job. // job.
UNORDERED_REQUIRE(x.bucket_count() != bucket_count); BOOST_REQUIRE(x.bucket_count() != bucket_count);
} }
}; };
@ -178,10 +178,10 @@ struct insert_test_rehash3 : public insert_test_base<T>
size_type initial_elements = rehash_bucket_count - 5; size_type initial_elements = rehash_bucket_count - 5;
UNORDERED_REQUIRE(initial_elements < this->values.size()); BOOST_REQUIRE(initial_elements < this->values.size());
x.insert(this->values.begin(), x.insert(this->values.begin(),
boost::next(this->values.begin(), initial_elements)); boost::next(this->values.begin(), initial_elements));
UNORDERED_REQUIRE(original_bucket_count == x.bucket_count()); BOOST_REQUIRE(original_bucket_count == x.bucket_count());
return x; return x;
} }
@ -193,7 +193,7 @@ struct insert_test_rehash3 : public insert_test_base<T>
// This isn't actually a failure, but it means the test isn't doing its // This isn't actually a failure, but it means the test isn't doing its
// job. // job.
UNORDERED_REQUIRE(x.bucket_count() != bucket_count); BOOST_REQUIRE(x.bucket_count() != bucket_count);
} }
void check(T const& x) const { void check(T const& x) const {

4
test/exception/swap_exception_tests.cpp
View File

@ -22,7 +22,7 @@ struct self_swap_base : public test::exception_base
std::string scope(test::scope); std::string scope(test::scope);
#if BOOST_UNORDERED_SWAP_METHOD != 2 #if BOOST_UNORDERED_SWAP_METHOD != 2
UNORDERED_CHECK( BOOST_CHECK(
scope == "hash::operator(hash)" || scope == "hash::operator(hash)" ||
scope == "hash::operator=(hash)" || scope == "hash::operator=(hash)" ||
scope == "equal_to::operator(equal_to)" || scope == "equal_to::operator(equal_to)" ||
@ -77,7 +77,7 @@ struct swap_base : public test::exception_base
std::string scope(test::scope); std::string scope(test::scope);
#if BOOST_UNORDERED_SWAP_METHOD != 2 #if BOOST_UNORDERED_SWAP_METHOD != 2
UNORDERED_CHECK( BOOST_CHECK(
scope == "hash::operator(hash)" || scope == "hash::operator(hash)" ||
scope == "hash::operator=(hash)" || scope == "hash::operator=(hash)" ||
scope == "equal_to::operator(equal_to)" || scope == "equal_to::operator(equal_to)" ||

6
test/helpers/exception_test.hpp
View File

@ -8,7 +8,7 @@
#include "./test.hpp" #include "./test.hpp"
#if defined(BOOST_UNORDERED_USE_TEST) #if defined(BOOST_UNORDERED_FULL_TEST)
# define BOOST_TEST_MAIN # define BOOST_TEST_MAIN
# include <boost/test/exception_safety.hpp> # include <boost/test/exception_safety.hpp>
# include <boost/test/unit_test.hpp> # include <boost/test/unit_test.hpp>
@ -18,7 +18,7 @@
#include <boost/preprocessor/seq/elem.hpp> #include <boost/preprocessor/seq/elem.hpp>
#include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/cat.hpp>
#if defined(BOOST_UNORDERED_USE_TEST) #if defined(BOOST_UNORDERED_FULL_TEST)
# define UNORDERED_EXCEPTION_TEST_CASE(name, test_func, type) \ # define UNORDERED_EXCEPTION_TEST_CASE(name, test_func, type) \
UNORDERED_AUTO_TEST(name) \ UNORDERED_AUTO_TEST(name) \
{ \ { \
@ -181,7 +181,7 @@ namespace test {
#if defined(BOOST_UNORDERED_USE_TEST) #if defined(BOOST_UNORDERED_FULL_TEST)
template <class Test> template <class Test>
void exception_safety(Test const& f, char const* name) { void exception_safety(Test const& f, char const* name) {
test_runner<Test> runner(f); test_runner<Test> runner(f);

10
test/helpers/test.hpp
View File

@ -6,21 +6,17 @@
#if !defined(BOOST_UNORDERED_TEST_TEST_HEADER) #if !defined(BOOST_UNORDERED_TEST_TEST_HEADER)
#define BOOST_UNORDERED_TEST_TEST_HEADER #define BOOST_UNORDERED_TEST_TEST_HEADER
#if defined(BOOST_UNORDERED_USE_TEST) #if defined(BOOST_UNORDERED_FULL_TEST)
#include <boost/test/test_tools.hpp> #include <boost/test/test_tools.hpp>
#define UNORDERED_CHECK(x) BOOST_CHECK(x)
#define UNORDERED_REQUIRE(x) BOOST_REQUIRE(x)
#define UNORDERED_AUTO_TEST(x) BOOST_AUTO_TEST_CASE(x) #define UNORDERED_AUTO_TEST(x) BOOST_AUTO_TEST_CASE(x)
#define RUN_TESTS() #define RUN_TESTS()
#else #else
#include <boost/detail/lightweight_test.hpp> #include <boost/test/minimal.hpp>
#include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/cat.hpp>
#define UNORDERED_CHECK(x) BOOST_TEST(x)
#define UNORDERED_REQUIRE(x) if(!(x)) { BOOST_ERROR(BOOST_STRINGIZE(x)); throw ::test::lightweight::test_failure(); }
#define UNORDERED_AUTO_TEST(x) \ #define UNORDERED_AUTO_TEST(x) \
struct BOOST_PP_CAT(x, _type) : public ::test::registered_test_base { \ struct BOOST_PP_CAT(x, _type) : public ::test::registered_test_base { \
BOOST_PP_CAT(x, _type)() { \ BOOST_PP_CAT(x, _type)() { \
@ -30,7 +26,7 @@
}; \ }; \
BOOST_PP_CAT(x, _type) x; \ BOOST_PP_CAT(x, _type) x; \
void BOOST_PP_CAT(x, _type)::run() void BOOST_PP_CAT(x, _type)::run()
#define RUN_TESTS() int main() { ::test::test_list::run_tests(); return boost::report_errors(); } #define RUN_TESTS() int test_main(int, char**) { ::test::test_list::run_tests(); return 0; }
namespace test { namespace test {
struct registered_test_base { struct registered_test_base {

4
test/helpers/tracker.hpp
View File

@ -51,7 +51,7 @@ namespace test
std::copy(x2.begin(), x2.end(), std::back_inserter(values2)); std::copy(x2.begin(), x2.end(), std::back_inserter(values2));
std::sort(values1.begin(), values1.end()); std::sort(values1.begin(), values1.end());
std::sort(values2.begin(), values2.end()); std::sort(values2.begin(), values2.end());
BOOST_TEST(values1.size() == values2.size() && BOOST_CHECK(values1.size() == values2.size() &&
std::equal(values1.begin(), values1.end(), values2.begin(), test::equivalent)); std::equal(values1.begin(), values1.end(), values2.begin(), test::equivalent));
} }
@ -65,7 +65,7 @@ namespace test
std::copy(x2.first, x2.second, std::back_inserter(values2)); std::copy(x2.first, x2.second, std::back_inserter(values2));
std::sort(values1.begin(), values1.end()); std::sort(values1.begin(), values1.end());
std::sort(values2.begin(), values2.end()); std::sort(values2.begin(), values2.end());
BOOST_TEST(values1.size() == values2.size() && BOOST_CHECK(values1.size() == values2.size() &&
std::equal(values1.begin(), values1.end(), values2.begin(), test::equivalent)); std::equal(values1.begin(), values1.end(), values2.begin(), test::equivalent));
} }

18
test/objects/memory.hpp
View File

@ -103,7 +103,7 @@ namespace test
void allocator_unref() void allocator_unref()
{ {
UNORDERED_CHECK(count_allocators > 0); BOOST_CHECK(count_allocators > 0);
if(count_allocators > 0) { if(count_allocators > 0) {
--count_allocators; --count_allocators;
if(count_allocators == 0) { if(count_allocators == 0) {
@ -116,9 +116,9 @@ namespace test
count_constructions = 0; count_constructions = 0;
allocated_memory.clear(); allocated_memory.clear();
UNORDERED_CHECK(no_allocations_left); BOOST_CHECK(no_allocations_left);
UNORDERED_CHECK(no_constructions_left); BOOST_CHECK(no_constructions_left);
UNORDERED_CHECK(allocated_memory_empty); BOOST_CHECK(allocated_memory_empty);
} }
} }
} }
@ -144,12 +144,12 @@ namespace test
if(pos == allocated_memory.end()) { if(pos == allocated_memory.end()) {
BOOST_ERROR("Deallocating unknown pointer."); BOOST_ERROR("Deallocating unknown pointer.");
} else { } else {
UNORDERED_CHECK(pos->first.start == ptr); BOOST_CHECK(pos->first.start == ptr);
UNORDERED_CHECK(pos->first.end == (char*) ptr + n * size); BOOST_CHECK(pos->first.end == (char*) ptr + n * size);
UNORDERED_CHECK(pos->second.tag_ == tag); BOOST_CHECK(pos->second.tag_ == tag);
allocated_memory.erase(pos); allocated_memory.erase(pos);
} }
UNORDERED_CHECK(count_allocations > 0); BOOST_CHECK(count_allocations > 0);
if(count_allocations > 0) --count_allocations; if(count_allocations > 0) --count_allocations;
} }
@ -160,7 +160,7 @@ namespace test
void track_destroy(void* ptr, std::size_t /*size*/, int tag) void track_destroy(void* ptr, std::size_t /*size*/, int tag)
{ {
UNORDERED_CHECK(count_constructions > 0); BOOST_CHECK(count_constructions > 0);
if(count_constructions > 0) --count_constructions; if(count_constructions > 0) --count_constructions;
} }
}; };

18
test/unordered/assign_tests.cpp
View File

@ -27,9 +27,9 @@ void assign_tests1(T*, test::random_generator generator = test::default_generato
{ {
T x; T x;
x = x; x = x;
BOOST_TEST(x.empty()); BOOST_CHECK(x.empty());
BOOST_TEST(test::equivalent(x.hash_function(), hf)); BOOST_CHECK(test::equivalent(x.hash_function(), hf));
BOOST_TEST(test::equivalent(x.key_eq(), eq)); BOOST_CHECK(test::equivalent(x.key_eq(), eq));
} }
std::cerr<<"assign_tests1.2\n"; std::cerr<<"assign_tests1.2\n";
@ -47,7 +47,7 @@ void assign_tests1(T*, test::random_generator generator = test::default_generato
y.max_load_factor(x.max_load_factor() / 20); y.max_load_factor(x.max_load_factor() / 20);
y = x; y = x;
tracker.compare(y); tracker.compare(y);
BOOST_TEST(x.max_load_factor() == y.max_load_factor()); BOOST_CHECK(x.max_load_factor() == y.max_load_factor());
} }
} }
@ -67,8 +67,8 @@ void assign_tests2(T*, test::random_generator generator = test::default_generato
T x1(v.begin(), v.end(), 0, hf1, eq1); T x1(v.begin(), v.end(), 0, hf1, eq1);
T x2(0, hf2, eq2); T x2(0, hf2, eq2);
x2 = x1; x2 = x1;
BOOST_TEST(test::equivalent(x2.hash_function(), hf1)); BOOST_CHECK(test::equivalent(x2.hash_function(), hf1));
BOOST_TEST(test::equivalent(x2.key_eq(), eq1)); BOOST_CHECK(test::equivalent(x2.key_eq(), eq1));
test::check_container(x2, v); test::check_container(x2, v);
} }
@ -78,9 +78,9 @@ void assign_tests2(T*, test::random_generator generator = test::default_generato
T x1(v1.begin(), v1.end(), 0, hf1, eq1, al1); T x1(v1.begin(), v1.end(), 0, hf1, eq1, al1);
T x2(v2.begin(), v2.end(), 0, hf2, eq2, al2); T x2(v2.begin(), v2.end(), 0, hf2, eq2, al2);
x2 = x1; x2 = x1;
BOOST_TEST(test::equivalent(x2.hash_function(), hf1)); BOOST_CHECK(test::equivalent(x2.hash_function(), hf1));
BOOST_TEST(test::equivalent(x2.key_eq(), eq1)); BOOST_CHECK(test::equivalent(x2.key_eq(), eq1));
BOOST_TEST(test::equivalent(x2.get_allocator(), al2)); BOOST_CHECK(test::equivalent(x2.get_allocator(), al2));
test::check_container(x2, v1); test::check_container(x2, v1);
} }
} }

4
test/unordered/at_tests.cpp
View File

@ -16,8 +16,8 @@ UNORDERED_AUTO_TEST(at_tests) {
x["one"] = 1; x["one"] = 1;
x["two"] = 2; x["two"] = 2;
BOOST_TEST(x.at("one") == 1); BOOST_CHECK(x.at("one") == 1);
BOOST_TEST(x.at("two") == 2); BOOST_CHECK(x.at("two") == 2);
try { try {
x.at("three"); x.at("three");

14
test/unordered/bucket_tests.cpp
View File

@ -24,7 +24,7 @@ void bucket_tests(X* = 0)
X x(v.begin(), v.end()); X x(v.begin(), v.end());
BOOST_TEST(x.bucket_count() < x.max_bucket_count()); BOOST_CHECK(x.bucket_count() < x.max_bucket_count());
std::cerr<<x.bucket_count()<<"<"<<x.max_bucket_count()<<"\n"; std::cerr<<x.bucket_count()<<"<"<<x.max_bucket_count()<<"\n";
for(BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator for(BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator
@ -32,21 +32,21 @@ void bucket_tests(X* = 0)
{ {
size_type bucket = x.bucket(test::get_key<X>(*it)); size_type bucket = x.bucket(test::get_key<X>(*it));
BOOST_TEST(bucket < x.bucket_count()); BOOST_CHECK(bucket < x.bucket_count());
if(bucket < x.max_bucket_count()) { if(bucket < x.max_bucket_count()) {
// lit? lend?? I need a new naming scheme. // lit? lend?? I need a new naming scheme.
const_local_iterator lit = x.begin(bucket), lend = x.end(bucket); const_local_iterator lit = x.begin(bucket), lend = x.end(bucket);
while(lit != lend && test::get_key<X>(*it) != test::get_key<X>(*lit)) ++lit; while(lit != lend && test::get_key<X>(*it) != test::get_key<X>(*lit)) ++lit;
BOOST_TEST(lit != lend); BOOST_CHECK(lit != lend);
} }
} }
for(size_type i = 0; i < x.bucket_count(); ++i) { for(size_type i = 0; i < x.bucket_count(); ++i) {
BOOST_TEST(x.bucket_size(i) == (size_type) std::distance(x.begin(i), x.end(i))); BOOST_CHECK(x.bucket_size(i) == (size_type) std::distance(x.begin(i), x.end(i)));
BOOST_TEST(x.bucket_size(i) == (size_type) std::distance(x.cbegin(i), x.cend(i))); BOOST_CHECK(x.bucket_size(i) == (size_type) std::distance(x.cbegin(i), x.cend(i)));
X const& x_ref = x; X const& x_ref = x;
BOOST_TEST(x.bucket_size(i) == (size_type) std::distance(x_ref.begin(i), x_ref.end(i))); BOOST_CHECK(x.bucket_size(i) == (size_type) std::distance(x_ref.begin(i), x_ref.end(i)));
BOOST_TEST(x.bucket_size(i) == (size_type) std::distance(x_ref.cbegin(i), x_ref.cend(i))); BOOST_CHECK(x.bucket_size(i) == (size_type) std::distance(x_ref.cbegin(i), x_ref.cend(i)));
} }
} }

10
test/unordered/compile_tests.hpp
View File

@ -86,10 +86,10 @@ void container_test(X& r, T&)
// I'm not sure about either of these tests... // I'm not sure about either of these tests...
size_type max_diff((std::numeric_limits<difference_type>::max)()); size_type max_diff((std::numeric_limits<difference_type>::max)());
difference_type converted_diff(max_diff); difference_type converted_diff(max_diff);
BOOST_TEST((std::numeric_limits<difference_type>::max)() BOOST_CHECK((std::numeric_limits<difference_type>::max)()
== converted_diff); == converted_diff);
BOOST_TEST( BOOST_CHECK(
static_cast<comparison_type>( static_cast<comparison_type>(
(std::numeric_limits<size_type>::max)()) > (std::numeric_limits<size_type>::max)()) >
static_cast<comparison_type>( static_cast<comparison_type>(
@ -97,8 +97,8 @@ void container_test(X& r, T&)
// I don't test the runtime post-conditions here. // I don't test the runtime post-conditions here.
X u; X u;
BOOST_TEST(u.size() == 0); BOOST_CHECK(u.size() == 0);
BOOST_TEST(X().size() == 0); BOOST_CHECK(X().size() == 0);
X a,b; X a,b;
@ -263,7 +263,7 @@ void unordered_test(X&, Key& k, T& t, Hash& hf, Pred& eq)
a.insert(i, j); a.insert(i, j);
test::check_return_type<size_type>::equals(a.erase(k)); test::check_return_type<size_type>::equals(a.erase(k));
BOOST_TEST(a.empty()); BOOST_CHECK(a.empty());
if(a.empty()) { if(a.empty()) {
a.insert(t); a.insert(t);
q = a.cbegin(); q = a.cbegin();

122
test/unordered/constructor_tests.cpp
View File

@ -29,42 +29,42 @@ void constructor_tests1(T*, test::random_generator generator = test::default_gen
std::cerr<<"Construct 1\n"; std::cerr<<"Construct 1\n";
{ {
T x(0, hf, eq); T x(0, hf, eq);
BOOST_TEST(x.empty()); BOOST_CHECK(x.empty());
BOOST_TEST(test::equivalent(x.hash_function(), hf)); BOOST_CHECK(test::equivalent(x.hash_function(), hf));
BOOST_TEST(test::equivalent(x.key_eq(), eq)); BOOST_CHECK(test::equivalent(x.key_eq(), eq));
BOOST_TEST(test::equivalent(x.get_allocator(), al)); BOOST_CHECK(test::equivalent(x.get_allocator(), al));
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
} }
std::cerr<<"Construct 2\n"; std::cerr<<"Construct 2\n";
{ {
T x(100, hf); T x(100, hf);
BOOST_TEST(x.empty()); BOOST_CHECK(x.empty());
BOOST_TEST(x.bucket_count() >= 100); BOOST_CHECK(x.bucket_count() >= 100);
BOOST_TEST(test::equivalent(x.hash_function(), hf)); BOOST_CHECK(test::equivalent(x.hash_function(), hf));
BOOST_TEST(test::equivalent(x.key_eq(), eq)); BOOST_CHECK(test::equivalent(x.key_eq(), eq));
BOOST_TEST(test::equivalent(x.get_allocator(), al)); BOOST_CHECK(test::equivalent(x.get_allocator(), al));
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
} }
std::cerr<<"Construct 3\n"; std::cerr<<"Construct 3\n";
{ {
T x(2000); T x(2000);
BOOST_TEST(x.empty()); BOOST_CHECK(x.empty());
BOOST_TEST(x.bucket_count() >= 2000); BOOST_CHECK(x.bucket_count() >= 2000);
BOOST_TEST(test::equivalent(x.hash_function(), hf)); BOOST_CHECK(test::equivalent(x.hash_function(), hf));
BOOST_TEST(test::equivalent(x.key_eq(), eq)); BOOST_CHECK(test::equivalent(x.key_eq(), eq));
BOOST_TEST(test::equivalent(x.get_allocator(), al)); BOOST_CHECK(test::equivalent(x.get_allocator(), al));
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
} }
std::cerr<<"Construct 4\n"; std::cerr<<"Construct 4\n";
{ {
T x; T x;
BOOST_TEST(x.empty()); BOOST_CHECK(x.empty());
BOOST_TEST(test::equivalent(x.hash_function(), hf)); BOOST_CHECK(test::equivalent(x.hash_function(), hf));
BOOST_TEST(test::equivalent(x.key_eq(), eq)); BOOST_CHECK(test::equivalent(x.key_eq(), eq));
BOOST_TEST(test::equivalent(x.get_allocator(), al)); BOOST_CHECK(test::equivalent(x.get_allocator(), al));
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
} }
@ -72,10 +72,10 @@ void constructor_tests1(T*, test::random_generator generator = test::default_gen
{ {
test::random_values<T> v(1000, generator); test::random_values<T> v(1000, generator);
T x(v.begin(), v.end(), 10000, hf, eq); T x(v.begin(), v.end(), 10000, hf, eq);
BOOST_TEST(x.bucket_count() >= 10000); BOOST_CHECK(x.bucket_count() >= 10000);
BOOST_TEST(test::equivalent(x.hash_function(), hf)); BOOST_CHECK(test::equivalent(x.hash_function(), hf));
BOOST_TEST(test::equivalent(x.key_eq(), eq)); BOOST_CHECK(test::equivalent(x.key_eq(), eq));
BOOST_TEST(test::equivalent(x.get_allocator(), al)); BOOST_CHECK(test::equivalent(x.get_allocator(), al));
test::check_container(x, v); test::check_container(x, v);
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
} }
@ -84,10 +84,10 @@ void constructor_tests1(T*, test::random_generator generator = test::default_gen
{ {
test::random_values<T> v(10, generator); test::random_values<T> v(10, generator);
T x(v.begin(), v.end(), 10000, hf); T x(v.begin(), v.end(), 10000, hf);
BOOST_TEST(x.bucket_count() >= 10000); BOOST_CHECK(x.bucket_count() >= 10000);
BOOST_TEST(test::equivalent(x.hash_function(), hf)); BOOST_CHECK(test::equivalent(x.hash_function(), hf));
BOOST_TEST(test::equivalent(x.key_eq(), eq)); BOOST_CHECK(test::equivalent(x.key_eq(), eq));
BOOST_TEST(test::equivalent(x.get_allocator(), al)); BOOST_CHECK(test::equivalent(x.get_allocator(), al));
test::check_container(x, v); test::check_container(x, v);
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
} }
@ -96,10 +96,10 @@ void constructor_tests1(T*, test::random_generator generator = test::default_gen
{ {
test::random_values<T> v(100, generator); test::random_values<T> v(100, generator);
T x(v.begin(), v.end(), 100); T x(v.begin(), v.end(), 100);
BOOST_TEST(x.bucket_count() >= 100); BOOST_CHECK(x.bucket_count() >= 100);
BOOST_TEST(test::equivalent(x.hash_function(), hf)); BOOST_CHECK(test::equivalent(x.hash_function(), hf));
BOOST_TEST(test::equivalent(x.key_eq(), eq)); BOOST_CHECK(test::equivalent(x.key_eq(), eq));
BOOST_TEST(test::equivalent(x.get_allocator(), al)); BOOST_CHECK(test::equivalent(x.get_allocator(), al));
test::check_container(x, v); test::check_container(x, v);
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
} }
@ -108,9 +108,9 @@ void constructor_tests1(T*, test::random_generator generator = test::default_gen
{ {
test::random_values<T> v(1, generator); test::random_values<T> v(1, generator);
T x(v.begin(), v.end()); T x(v.begin(), v.end());
BOOST_TEST(test::equivalent(x.hash_function(), hf)); BOOST_CHECK(test::equivalent(x.hash_function(), hf));
BOOST_TEST(test::equivalent(x.key_eq(), eq)); BOOST_CHECK(test::equivalent(x.key_eq(), eq));
BOOST_TEST(test::equivalent(x.get_allocator(), al)); BOOST_CHECK(test::equivalent(x.get_allocator(), al));
test::check_container(x, v); test::check_container(x, v);
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
} }
@ -118,10 +118,10 @@ void constructor_tests1(T*, test::random_generator generator = test::default_gen
std::cerr<<"Construct 9\n"; std::cerr<<"Construct 9\n";
{ {
T x(0, hf, eq, al); T x(0, hf, eq, al);
BOOST_TEST(x.empty()); BOOST_CHECK(x.empty());
BOOST_TEST(test::equivalent(x.hash_function(), hf)); BOOST_CHECK(test::equivalent(x.hash_function(), hf));
BOOST_TEST(test::equivalent(x.key_eq(), eq)); BOOST_CHECK(test::equivalent(x.key_eq(), eq));
BOOST_TEST(test::equivalent(x.get_allocator(), al)); BOOST_CHECK(test::equivalent(x.get_allocator(), al));
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
} }
@ -129,10 +129,10 @@ void constructor_tests1(T*, test::random_generator generator = test::default_gen
{ {
test::random_values<T> v(1000, generator); test::random_values<T> v(1000, generator);
T x(v.begin(), v.end(), 10000, hf, eq, al); T x(v.begin(), v.end(), 10000, hf, eq, al);
BOOST_TEST(x.bucket_count() >= 10000); BOOST_CHECK(x.bucket_count() >= 10000);
BOOST_TEST(test::equivalent(x.hash_function(), hf)); BOOST_CHECK(test::equivalent(x.hash_function(), hf));
BOOST_TEST(test::equivalent(x.key_eq(), eq)); BOOST_CHECK(test::equivalent(x.key_eq(), eq));
BOOST_TEST(test::equivalent(x.get_allocator(), al)); BOOST_CHECK(test::equivalent(x.get_allocator(), al));
test::check_container(x, v); test::check_container(x, v);
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
} }
@ -141,10 +141,10 @@ void constructor_tests1(T*, test::random_generator generator = test::default_gen
{ {
test::random_values<T> v(1000, generator); test::random_values<T> v(1000, generator);
T x(al); T x(al);
BOOST_TEST(x.empty()); BOOST_CHECK(x.empty());
BOOST_TEST(test::equivalent(x.hash_function(), hf)); BOOST_CHECK(test::equivalent(x.hash_function(), hf));
BOOST_TEST(test::equivalent(x.key_eq(), eq)); BOOST_CHECK(test::equivalent(x.key_eq(), eq));
BOOST_TEST(test::equivalent(x.get_allocator(), al)); BOOST_CHECK(test::equivalent(x.get_allocator(), al));
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
} }
} }
@ -165,21 +165,21 @@ void constructor_tests2(T*, test::random_generator const& generator = test::defa
std::cerr<<"Construct 1\n"; std::cerr<<"Construct 1\n";
{ {
T x(10000, hf1, eq1); T x(10000, hf1, eq1);
BOOST_TEST(x.bucket_count() >= 10000); BOOST_CHECK(x.bucket_count() >= 10000);
BOOST_TEST(test::equivalent(x.hash_function(), hf1)); BOOST_CHECK(test::equivalent(x.hash_function(), hf1));
BOOST_TEST(test::equivalent(x.key_eq(), eq1)); BOOST_CHECK(test::equivalent(x.key_eq(), eq1));
BOOST_TEST(test::equivalent(x.get_allocator(), al)); BOOST_CHECK(test::equivalent(x.get_allocator(), al));
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
} }
std::cerr<<"Construct 2\n"; std::cerr<<"Construct 2\n";
{ {
T x(100, hf1); T x(100, hf1);
BOOST_TEST(x.empty()); BOOST_CHECK(x.empty());
BOOST_TEST(x.bucket_count() >= 100); BOOST_CHECK(x.bucket_count() >= 100);
BOOST_TEST(test::equivalent(x.hash_function(), hf1)); BOOST_CHECK(test::equivalent(x.hash_function(), hf1));
BOOST_TEST(test::equivalent(x.key_eq(), eq)); BOOST_CHECK(test::equivalent(x.key_eq(), eq));
BOOST_TEST(test::equivalent(x.get_allocator(), al)); BOOST_CHECK(test::equivalent(x.get_allocator(), al));
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
} }
@ -187,9 +187,9 @@ void constructor_tests2(T*, test::random_generator const& generator = test::defa
{ {
test::random_values<T> v(100, generator); test::random_values<T> v(100, generator);
T x(v.begin(), v.end(), 0, hf1, eq1); T x(v.begin(), v.end(), 0, hf1, eq1);
BOOST_TEST(test::equivalent(x.hash_function(), hf1)); BOOST_CHECK(test::equivalent(x.hash_function(), hf1));
BOOST_TEST(test::equivalent(x.key_eq(), eq1)); BOOST_CHECK(test::equivalent(x.key_eq(), eq1));
BOOST_TEST(test::equivalent(x.get_allocator(), al)); BOOST_CHECK(test::equivalent(x.get_allocator(), al));
test::check_container(x, v); test::check_container(x, v);
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
} }
@ -198,10 +198,10 @@ void constructor_tests2(T*, test::random_generator const& generator = test::defa
{ {
test::random_values<T> v(5, generator); test::random_values<T> v(5, generator);
T x(v.begin(), v.end(), 1000, hf1); T x(v.begin(), v.end(), 1000, hf1);
BOOST_TEST(x.bucket_count() >= 1000); BOOST_CHECK(x.bucket_count() >= 1000);
BOOST_TEST(test::equivalent(x.hash_function(), hf1)); BOOST_CHECK(test::equivalent(x.hash_function(), hf1));
BOOST_TEST(test::equivalent(x.key_eq(), eq)); BOOST_CHECK(test::equivalent(x.key_eq(), eq));
BOOST_TEST(test::equivalent(x.get_allocator(), al)); BOOST_CHECK(test::equivalent(x.get_allocator(), al));
test::check_container(x, v); test::check_container(x, v);
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
} }

36
test/unordered/copy_tests.cpp
View File

@ -27,11 +27,11 @@ void copy_construct_tests1(T*, test::random_generator const& generator = test::d
{ {
T x; T x;
T y(x); T y(x);
BOOST_TEST(y.empty()); BOOST_CHECK(y.empty());
BOOST_TEST(test::equivalent(y.hash_function(), hf)); BOOST_CHECK(test::equivalent(y.hash_function(), hf));
BOOST_TEST(test::equivalent(y.key_eq(), eq)); BOOST_CHECK(test::equivalent(y.key_eq(), eq));
BOOST_TEST(test::equivalent(y.get_allocator(), al)); BOOST_CHECK(test::equivalent(y.get_allocator(), al));
BOOST_TEST(x.max_load_factor() == y.max_load_factor()); BOOST_CHECK(x.max_load_factor() == y.max_load_factor());
test::check_equivalent_keys(y); test::check_equivalent_keys(y);
} }
@ -57,7 +57,7 @@ void copy_construct_tests1(T*, test::random_generator const& generator = test::d
test::unordered_equivalence_tester<T> equivalent(x); test::unordered_equivalence_tester<T> equivalent(x);
equivalent(y); equivalent(y);
// This isn't guaranteed: // This isn't guaranteed:
BOOST_TEST(y.load_factor() < y.max_load_factor()); BOOST_CHECK(y.load_factor() < y.max_load_factor());
test::check_equivalent_keys(y); test::check_equivalent_keys(y);
} }
} }
@ -75,22 +75,22 @@ void copy_construct_tests2(T* ptr, test::random_generator const& generator = tes
{ {
T x(10000, hf, eq, al); T x(10000, hf, eq, al);
T y(x); T y(x);
BOOST_TEST(y.empty()); BOOST_CHECK(y.empty());
BOOST_TEST(test::equivalent(y.hash_function(), hf)); BOOST_CHECK(test::equivalent(y.hash_function(), hf));
BOOST_TEST(test::equivalent(y.key_eq(), eq)); BOOST_CHECK(test::equivalent(y.key_eq(), eq));
BOOST_TEST(test::equivalent(y.get_allocator(), al)); BOOST_CHECK(test::equivalent(y.get_allocator(), al));
BOOST_TEST(x.max_load_factor() == y.max_load_factor()); BOOST_CHECK(x.max_load_factor() == y.max_load_factor());
test::check_equivalent_keys(y); test::check_equivalent_keys(y);
} }
{ {
T x(1000, hf, eq, al); T x(1000, hf, eq, al);
T y(x, al2); T y(x, al2);
BOOST_TEST(y.empty()); BOOST_CHECK(y.empty());
BOOST_TEST(test::equivalent(y.hash_function(), hf)); BOOST_CHECK(test::equivalent(y.hash_function(), hf));
BOOST_TEST(test::equivalent(y.key_eq(), eq)); BOOST_CHECK(test::equivalent(y.key_eq(), eq));
BOOST_TEST(test::equivalent(y.get_allocator(), al2)); BOOST_CHECK(test::equivalent(y.get_allocator(), al2));
BOOST_TEST(x.max_load_factor() == y.max_load_factor()); BOOST_CHECK(x.max_load_factor() == y.max_load_factor());
test::check_equivalent_keys(y); test::check_equivalent_keys(y);
} }
@ -102,7 +102,7 @@ void copy_construct_tests2(T* ptr, test::random_generator const& generator = tes
test::unordered_equivalence_tester<T> equivalent(x); test::unordered_equivalence_tester<T> equivalent(x);
equivalent(y); equivalent(y);
test::check_equivalent_keys(y); test::check_equivalent_keys(y);
BOOST_TEST(test::equivalent(y.get_allocator(), al)); BOOST_CHECK(test::equivalent(y.get_allocator(), al));
} }
{ {
@ -113,7 +113,7 @@ void copy_construct_tests2(T* ptr, test::random_generator const& generator = tes
test::unordered_equivalence_tester<T> equivalent(x); test::unordered_equivalence_tester<T> equivalent(x);
equivalent(y); equivalent(y);
test::check_equivalent_keys(y); test::check_equivalent_keys(y);
BOOST_TEST(test::equivalent(y.get_allocator(), al2)); BOOST_CHECK(test::equivalent(y.get_allocator(), al2));
} }
} }

12
test/unordered/erase_equiv_tests.cpp
View File

@ -67,11 +67,11 @@ UNORDERED_AUTO_TEST(single_item_tests)
collide_map x(init.begin(), init.end()); collide_map x(init.begin(), init.end());
x.erase(x.begin(), x.begin()); x.erase(x.begin(), x.begin());
BOOST_TEST(x.count(1) == 1 && x.size() == 1); BOOST_CHECK(x.count(1) == 1 && x.size() == 1);
x.erase(x.end(), x.end()); x.erase(x.end(), x.end());
BOOST_TEST(x.count(1) == 1 && x.size() == 1); BOOST_CHECK(x.count(1) == 1 && x.size() == 1);
x.erase(x.begin(), x.end()); x.erase(x.begin(), x.end());
BOOST_TEST(x.count(1) == 0 && x.size() == 0); BOOST_CHECK(x.count(1) == 0 && x.size() == 0);
} }
UNORDERED_AUTO_TEST(two_equivalent_item_tests) UNORDERED_AUTO_TEST(two_equivalent_item_tests)
@ -83,14 +83,14 @@ UNORDERED_AUTO_TEST(two_equivalent_item_tests)
{ {
collide_map x(init.begin(), init.end()); collide_map x(init.begin(), init.end());
x.erase(x.begin(), x.end()); x.erase(x.begin(), x.end());
BOOST_TEST(x.count(1) == 0 && x.size() == 0); BOOST_CHECK(x.count(1) == 0 && x.size() == 0);
} }
{ {
collide_map x(init.begin(), init.end()); collide_map x(init.begin(), init.end());
int value = boost::next(x.begin())->second; int value = boost::next(x.begin())->second;
x.erase(x.begin(), boost::next(x.begin())); x.erase(x.begin(), boost::next(x.begin()));
BOOST_TEST(x.count(1) == 1 && x.size() == 1 && BOOST_CHECK(x.count(1) == 1 && x.size() == 1 &&
x.begin()->first == 1 && x.begin()->second == value); x.begin()->first == 1 && x.begin()->second == value);
} }
@ -98,7 +98,7 @@ UNORDERED_AUTO_TEST(two_equivalent_item_tests)
collide_map x(init.begin(), init.end()); collide_map x(init.begin(), init.end());
int value = x.begin()->second; int value = x.begin()->second;
x.erase(boost::next(x.begin()), x.end()); x.erase(boost::next(x.begin()), x.end());
BOOST_TEST(x.count(1) == 1 && x.size() == 1 && BOOST_CHECK(x.count(1) == 1 && x.size() == 1 &&
x.begin()->first == 1 && x.begin()->second == value); x.begin()->first == 1 && x.begin()->second == value);
} }
} }

44
test/unordered/erase_tests.cpp
View File

@ -32,10 +32,10 @@ void erase_tests1(Container*, test::random_generator generator = test::default_g
{ {
std::size_t count = x.count(test::get_key<Container>(*it)); std::size_t count = x.count(test::get_key<Container>(*it));
std::size_t old_size = x.size(); std::size_t old_size = x.size();
BOOST_TEST(count == x.erase(test::get_key<Container>(*it))); BOOST_CHECK(count == x.erase(test::get_key<Container>(*it)));
BOOST_TEST(x.size() == old_size - count); BOOST_CHECK(x.size() == old_size - count);
BOOST_TEST(x.count(test::get_key<Container>(*it)) == 0); BOOST_CHECK(x.count(test::get_key<Container>(*it)) == 0);
BOOST_TEST(x.find(test::get_key<Container>(*it)) == x.end()); BOOST_CHECK(x.find(test::get_key<Container>(*it)) == x.end());
} }
} }
@ -50,11 +50,11 @@ void erase_tests1(Container*, test::random_generator generator = test::default_g
std::size_t count = x.count(key); std::size_t count = x.count(key);
BOOST_DEDUCED_TYPENAME Container::iterator pos = x.erase(x.begin()); BOOST_DEDUCED_TYPENAME Container::iterator pos = x.erase(x.begin());
--size; --size;
BOOST_TEST(pos == x.begin()); BOOST_CHECK(pos == x.begin());
BOOST_TEST(x.count(key) == count - 1); BOOST_CHECK(x.count(key) == count - 1);
BOOST_TEST(x.size() == size); BOOST_CHECK(x.size() == size);
} }
BOOST_TEST(x.empty()); BOOST_CHECK(x.empty());
} }
std::cerr<<"erase(random position).\n"; std::cerr<<"erase(random position).\n";
@ -77,15 +77,15 @@ void erase_tests1(Container*, test::random_generator generator = test::default_g
next = boost::next(pos); next = boost::next(pos);
BOOST_DEDUCED_TYPENAME Container::key_type key = test::get_key<Container>(*pos); BOOST_DEDUCED_TYPENAME Container::key_type key = test::get_key<Container>(*pos);
std::size_t count = x.count(key); std::size_t count = x.count(key);
BOOST_TEST(next == x.erase(pos)); BOOST_CHECK(next == x.erase(pos));
--size; --size;
if(size > 0) if(size > 0)
BOOST_TEST(index == 0 ? next == x.begin() : BOOST_CHECK(index == 0 ? next == x.begin() :
next == boost::next(prev)); next == boost::next(prev));
BOOST_TEST(x.count(key) == count - 1); BOOST_CHECK(x.count(key) == count - 1);
BOOST_TEST(x.size() == size); BOOST_CHECK(x.size() == size);
} }
BOOST_TEST(x.empty()); BOOST_CHECK(x.empty());
} }
std::cerr<<"erase(ranges).\n"; std::cerr<<"erase(ranges).\n";
@ -99,15 +99,15 @@ void erase_tests1(Container*, test::random_generator generator = test::default_g
// returns 'the iterator immediately following the erase elements' // returns 'the iterator immediately following the erase elements'
// and if nothing is erased, then there's nothing to follow. But I // and if nothing is erased, then there's nothing to follow. But I
// think this is the only sensible option... // think this is the only sensible option...
BOOST_TEST(x.erase(x.end(), x.end()) == x.end()); BOOST_CHECK(x.erase(x.end(), x.end()) == x.end());
BOOST_TEST(x.erase(x.begin(), x.begin()) == x.begin()); BOOST_CHECK(x.erase(x.begin(), x.begin()) == x.begin());
BOOST_TEST(x.size() == size); BOOST_CHECK(x.size() == size);
BOOST_TEST(x.erase(x.begin(), x.end()) == x.end()); BOOST_CHECK(x.erase(x.begin(), x.end()) == x.end());
BOOST_TEST(x.empty()); BOOST_CHECK(x.empty());
BOOST_TEST(x.begin() == x.end()); BOOST_CHECK(x.begin() == x.end());
BOOST_TEST(x.erase(x.begin(), x.end()) == x.begin()); BOOST_CHECK(x.erase(x.begin(), x.end()) == x.begin());
} }
std::cerr<<"clear().\n"; std::cerr<<"clear().\n";
@ -115,8 +115,8 @@ void erase_tests1(Container*, test::random_generator generator = test::default_g
test::random_values<Container> v(500, generator); test::random_values<Container> v(500, generator);
Container x(v.begin(), v.end()); Container x(v.begin(), v.end());
x.clear(); x.clear();
BOOST_TEST(x.empty()); BOOST_CHECK(x.empty());
BOOST_TEST(x.begin() == x.end()); BOOST_CHECK(x.begin() == x.end());
} }
std::cerr<<"\n"; std::cerr<<"\n";

20
test/unordered/find_tests.cpp
View File

@ -34,12 +34,12 @@ void find_tests1(X*, test::random_generator generator = test::default_generator)
BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it1); BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it1);
iterator pos = x.find(key); iterator pos = x.find(key);
BOOST_DEDUCED_TYPENAME X::const_iterator const_pos = x_const.find(key); BOOST_DEDUCED_TYPENAME X::const_iterator const_pos = x_const.find(key);
BOOST_TEST(pos != x.end() && BOOST_CHECK(pos != x.end() &&
x.key_eq()(key, test::get_key<X>(*pos))); x.key_eq()(key, test::get_key<X>(*pos)));
BOOST_TEST(const_pos != x_const.end() && BOOST_CHECK(const_pos != x_const.end() &&
x_const.key_eq()(key, test::get_key<X>(*const_pos))); x_const.key_eq()(key, test::get_key<X>(*const_pos)));
BOOST_TEST(x.count(key) == tracker.count(key)); BOOST_CHECK(x.count(key) == tracker.count(key));
test::compare_pairs(x.equal_range(key), test::compare_pairs(x.equal_range(key),
tracker.equal_range(key), tracker.equal_range(key),
@ -56,11 +56,11 @@ void find_tests1(X*, test::random_generator generator = test::default_generator)
BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it2); BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it2);
if(tracker.find(test::get_key<X>(key)) == tracker.end()) if(tracker.find(test::get_key<X>(key)) == tracker.end())
{ {
BOOST_TEST(x.find(key) == x.end()); BOOST_CHECK(x.find(key) == x.end());
BOOST_TEST(x_const.find(key) == x_const.end()); BOOST_CHECK(x_const.find(key) == x_const.end());
BOOST_TEST(x.count(key) == 0); BOOST_CHECK(x.count(key) == 0);
std::pair<iterator, iterator> range = x.equal_range(key); std::pair<iterator, iterator> range = x.equal_range(key);
BOOST_TEST(range.first == range.second); BOOST_CHECK(range.first == range.second);
} }
} }
} }
@ -73,10 +73,10 @@ void find_tests1(X*, test::random_generator generator = test::default_generator)
v2.begin(); it3 != v2.end(); ++it3) v2.begin(); it3 != v2.end(); ++it3)
{ {
BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it3); BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it3);
BOOST_TEST(x.find(key) == x.end()); BOOST_CHECK(x.find(key) == x.end());
BOOST_TEST(x.count(key) == 0); BOOST_CHECK(x.count(key) == 0);
std::pair<iterator, iterator> range = x.equal_range(key); std::pair<iterator, iterator> range = x.equal_range(key);
BOOST_TEST(range.first == range.second); BOOST_CHECK(range.first == range.second);
} }
} }
} }

28
test/unordered/insert_stable_tests.cpp
View File

@ -47,13 +47,13 @@ UNORDERED_AUTO_TEST(stable_insert_test1) {
x.insert(insert_stable::member(1,3)); x.insert(insert_stable::member(1,3));
boost::unordered_multiset<insert_stable::member>::const_iterator it = x.begin(), end = x.end(); boost::unordered_multiset<insert_stable::member>::const_iterator it = x.begin(), end = x.end();
BOOST_TEST(it != end); BOOST_CHECK(it != end);
if(it != end) { BOOST_TEST(it->tag2_ == 1); ++it; } if(it != end) { BOOST_CHECK(it->tag2_ == 1); ++it; }
BOOST_TEST(it != end); BOOST_CHECK(it != end);
if(it != end) { BOOST_TEST(it->tag2_ == 2); ++it; } if(it != end) { BOOST_CHECK(it->tag2_ == 2); ++it; }
BOOST_TEST(it != end); BOOST_CHECK(it != end);
if(it != end) { BOOST_TEST(it->tag2_ == 3); ++it; } if(it != end) { BOOST_CHECK(it->tag2_ == 3); ++it; }
BOOST_TEST(it == end); BOOST_CHECK(it == end);
} }
UNORDERED_AUTO_TEST(stable_insert_test2) { UNORDERED_AUTO_TEST(stable_insert_test2) {
@ -66,13 +66,13 @@ UNORDERED_AUTO_TEST(stable_insert_test2) {
it = x.begin(); it = x.begin();
iterator end = x.end(); iterator end = x.end();
BOOST_TEST(it != end); BOOST_CHECK(it != end);
if(it != end) { BOOST_TEST(it->first.tag2_ == 1 && it->second == 1); ++it; } if(it != end) { BOOST_CHECK(it->first.tag2_ == 1 && it->second == 1); ++it; }
BOOST_TEST(it != end); BOOST_CHECK(it != end);
if(it != end) { BOOST_TEST(it->first.tag2_ == 2 && it->second == 2); ++it; } if(it != end) { BOOST_CHECK(it->first.tag2_ == 2 && it->second == 2); ++it; }
BOOST_TEST(it != end); BOOST_CHECK(it != end);
if(it != end) { BOOST_TEST(it->first.tag2_ == 3 && it->second == 3); ++it; } if(it != end) { BOOST_CHECK(it->first.tag2_ == 3 && it->second == 3); ++it; }
BOOST_TEST(it == end); BOOST_CHECK(it == end);
} }
RUN_TESTS() RUN_TESTS()

77
test/unordered/insert_tests.cpp
View File

@ -16,6 +16,8 @@
#include <iostream> #include <iostream>
namespace insert_tests {
test::seed_t seed(243432); test::seed_t seed(243432);
template <class X> template <class X>
@ -41,13 +43,13 @@ void unique_insert_tests1(X*, test::random_generator generator = test::default_g
std::pair<iterator, bool> r1 = x.insert(*it); std::pair<iterator, bool> r1 = x.insert(*it);
std::pair<BOOST_DEDUCED_TYPENAME ordered::iterator, bool> r2 = tracker.insert(*it); std::pair<BOOST_DEDUCED_TYPENAME ordered::iterator, bool> r2 = tracker.insert(*it);
BOOST_TEST(r1.second == r2.second); BOOST_CHECK(r1.second == r2.second);
BOOST_TEST(*r1.first == *r2.first); BOOST_CHECK(*r1.first == *r2.first);
tracker.compare_key(x, *it); tracker.compare_key(x, *it);
if(x.size() < b * old_bucket_count) if(x.size() < b * old_bucket_count)
BOOST_TEST(x.bucket_count() == old_bucket_count); BOOST_CHECK(x.bucket_count() == old_bucket_count);
} }
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
@ -71,12 +73,12 @@ void equivalent_insert_tests1(X*, test::random_generator generator = test::defau
BOOST_DEDUCED_TYPENAME X::iterator r1 = x.insert(*it); BOOST_DEDUCED_TYPENAME X::iterator r1 = x.insert(*it);
BOOST_DEDUCED_TYPENAME test::ordered<X>::iterator r2 = tracker.insert(*it); BOOST_DEDUCED_TYPENAME test::ordered<X>::iterator r2 = tracker.insert(*it);
BOOST_TEST(*r1 == *r2); BOOST_CHECK(*r1 == *r2);
tracker.compare_key(x, *it); tracker.compare_key(x, *it);
if(x.size() < b * old_bucket_count) if(x.size() < b * old_bucket_count)
BOOST_TEST(x.bucket_count() == old_bucket_count); BOOST_CHECK(x.bucket_count() == old_bucket_count);
} }
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
@ -105,11 +107,11 @@ void insert_tests2(X*, test::random_generator generator = test::default_generato
iterator r1 = x.insert(x.begin(), *it); iterator r1 = x.insert(x.begin(), *it);
tracker_iterator r2 = tracker.insert(tracker.begin(), *it); tracker_iterator r2 = tracker.insert(tracker.begin(), *it);
BOOST_TEST(*r1 == *r2); BOOST_CHECK(*r1 == *r2);
tracker.compare_key(x, *it); tracker.compare_key(x, *it);
if(x.size() < b * old_bucket_count) if(x.size() < b * old_bucket_count)
BOOST_TEST(x.bucket_count() == old_bucket_count); BOOST_CHECK(x.bucket_count() == old_bucket_count);
} }
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
@ -131,11 +133,11 @@ void insert_tests2(X*, test::random_generator generator = test::default_generato
const_iterator r1 = x.insert(x_const.end(), *it); const_iterator r1 = x.insert(x_const.end(), *it);
tracker_iterator r2 = tracker.insert(tracker.end(), *it); tracker_iterator r2 = tracker.insert(tracker.end(), *it);
BOOST_TEST(*r1 == *r2); BOOST_CHECK(*r1 == *r2);
tracker.compare_key(x, *it); tracker.compare_key(x, *it);
if(x.size() < b * old_bucket_count) if(x.size() < b * old_bucket_count)
BOOST_TEST(x.bucket_count() == old_bucket_count); BOOST_CHECK(x.bucket_count() == old_bucket_count);
} }
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
@ -157,11 +159,11 @@ void insert_tests2(X*, test::random_generator generator = test::default_generato
pos = x.insert(pos, *it); pos = x.insert(pos, *it);
tracker_iterator r2 = tracker.insert(tracker.begin(), *it); tracker_iterator r2 = tracker.insert(tracker.begin(), *it);
BOOST_TEST(*pos == *r2); BOOST_CHECK(*pos == *r2);
tracker.compare_key(x, *it); tracker.compare_key(x, *it);
if(x.size() < b * old_bucket_count) if(x.size() < b * old_bucket_count)
BOOST_TEST(x.bucket_count() == old_bucket_count); BOOST_CHECK(x.bucket_count() == old_bucket_count);
} }
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
@ -185,7 +187,7 @@ void insert_tests2(X*, test::random_generator generator = test::default_generato
tracker.compare_key(x, *it); tracker.compare_key(x, *it);
if(x.size() < b * old_bucket_count) if(x.size() < b * old_bucket_count)
BOOST_TEST(x.bucket_count() == old_bucket_count); BOOST_CHECK(x.bucket_count() == old_bucket_count);
} }
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
@ -237,7 +239,7 @@ void map_tests(X*, test::random_generator generator = test::default_generator)
tracker.compare_key(x, *it); tracker.compare_key(x, *it);
if(x.size() < b * old_bucket_count) if(x.size() < b * old_bucket_count)
BOOST_TEST(x.bucket_count() == old_bucket_count); BOOST_CHECK(x.bucket_count() == old_bucket_count);
} }
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
@ -258,40 +260,39 @@ void associative_insert_range_test(X*, test::random_generator generator = test::
test::check_equivalent_keys(x); test::check_equivalent_keys(x);
} }
int main()
{
boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_set; 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_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_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; boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multimap;
unique_insert_tests1(test_set); using test::default_generator;
equivalent_insert_tests1(test_multiset); using test::generate_collisions;
unique_insert_tests1(test_map);
equivalent_insert_tests1(test_multimap);
unique_insert_tests1(test_set, test::generate_collisions); UNORDERED_TEST(unique_insert_tests1,
equivalent_insert_tests1(test_multiset, test::generate_collisions); ((test_set)(test_map))
unique_insert_tests1(test_map, test::generate_collisions); ((default_generator)(generate_collisions))
equivalent_insert_tests1(test_multimap, test::generate_collisions); )
insert_tests2(test_set); UNORDERED_TEST(equivalent_insert_tests1,
insert_tests2(test_multiset); ((test_multiset)(test_multimap))
insert_tests2(test_map); ((default_generator)(generate_collisions))
insert_tests2(test_multimap); )
insert_tests2(test_set, test::generate_collisions); UNORDERED_TEST(insert_tests2,
insert_tests2(test_multiset, test::generate_collisions); ((test_set)(test_multiset)(test_map)(test_multimap))
insert_tests2(test_map, test::generate_collisions); ((default_generator)(generate_collisions))
insert_tests2(test_multimap, test::generate_collisions); )
map_tests(test_map); UNORDERED_TEST(map_tests,
map_tests(test_map, test::generate_collisions); ((test_map))
((default_generator)(generate_collisions))
)
associative_insert_range_test(test_map); UNORDERED_TEST(associative_insert_range_test,
associative_insert_range_test(test_map, test::generate_collisions); ((test_map)(test_multimap))
associative_insert_range_test(test_multimap); ((default_generator)(generate_collisions))
associative_insert_range_test(test_multimap, test::generate_collisions); )
return boost::report_errors();
} }
RUN_TESTS()

10
test/unordered/load_factor_tests.cpp
View File

@ -24,13 +24,13 @@ void load_factor_tests(X* = 0)
{ {
X x; X x;
BOOST_TEST(x.max_load_factor() == 1.0); BOOST_CHECK(x.max_load_factor() == 1.0);
BOOST_TEST(x.load_factor() == 0); BOOST_CHECK(x.load_factor() == 0);
// A valid implementation could fail these tests, but I think they're // A valid implementation could fail these tests, but I think they're
// reasonable. // reasonable.
x.max_load_factor(2.0); BOOST_TEST(x.max_load_factor() == 2.0); x.max_load_factor(2.0); BOOST_CHECK(x.max_load_factor() == 2.0);
x.max_load_factor(0.5); BOOST_TEST(x.max_load_factor() == 0.5); x.max_load_factor(0.5); BOOST_CHECK(x.max_load_factor() == 0.5);
} }
template <class X> template <class X>
@ -49,7 +49,7 @@ void insert_test(X*, float mlf)
old_bucket_count = x.bucket_count(); old_bucket_count = x.bucket_count();
x.insert(*it); x.insert(*it);
if(old_size + 1 < b * old_bucket_count) if(old_size + 1 < b * old_bucket_count)
BOOST_TEST(x.bucket_count() == old_bucket_count); BOOST_CHECK(x.bucket_count() == old_bucket_count);
} }
} }

44
test/unordered/move_tests.cpp
View File

@ -52,11 +52,11 @@ namespace move_tests
{ {
T y(empty(ptr)); T y(empty(ptr));
BOOST_TEST(y.empty()); BOOST_CHECK(y.empty());
BOOST_TEST(test::equivalent(y.hash_function(), hf)); BOOST_CHECK(test::equivalent(y.hash_function(), hf));
BOOST_TEST(test::equivalent(y.key_eq(), eq)); BOOST_CHECK(test::equivalent(y.key_eq(), eq));
BOOST_TEST(test::equivalent(y.get_allocator(), al)); BOOST_CHECK(test::equivalent(y.get_allocator(), al));
BOOST_TEST(y.max_load_factor() == 1.0); BOOST_CHECK(y.max_load_factor() == 1.0);
test::check_equivalent_keys(y); test::check_equivalent_keys(y);
} }
@ -64,7 +64,7 @@ namespace move_tests
test::random_values<T> v(1000); test::random_values<T> v(1000);
BOOST_DEDUCED_TYPENAME T::value_type const* first = 0; BOOST_DEDUCED_TYPENAME T::value_type const* first = 0;
T y(create(v, first)); T y(create(v, first));
BOOST_TEST(first == &*y.begin()); BOOST_CHECK(first == &*y.begin());
test::check_container(y, v); test::check_container(y, v);
test::check_equivalent_keys(y); test::check_equivalent_keys(y);
} }
@ -78,7 +78,7 @@ namespace move_tests
BOOST_DEDUCED_TYPENAME T::value_type const* first = 0; BOOST_DEDUCED_TYPENAME T::value_type const* first = 0;
T y; T y;
y = create(v, first); y = create(v, first);
BOOST_TEST(first == &*y.begin()); BOOST_CHECK(first == &*y.begin());
test::check_container(y, v); test::check_container(y, v);
test::check_equivalent_keys(y); test::check_equivalent_keys(y);
} }
@ -100,12 +100,12 @@ namespace move_tests
{ {
test::random_values<T> v(500); test::random_values<T> v(500);
T y(create(v, first, hf, eq, al, 0.5)); T y(create(v, first, hf, eq, al, 0.5));
BOOST_TEST(first == &*y.begin()); BOOST_CHECK(first == &*y.begin());
test::check_container(y, v); test::check_container(y, v);
BOOST_TEST(test::equivalent(y.hash_function(), hf)); BOOST_CHECK(test::equivalent(y.hash_function(), hf));
BOOST_TEST(test::equivalent(y.key_eq(), eq)); BOOST_CHECK(test::equivalent(y.key_eq(), eq));
BOOST_TEST(test::equivalent(y.get_allocator(), al)); BOOST_CHECK(test::equivalent(y.get_allocator(), al));
BOOST_TEST(y.max_load_factor() == 0.5); // Not necessarily required. BOOST_CHECK(y.max_load_factor() == 0.5); // Not necessarily required.
test::check_equivalent_keys(y); test::check_equivalent_keys(y);
} }
@ -113,24 +113,24 @@ namespace move_tests
// TODO: To do this correctly requires the fancy new allocator stuff. // TODO: To do this correctly requires the fancy new allocator stuff.
test::random_values<T> v(500); test::random_values<T> v(500);
T y(create(v, first, hf, eq, al, 2.0), al2); T y(create(v, first, hf, eq, al, 2.0), al2);
BOOST_TEST(first != &*y.begin()); BOOST_CHECK(first != &*y.begin());
test::check_container(y, v); test::check_container(y, v);
BOOST_TEST(test::equivalent(y.hash_function(), hf)); BOOST_CHECK(test::equivalent(y.hash_function(), hf));
BOOST_TEST(test::equivalent(y.key_eq(), eq)); BOOST_CHECK(test::equivalent(y.key_eq(), eq));
BOOST_TEST(test::equivalent(y.get_allocator(), al2)); BOOST_CHECK(test::equivalent(y.get_allocator(), al2));
BOOST_TEST(y.max_load_factor() == 2.0); // Not necessarily required. BOOST_CHECK(y.max_load_factor() == 2.0); // Not necessarily required.
test::check_equivalent_keys(y); test::check_equivalent_keys(y);
} }
{ {
test::random_values<T> v(25); test::random_values<T> v(25);
T y(create(v, first, hf, eq, al, 1.0), al); T y(create(v, first, hf, eq, al, 1.0), al);
BOOST_TEST(first == &*y.begin()); BOOST_CHECK(first == &*y.begin());
test::check_container(y, v); test::check_container(y, v);
BOOST_TEST(test::equivalent(y.hash_function(), hf)); BOOST_CHECK(test::equivalent(y.hash_function(), hf));
BOOST_TEST(test::equivalent(y.key_eq(), eq)); BOOST_CHECK(test::equivalent(y.key_eq(), eq));
BOOST_TEST(test::equivalent(y.get_allocator(), al)); BOOST_CHECK(test::equivalent(y.get_allocator(), al));
BOOST_TEST(y.max_load_factor() == 1.0); // Not necessarily required. BOOST_CHECK(y.max_load_factor() == 1.0); // Not necessarily required.
test::check_equivalent_keys(y); test::check_equivalent_keys(y);
} }
} }

12
test/unordered/rehash_tests.cpp
View File

@ -26,10 +26,10 @@ void rehash_empty_test1(X* = 0)
X x; X x;
x.rehash(10000); x.rehash(10000);
BOOST_TEST(postcondition(x, 10000)); BOOST_CHECK(postcondition(x, 10000));
x.rehash(0); x.rehash(0);
BOOST_TEST(postcondition(x, 0)); BOOST_CHECK(postcondition(x, 0));
} }
template <class X> template <class X>
@ -40,18 +40,18 @@ void rehash_test1(X* = 0)
tracker.insert_range(v.begin(), v.end()); tracker.insert_range(v.begin(), v.end());
X x(v.begin(), v.end()); X x(v.begin(), v.end());
x.rehash(0); BOOST_TEST(postcondition(x, 0)); x.rehash(0); BOOST_CHECK(postcondition(x, 0));
tracker.compare(x); tracker.compare(x);
x.max_load_factor(0.25); x.max_load_factor(0.25);
x.rehash(0); BOOST_TEST(postcondition(x, 0)); x.rehash(0); BOOST_CHECK(postcondition(x, 0));
tracker.compare(x); tracker.compare(x);
x.max_load_factor(50.0); x.max_load_factor(50.0);
x.rehash(0); BOOST_TEST(postcondition(x, 0)); x.rehash(0); BOOST_CHECK(postcondition(x, 0));
tracker.compare(x); tracker.compare(x);
x.rehash(1000); BOOST_TEST(postcondition(x, 1000)); x.rehash(1000); BOOST_CHECK(postcondition(x, 1000));
tracker.compare(x); tracker.compare(x);
} }

46
test/unordered/simple_tests.cpp
View File

@ -19,67 +19,67 @@ void simple_test(X const& a)
{ {
X u; X u;
BOOST_TEST(u.size() == 0); BOOST_CHECK(u.size() == 0);
BOOST_TEST(X().size() == 0); BOOST_CHECK(X().size() == 0);
} }
{ {
BOOST_TEST(equivalent(X(a))); BOOST_CHECK(equivalent(X(a)));
} }
{ {
X u(a); X u(a);
BOOST_TEST(equivalent(u)); BOOST_CHECK(equivalent(u));
} }
{ {
X u = a; X u = a;
BOOST_TEST(equivalent(u)); BOOST_CHECK(equivalent(u));
} }
{ {
X b(a); X b(a);
BOOST_TEST(b.begin() == const_cast<X const&>(b).cbegin()); BOOST_CHECK(b.begin() == const_cast<X const&>(b).cbegin());
BOOST_TEST(b.end() == const_cast<X const&>(b).cend()); BOOST_CHECK(b.end() == const_cast<X const&>(b).cend());
} }
{ {
X b(a); X b(a);
X c; X c;
BOOST_TEST(equivalent(b)); BOOST_CHECK(equivalent(b));
BOOST_TEST(c.empty()); BOOST_CHECK(c.empty());
b.swap(c); b.swap(c);
BOOST_TEST(b.empty()); BOOST_CHECK(b.empty());
BOOST_TEST(equivalent(c)); BOOST_CHECK(equivalent(c));
b.swap(c); b.swap(c);
BOOST_TEST(c.empty()); BOOST_CHECK(c.empty());
BOOST_TEST(equivalent(b)); BOOST_CHECK(equivalent(b));
} }
{ {
X u; X u;
X& r = u; X& r = u;
BOOST_TEST(&(r = r) == &r); BOOST_CHECK(&(r = r) == &r);
BOOST_TEST(r.empty()); BOOST_CHECK(r.empty());
BOOST_TEST(&(r = a) == &r); BOOST_CHECK(&(r = a) == &r);
BOOST_TEST(equivalent(r)); BOOST_CHECK(equivalent(r));
BOOST_TEST(&(r = r) == &r); BOOST_CHECK(&(r = r) == &r);
BOOST_TEST(equivalent(r)); BOOST_CHECK(equivalent(r));
} }
{ {
BOOST_TEST(a.size() == BOOST_CHECK(a.size() ==
(BOOST_DEDUCED_TYPENAME X::size_type) std::distance(a.begin(), a.end())); (BOOST_DEDUCED_TYPENAME X::size_type) std::distance(a.begin(), a.end()));
} }
{ {
BOOST_TEST(a.empty() == (a.size() == 0)); BOOST_CHECK(a.empty() == (a.size() == 0));
} }
{ {
BOOST_TEST(a.empty() == (a.begin() == a.end())); BOOST_CHECK(a.empty() == (a.begin() == a.end()));
X u; X u;
BOOST_TEST(u.begin() == u.end()); BOOST_CHECK(u.begin() == u.end());
} }
} }

4
test/unordered/unnecessary_copy_tests.cpp
View File

@ -44,9 +44,9 @@ namespace unnecessary_copy_tests
count_copies::count = 0; count_copies::count = 0;
T x; T x;
BOOST_DEDUCED_TYPENAME T::value_type a; BOOST_DEDUCED_TYPENAME T::value_type a;
BOOST_TEST(count_copies::count == 1); BOOST_CHECK(count_copies::count == 1);
x.insert(a); x.insert(a);
BOOST_TEST(count_copies::count == 2); BOOST_CHECK(count_copies::count == 2);
} }
boost::unordered_set<count_copies>* set; boost::unordered_set<count_copies>* set;