forked from boostorg/unordered
50e8df5e12
Anotehr overhaul. Can now use `void_pointer` for links between nodes, although it doesn't as I don't think `void_pointer` support is strong enough in existing allocators. Also no longer relies on using base pointers for custome pointer types. And scaled back member function detection to just detect if an allocator has a member, not what its signature is. I found that the trait could be confused by ambiguous overloads. This might be fixable. Better documentation of C++11 compliance to come. [SVN r74859]
294 lines
9.3 KiB
C++
294 lines
9.3 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 test creates the containers with members that meet their minimum
|
|
// requirements. Makes sure everything compiles and is defined correctly.
|
|
|
|
#include "../helpers/prefix.hpp"
|
|
|
|
#include <boost/unordered_set.hpp>
|
|
|
|
#include <iostream>
|
|
#include "../helpers/test.hpp"
|
|
#include "../objects/minimal.hpp"
|
|
#include "./compile_tests.hpp"
|
|
|
|
// Explicit instantiation to catch compile-time errors
|
|
|
|
template class boost::unordered_set<
|
|
int,
|
|
boost::hash<int>,
|
|
std::equal_to<int>,
|
|
test::minimal::allocator<int> >;
|
|
template class boost::unordered_multiset<
|
|
int,
|
|
boost::hash<int>,
|
|
std::equal_to<int>,
|
|
test::minimal::allocator<int> >;
|
|
|
|
template class boost::unordered_set<
|
|
test::minimal::assignable,
|
|
test::minimal::hash<test::minimal::assignable>,
|
|
test::minimal::equal_to<test::minimal::assignable>,
|
|
test::minimal::allocator<test::minimal::assignable> >;
|
|
template class boost::unordered_multiset<
|
|
test::minimal::assignable,
|
|
test::minimal::hash<test::minimal::assignable>,
|
|
test::minimal::equal_to<test::minimal::assignable>,
|
|
test::minimal::allocator<test::minimal::assignable> >;
|
|
|
|
UNORDERED_AUTO_TEST(test0)
|
|
{
|
|
test::minimal::constructor_param x;
|
|
|
|
test::minimal::assignable assignable(x);
|
|
|
|
std::cout<<"Test unordered_set.\n";
|
|
|
|
boost::unordered_set<int> int_set;
|
|
|
|
boost::unordered_set<int,
|
|
boost::hash<int>, std::equal_to<int>,
|
|
test::minimal::cxx11_allocator<int>
|
|
> int_set2;
|
|
|
|
boost::unordered_set<
|
|
test::minimal::assignable,
|
|
test::minimal::hash<test::minimal::assignable>,
|
|
test::minimal::equal_to<test::minimal::assignable>,
|
|
test::minimal::allocator<test::minimal::assignable> > set;
|
|
|
|
container_test(int_set, 0);
|
|
container_test(int_set2, 0);
|
|
container_test(set, assignable);
|
|
|
|
std::cout<<"Test unordered_multiset.\n";
|
|
|
|
boost::unordered_multiset<int> int_multiset;
|
|
|
|
boost::unordered_multiset<int,
|
|
boost::hash<int>, std::equal_to<int>,
|
|
test::minimal::cxx11_allocator<int>
|
|
> int_multiset2;
|
|
|
|
boost::unordered_multiset<
|
|
test::minimal::assignable,
|
|
test::minimal::hash<test::minimal::assignable>,
|
|
test::minimal::equal_to<test::minimal::assignable>,
|
|
test::minimal::allocator<test::minimal::assignable> > multiset;
|
|
|
|
container_test(int_multiset, 0);
|
|
container_test(int_multiset2, 0);
|
|
container_test(multiset, assignable);
|
|
}
|
|
|
|
UNORDERED_AUTO_TEST(equality_tests) {
|
|
typedef test::minimal::copy_constructible_equality_comparable value_type;
|
|
|
|
boost::unordered_set<int> int_set;
|
|
|
|
boost::unordered_set<int,
|
|
boost::hash<int>, std::equal_to<int>,
|
|
test::minimal::cxx11_allocator<int>
|
|
> int_set2;
|
|
|
|
boost::unordered_set<
|
|
test::minimal::copy_constructible_equality_comparable,
|
|
test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
|
|
test::minimal::equal_to<test::minimal::copy_constructible_equality_comparable>,
|
|
test::minimal::allocator<value_type> > set;
|
|
|
|
equality_test(int_set);
|
|
equality_test(int_set2);
|
|
equality_test(set);
|
|
|
|
boost::unordered_multiset<int> int_multiset;
|
|
|
|
boost::unordered_multiset<int,
|
|
boost::hash<int>, std::equal_to<int>,
|
|
test::minimal::cxx11_allocator<int>
|
|
> int_multiset2;
|
|
|
|
boost::unordered_multiset<
|
|
test::minimal::copy_constructible_equality_comparable,
|
|
test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
|
|
test::minimal::equal_to<test::minimal::copy_constructible_equality_comparable>,
|
|
test::minimal::allocator<value_type> > multiset;
|
|
|
|
equality_test(int_multiset);
|
|
equality_test(int_multiset2);
|
|
equality_test(multiset);
|
|
}
|
|
|
|
UNORDERED_AUTO_TEST(test1)
|
|
{
|
|
boost::hash<int> hash;
|
|
std::equal_to<int> equal_to;
|
|
int value = 0;
|
|
|
|
std::cout<<"Test unordered_set." << std::endl;
|
|
|
|
boost::unordered_set<int> set;
|
|
|
|
boost::unordered_set<int,
|
|
boost::hash<int>, std::equal_to<int>,
|
|
test::minimal::cxx11_allocator<int>
|
|
> set2;
|
|
|
|
unordered_unique_test(set, value);
|
|
unordered_set_test(set, value);
|
|
unordered_copyable_test(set, value, value, hash, equal_to);
|
|
|
|
unordered_unique_test(set2, value);
|
|
unordered_set_test(set2, value);
|
|
unordered_copyable_test(set2, value, value, hash, equal_to);
|
|
|
|
std::cout<<"Test unordered_multiset." << std::endl;
|
|
|
|
boost::unordered_multiset<int> multiset;
|
|
|
|
boost::unordered_multiset<int,
|
|
boost::hash<int>, std::equal_to<int>,
|
|
test::minimal::cxx11_allocator<int>
|
|
> multiset2;
|
|
|
|
unordered_equivalent_test(multiset, value);
|
|
unordered_set_test(multiset, value);
|
|
unordered_copyable_test(multiset, value, value, hash, equal_to);
|
|
|
|
unordered_equivalent_test(multiset2, value);
|
|
unordered_set_test(multiset2, value);
|
|
unordered_copyable_test(multiset2, value, value, hash, equal_to);
|
|
}
|
|
|
|
UNORDERED_AUTO_TEST(test2)
|
|
{
|
|
test::minimal::constructor_param x;
|
|
|
|
test::minimal::assignable assignable(x);
|
|
test::minimal::copy_constructible copy_constructible(x);
|
|
test::minimal::hash<test::minimal::assignable> hash(x);
|
|
test::minimal::equal_to<test::minimal::assignable> equal_to(x);
|
|
|
|
std::cout<<"Test unordered_set.\n";
|
|
|
|
boost::unordered_set<
|
|
test::minimal::assignable,
|
|
test::minimal::hash<test::minimal::assignable>,
|
|
test::minimal::equal_to<test::minimal::assignable>,
|
|
test::minimal::allocator<test::minimal::assignable> > set;
|
|
|
|
unordered_unique_test(set, assignable);
|
|
unordered_set_test(set, assignable);
|
|
unordered_copyable_test(set, assignable, assignable, hash, equal_to);
|
|
|
|
std::cout<<"Test unordered_multiset.\n";
|
|
|
|
boost::unordered_multiset<
|
|
test::minimal::assignable,
|
|
test::minimal::hash<test::minimal::assignable>,
|
|
test::minimal::equal_to<test::minimal::assignable>,
|
|
test::minimal::allocator<test::minimal::assignable> > multiset;
|
|
|
|
unordered_equivalent_test(multiset, assignable);
|
|
unordered_set_test(multiset, assignable);
|
|
unordered_copyable_test(multiset, assignable, assignable, hash, equal_to);
|
|
}
|
|
|
|
UNORDERED_AUTO_TEST(movable1_tests)
|
|
{
|
|
test::minimal::constructor_param x;
|
|
|
|
test::minimal::movable1 movable1(x);
|
|
test::minimal::hash<test::minimal::movable1> hash(x);
|
|
test::minimal::equal_to<test::minimal::movable1> equal_to(x);
|
|
|
|
std::cout<<"Test unordered_set.\n";
|
|
|
|
boost::unordered_set<
|
|
test::minimal::movable1,
|
|
test::minimal::hash<test::minimal::movable1>,
|
|
test::minimal::equal_to<test::minimal::movable1>,
|
|
test::minimal::allocator<test::minimal::movable1> > set;
|
|
|
|
//unordered_unique_test(set, movable1);
|
|
unordered_set_test(set, movable1);
|
|
unordered_movable_test(set, movable1, movable1, hash, equal_to);
|
|
|
|
std::cout<<"Test unordered_multiset.\n";
|
|
|
|
boost::unordered_multiset<
|
|
test::minimal::movable1,
|
|
test::minimal::hash<test::minimal::movable1>,
|
|
test::minimal::equal_to<test::minimal::movable1>,
|
|
test::minimal::allocator<test::minimal::movable1> > multiset;
|
|
|
|
//unordered_equivalent_test(multiset, movable1);
|
|
unordered_set_test(multiset, movable1);
|
|
unordered_movable_test(multiset, movable1, movable1, hash, equal_to);
|
|
}
|
|
|
|
UNORDERED_AUTO_TEST(movable2_tests)
|
|
{
|
|
test::minimal::constructor_param x;
|
|
|
|
test::minimal::movable2 movable2(x);
|
|
test::minimal::hash<test::minimal::movable2> hash(x);
|
|
test::minimal::equal_to<test::minimal::movable2> equal_to(x);
|
|
|
|
std::cout<<"Test unordered_set.\n";
|
|
|
|
boost::unordered_set<
|
|
test::minimal::movable2,
|
|
test::minimal::hash<test::minimal::movable2>,
|
|
test::minimal::equal_to<test::minimal::movable2>,
|
|
test::minimal::allocator<test::minimal::movable2> > set;
|
|
|
|
//unordered_unique_test(set, movable2);
|
|
unordered_set_test(set, movable2);
|
|
unordered_movable_test(set, movable2, movable2, hash, equal_to);
|
|
|
|
std::cout<<"Test unordered_multiset.\n";
|
|
|
|
boost::unordered_multiset<
|
|
test::minimal::movable2,
|
|
test::minimal::hash<test::minimal::movable2>,
|
|
test::minimal::equal_to<test::minimal::movable2>,
|
|
test::minimal::allocator<test::minimal::movable2> > multiset;
|
|
|
|
//unordered_equivalent_test(multiset, movable2);
|
|
unordered_set_test(multiset, movable2);
|
|
unordered_movable_test(multiset, movable2, movable2, hash, equal_to);
|
|
}
|
|
|
|
UNORDERED_AUTO_TEST(destructible_tests)
|
|
{
|
|
test::minimal::constructor_param x;
|
|
|
|
test::minimal::destructible destructible(x);
|
|
test::minimal::hash<test::minimal::destructible> hash(x);
|
|
test::minimal::equal_to<test::minimal::destructible> equal_to(x);
|
|
|
|
std::cout<<"Test unordered_set.\n";
|
|
|
|
boost::unordered_set<
|
|
test::minimal::destructible,
|
|
test::minimal::hash<test::minimal::destructible>,
|
|
test::minimal::equal_to<test::minimal::destructible> > set;
|
|
|
|
unordered_destructible_test(set);
|
|
|
|
std::cout<<"Test unordered_multiset.\n";
|
|
|
|
boost::unordered_multiset<
|
|
test::minimal::destructible,
|
|
test::minimal::hash<test::minimal::destructible>,
|
|
test::minimal::equal_to<test::minimal::destructible> > multiset;
|
|
|
|
unordered_destructible_test(multiset);
|
|
}
|
|
|
|
RUN_TESTS()
|