boostorg/unordered
1
0
Fork 1
mirror of https://github.com/boostorg/unordered.git synced 2025-07-30 03:17:15 +02:00
Code Issues Packages Projects Releases Wiki Activity

Add foa-based node containers to compile_set tests

Browse Source
This commit is contained in:
Christian Mazakas
2023-02-14 09:38:36 -08:00
parent d3b264345d
commit e68ec5c9a9
1 changed files with 187 additions and 200 deletions
Download Patch File Download Diff File Expand all files Collapse all files

387
test/unordered/compile_set.cpp
View File

@ -1,6 +1,6 @@
// Copyright 2006-2009 Daniel James. // Copyright 2006-2009 Daniel James.
// Copyright 2022 Christian Mazakas. // Copyright 2022-2023 Christian Mazakas.
// Distributed under the Boost Software License, Version 1.0. (See accompanying // 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) // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@ -35,6 +35,21 @@ template class instantiate_flat_set<test::minimal::assignable const,
test::minimal::equal_to<test::minimal::assignable>, test::minimal::equal_to<test::minimal::assignable>,
test::minimal::allocator<int> >; test::minimal::allocator<int> >;
template <typename T, typename H, typename P, typename A>
class instantiate_node_set
{
typedef boost::unordered_node_set<T, H, P, A> container;
container x;
};
template class instantiate_node_set<int, boost::hash<int>, std::equal_to<int>,
test::minimal::allocator<int> >;
template class instantiate_node_set<test::minimal::assignable const,
test::minimal::hash<test::minimal::assignable>,
test::minimal::equal_to<test::minimal::assignable>,
test::minimal::allocator<int> >;
#else #else
#define INSTANTIATE(type) \ #define INSTANTIATE(type) \
@ -56,153 +71,106 @@ INSTANTIATE(multiset)<test::minimal::assignable,
#endif #endif
UNORDERED_AUTO_TEST (type_traits) { template <class X> static void type_traits_impl()
#ifdef BOOST_UNORDERED_FOA_TESTS {
typedef boost::unordered_flat_set<int> set_type;
#else
typedef boost::unordered_set<int> set_type;
#endif
typedef set_type::iterator iterator;
BOOST_STATIC_ASSERT(boost::is_same<int const&, BOOST_STATIC_ASSERT(boost::is_same<int const&,
std::iterator_traits<iterator>::reference>::value); typename std::iterator_traits<typename X::iterator>::reference>::value);
} }
UNORDERED_AUTO_TEST (test0) { UNORDERED_AUTO_TEST (type_traits) {
#ifdef BOOST_UNORDERED_FOA_TESTS
type_traits_impl<boost::unordered_flat_set<int> >();
type_traits_impl<boost::unordered_node_set<int> >();
#else
type_traits_impl<boost::unordered_set<int> >();
type_traits_impl<boost::unordered_multiset<int> >();
#endif
}
template <template <class T, class H = boost::hash<T>,
class P = std::equal_to<T>, class A = std::allocator<T> >
class Set>
static void test0_impl()
{
test::minimal::constructor_param x; test::minimal::constructor_param x;
test::minimal::assignable assignable(x); test::minimal::assignable assignable(x);
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n"; Set<int> int_set;
#ifdef BOOST_UNORDERED_FOA_TESTS Set<int, boost::hash<int>, std::equal_to<int>,
boost::unordered_flat_set<int> int_set;
boost::unordered_flat_set<int, boost::hash<int>, std::equal_to<int>,
test::minimal::cxx11_allocator<int> > test::minimal::cxx11_allocator<int> >
int_set2; int_set2;
boost::unordered_flat_set<test::minimal::assignable, Set<test::minimal::assignable, test::minimal::hash<test::minimal::assignable>,
test::minimal::hash<test::minimal::assignable>,
test::minimal::equal_to<test::minimal::assignable>, test::minimal::equal_to<test::minimal::assignable>,
test::minimal::allocator<test::minimal::assignable> > test::minimal::allocator<test::minimal::assignable> >
set; set;
#else
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;
#endif
container_test(int_set, 0); container_test(int_set, 0);
container_test(int_set2, 0); container_test(int_set2, 0);
container_test(set, assignable); container_test(set, assignable);
}
#ifndef BOOST_UNORDERED_FOA_TESTS UNORDERED_AUTO_TEST (test0) {
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n"; #ifdef BOOST_UNORDERED_FOA_TESTS
test0_impl<boost::unordered_flat_set>();
boost::unordered_multiset<int> int_multiset; test0_impl<boost::unordered_node_set>();
#else
boost::unordered_multiset<int, boost::hash<int>, std::equal_to<int>, test0_impl<boost::unordered_set>();
test::minimal::cxx11_allocator<int> > test0_impl<boost::unordered_multiset>();
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);
#endif #endif
} }
UNORDERED_AUTO_TEST (equality_tests) { template <template <class T, class H = boost::hash<T>,
class P = std::equal_to<T>, class A = std::allocator<T> >
class Set>
static void equality_tests_impl()
{
typedef test::minimal::copy_constructible_equality_comparable value_type; typedef test::minimal::copy_constructible_equality_comparable value_type;
#ifdef BOOST_UNORDERED_FOA_TESTS Set<int> int_set;
boost::unordered_flat_set<int> int_set;
boost::unordered_flat_set<int, boost::hash<int>, std::equal_to<int>, Set<int, boost::hash<int>, std::equal_to<int>,
test::minimal::cxx11_allocator<int> > test::minimal::cxx11_allocator<int> >
int_set2; int_set2;
boost::unordered_flat_set< Set<test::minimal::copy_constructible_equality_comparable,
test::minimal::copy_constructible_equality_comparable,
test::minimal::hash<test::minimal::copy_constructible_equality_comparable>, test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
test::minimal::equal_to< test::minimal::equal_to<
test::minimal::copy_constructible_equality_comparable>, test::minimal::copy_constructible_equality_comparable>,
test::minimal::allocator<value_type> > test::minimal::allocator<value_type> >
set; set;
#else
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;
#endif
equality_test(int_set); equality_test(int_set);
equality_test(int_set2); equality_test(int_set2);
equality_test(set); equality_test(set);
}
#ifndef BOOST_UNORDERED_FOA_TESTS UNORDERED_AUTO_TEST (equality_tests) {
boost::unordered_multiset<int> int_multiset; #ifdef BOOST_UNORDERED_FOA_TESTS
equality_tests_impl<boost::unordered_flat_set>();
boost::unordered_multiset<int, boost::hash<int>, std::equal_to<int>, equality_tests_impl<boost::unordered_node_set>();
test::minimal::cxx11_allocator<int> > #else
int_multiset2; equality_tests_impl<boost::unordered_set>();
equality_tests_impl<boost::unordered_multiset>();
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);
#endif #endif
} }
UNORDERED_AUTO_TEST (test1) { template <template <class T, class H = boost::hash<T>,
class P = std::equal_to<T>, class A = std::allocator<T> >
class Set>
static void test1_unique_impl()
{
boost::hash<int> hash; boost::hash<int> hash;
std::equal_to<int> equal_to; std::equal_to<int> equal_to;
int value = 0; int value = 0;
Set<int> set;
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set." << std::endl; Set<int, boost::hash<int>, std::equal_to<int>,
#ifdef BOOST_UNORDERED_FOA_TESTS
boost::unordered_flat_set<int> set;
boost::unordered_flat_set<int, boost::hash<int>, std::equal_to<int>,
test::minimal::cxx11_allocator<int> > test::minimal::cxx11_allocator<int> >
set2; set2;
#else
boost::unordered_set<int> set;
boost::unordered_set<int, boost::hash<int>, std::equal_to<int>,
test::minimal::cxx11_allocator<int> >
set2;
#endif
unordered_unique_test(set, value); unordered_unique_test(set, value);
unordered_set_test(set, value); unordered_set_test(set, value);
@ -211,27 +179,49 @@ UNORDERED_AUTO_TEST (test1) {
unordered_unique_test(set2, value); unordered_unique_test(set2, value);
unordered_set_test(set2, value); unordered_set_test(set2, value);
unordered_copyable_test(set2, value, value, hash, equal_to); unordered_copyable_test(set2, value, value, hash, equal_to);
}
#ifndef BOOST_UNORDERED_FOA_TESTS #ifndef BOOST_UNORDERED_FOA_TESTS
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset." << std::endl; template <template <class T, class H = boost::hash<T>,
class P = std::equal_to<T>, class A = std::allocator<T> >
class Set>
static void test1_equivalent_impl()
{
boost::unordered_multiset<int> multiset; boost::hash<int> hash;
std::equal_to<int> equal_to;
int value = 0;
Set<int> set;
boost::unordered_multiset<int, boost::hash<int>, std::equal_to<int>, Set<int, boost::hash<int>, std::equal_to<int>,
test::minimal::cxx11_allocator<int> > test::minimal::cxx11_allocator<int> >
multiset2; set2;
unordered_equivalent_test(multiset, value); unordered_equivalent_test(set, value);
unordered_set_test(multiset, value); unordered_set_test(set, value);
unordered_copyable_test(multiset, value, value, hash, equal_to); unordered_copyable_test(set, value, value, hash, equal_to);
unordered_equivalent_test(multiset2, value); unordered_equivalent_test(set2, value);
unordered_set_test(multiset2, value); unordered_set_test(set2, value);
unordered_copyable_test(multiset2, value, value, hash, equal_to); unordered_copyable_test(set2, value, value, hash, equal_to);
}
#endif
UNORDERED_AUTO_TEST (test1) {
#ifdef BOOST_UNORDERED_FOA_TESTS
test1_unique_impl<boost::unordered_flat_set>();
test1_unique_impl<boost::unordered_node_set>();
#else
test1_unique_impl<boost::unordered_set>();
test1_equivalent_impl<boost::unordered_multiset>();
#endif #endif
} }
UNORDERED_AUTO_TEST (test2) { template <template <class T, class H = boost::hash<T>,
class P = std::equal_to<T>, class A = std::allocator<T> >
class Set>
static void test2_unique_impl()
{
test::minimal::constructor_param x; test::minimal::constructor_param x;
test::minimal::assignable assignable(x); test::minimal::assignable assignable(x);
@ -239,155 +229,144 @@ UNORDERED_AUTO_TEST (test2) {
test::minimal::hash<test::minimal::assignable> hash(x); test::minimal::hash<test::minimal::assignable> hash(x);
test::minimal::equal_to<test::minimal::assignable> equal_to(x); test::minimal::equal_to<test::minimal::assignable> equal_to(x);
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n"; Set<test::minimal::assignable, test::minimal::hash<test::minimal::assignable>,
#ifdef BOOST_UNORDERED_FOA_TESTS
boost::unordered_flat_set<test::minimal::assignable,
test::minimal::hash<test::minimal::assignable>,
test::minimal::equal_to<test::minimal::assignable>, test::minimal::equal_to<test::minimal::assignable>,
test::minimal::allocator<test::minimal::assignable> > test::minimal::allocator<test::minimal::assignable> >
set; set;
#else
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;
#endif
unordered_unique_test(set, assignable); unordered_unique_test(set, assignable);
unordered_set_test(set, assignable); unordered_set_test(set, assignable);
unordered_copyable_test(set, assignable, assignable, hash, equal_to); unordered_copyable_test(set, assignable, assignable, hash, equal_to);
unordered_set_member_test(set, assignable); unordered_set_member_test(set, assignable);
}
#ifndef BOOST_UNORDERED_FOA_TESTS #ifndef BOOST_UNORDERED_FOA_TESTS
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n"; template <template <class T, class H = boost::hash<T>,
class P = std::equal_to<T>, class A = std::allocator<T> >
class Set>
static void test2_equivalent_impl()
{
test::minimal::constructor_param x;
boost::unordered_multiset<test::minimal::assignable, test::minimal::assignable assignable(x);
test::minimal::hash<test::minimal::assignable>, 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);
Set<test::minimal::assignable, test::minimal::hash<test::minimal::assignable>,
test::minimal::equal_to<test::minimal::assignable>, test::minimal::equal_to<test::minimal::assignable>,
test::minimal::allocator<test::minimal::assignable> > test::minimal::allocator<test::minimal::assignable> >
multiset; set;
unordered_equivalent_test(multiset, assignable); unordered_equivalent_test(set, assignable);
unordered_set_test(multiset, assignable); unordered_set_test(set, assignable);
unordered_copyable_test(multiset, assignable, assignable, hash, equal_to); unordered_copyable_test(set, assignable, assignable, hash, equal_to);
unordered_set_member_test(multiset, assignable); unordered_set_member_test(set, assignable);
}
#endif
UNORDERED_AUTO_TEST (test2) {
#ifdef BOOST_UNORDERED_FOA_TESTS
test2_unique_impl<boost::unordered_flat_set>();
test2_unique_impl<boost::unordered_node_set>();
#else
test2_unique_impl<boost::unordered_set>();
test2_equivalent_impl<boost::unordered_multiset>();
#endif #endif
} }
UNORDERED_AUTO_TEST (movable1_tests) { template <template <class T, class H = boost::hash<T>,
class P = std::equal_to<T>, class A = std::allocator<T> >
class Set>
static void movable1_tests_impl()
{
test::minimal::constructor_param x; test::minimal::constructor_param x;
test::minimal::movable1 movable1(x); test::minimal::movable1 movable1(x);
test::minimal::hash<test::minimal::movable1> hash(x); test::minimal::hash<test::minimal::movable1> hash(x);
test::minimal::equal_to<test::minimal::movable1> equal_to(x); test::minimal::equal_to<test::minimal::movable1> equal_to(x);
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n"; Set<test::minimal::movable1, test::minimal::hash<test::minimal::movable1>,
#ifdef BOOST_UNORDERED_FOA_TESTS
boost::unordered_flat_set<test::minimal::movable1,
test::minimal::hash<test::minimal::movable1>,
test::minimal::equal_to<test::minimal::movable1>, test::minimal::equal_to<test::minimal::movable1>,
test::minimal::allocator<test::minimal::movable1> > test::minimal::allocator<test::minimal::movable1> >
set; set;
#else
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;
#endif
// TODO: find out why Daniel had this commented out and if we need it and the
// corresponding equivalent impl
//
// unordered_unique_test(set, movable1); // unordered_unique_test(set, movable1);
unordered_set_test(set, movable1); unordered_set_test(set, movable1);
unordered_movable_test(set, movable1, movable1, hash, equal_to); unordered_movable_test(set, movable1, movable1, hash, equal_to);
}
#ifndef BOOST_UNORDERED_FOA_TESTS UNORDERED_AUTO_TEST (movable1_tests) {
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n"; #ifdef BOOST_UNORDERED_FOA_TESTS
movable1_tests_impl<boost::unordered_flat_set>();
boost::unordered_multiset<test::minimal::movable1, movable1_tests_impl<boost::unordered_node_set>();
test::minimal::hash<test::minimal::movable1>, #else
test::minimal::equal_to<test::minimal::movable1>, movable1_tests_impl<boost::unordered_set>();
test::minimal::allocator<test::minimal::movable1> > movable1_tests_impl<boost::unordered_multiset>();
multiset;
// unordered_equivalent_test(multiset, movable1);
unordered_set_test(multiset, movable1);
unordered_movable_test(multiset, movable1, movable1, hash, equal_to);
#endif #endif
} }
UNORDERED_AUTO_TEST (movable2_tests) { template <template <class T, class H = boost::hash<T>,
class P = std::equal_to<T>, class A = std::allocator<T> >
class Set>
static void movable2_tests_impl()
{
test::minimal::constructor_param x; test::minimal::constructor_param x;
test::minimal::movable2 movable2(x); test::minimal::movable2 movable2(x);
test::minimal::hash<test::minimal::movable2> hash(x); test::minimal::hash<test::minimal::movable2> hash(x);
test::minimal::equal_to<test::minimal::movable2> equal_to(x); test::minimal::equal_to<test::minimal::movable2> equal_to(x);
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n"; Set<test::minimal::movable2, test::minimal::hash<test::minimal::movable2>,
#ifdef BOOST_UNORDERED_FOA_TESTS
boost::unordered_flat_set<test::minimal::movable2,
test::minimal::hash<test::minimal::movable2>,
test::minimal::equal_to<test::minimal::movable2>, test::minimal::equal_to<test::minimal::movable2>,
test::minimal::allocator<test::minimal::movable2> > test::minimal::allocator<test::minimal::movable2> >
set; set;
#else
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;
#endif
// unordered_unique_test(set, movable2); // unordered_unique_test(set, movable2);
unordered_set_test(set, movable2); unordered_set_test(set, movable2);
unordered_movable_test(set, movable2, movable2, hash, equal_to); unordered_movable_test(set, movable2, movable2, hash, equal_to);
}
#ifndef BOOST_UNORDERED_FOA_TESTS UNORDERED_AUTO_TEST (movable2_tests) {
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
boost::unordered_multiset<test::minimal::movable2, #ifdef BOOST_UNORDERED_FOA_TESTS
test::minimal::hash<test::minimal::movable2>, movable2_tests_impl<boost::unordered_flat_set>();
test::minimal::equal_to<test::minimal::movable2>, movable2_tests_impl<boost::unordered_node_set>();
test::minimal::allocator<test::minimal::movable2> > #else
multiset; movable2_tests_impl<boost::unordered_set>();
movable2_tests_impl<boost::unordered_multiset>();
// unordered_equivalent_test(multiset, movable2);
unordered_set_test(multiset, movable2);
unordered_movable_test(multiset, movable2, movable2, hash, equal_to);
#endif #endif
} }
UNORDERED_AUTO_TEST (destructible_tests) { template <template <class T, class H = boost::hash<T>,
class P = std::equal_to<T>, class A = std::allocator<T> >
class Set>
static void destructible_tests_impl()
{
test::minimal::constructor_param x; test::minimal::constructor_param x;
test::minimal::destructible destructible(x); test::minimal::destructible destructible(x);
test::minimal::hash<test::minimal::destructible> hash(x); test::minimal::hash<test::minimal::destructible> hash(x);
test::minimal::equal_to<test::minimal::destructible> equal_to(x); test::minimal::equal_to<test::minimal::destructible> equal_to(x);
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n"; Set<test::minimal::destructible,
#ifdef BOOST_UNORDERED_FOA_TESTS
boost::unordered_flat_set<test::minimal::destructible,
test::minimal::hash<test::minimal::destructible>, test::minimal::hash<test::minimal::destructible>,
test::minimal::equal_to<test::minimal::destructible> > test::minimal::equal_to<test::minimal::destructible> >
set; set;
#else
boost::unordered_set<test::minimal::destructible,
test::minimal::hash<test::minimal::destructible>,
test::minimal::equal_to<test::minimal::destructible> >
set;
#endif
unordered_destructible_test(set); unordered_destructible_test(set);
}
#ifndef BOOST_UNORDERED_FOA_TESTS UNORDERED_AUTO_TEST (destructible_tests) {
BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n"; #ifdef BOOST_UNORDERED_FOA_TESTS
destructible_tests_impl<boost::unordered_flat_set>();
boost::unordered_multiset<test::minimal::destructible, destructible_tests_impl<boost::unordered_node_set>();
test::minimal::hash<test::minimal::destructible>, #else
test::minimal::equal_to<test::minimal::destructible> > destructible_tests_impl<boost::unordered_set>();
multiset; destructible_tests_impl<boost::unordered_multiset>();
unordered_destructible_test(multiset);
#endif #endif
} }
@ -410,9 +389,17 @@ bool operator==(lwg2059_key x, lwg2059_key y) { return x.value == y.value; }
UNORDERED_AUTO_TEST (lwg2059) { UNORDERED_AUTO_TEST (lwg2059) {
#ifdef BOOST_UNORDERED_FOA_TESTS #ifdef BOOST_UNORDERED_FOA_TESTS
boost::unordered_flat_set<lwg2059_key> x; {
x.emplace(lwg2059_key(10)); boost::unordered_flat_set<lwg2059_key> x;
x.erase(x.begin()); x.emplace(lwg2059_key(10));
x.erase(x.begin());
}
{
boost::unordered_node_set<lwg2059_key> x;
x.emplace(lwg2059_key(10));
x.erase(x.begin());
}
#else #else
{ {
boost::unordered_set<lwg2059_key> x; boost::unordered_set<lwg2059_key> x;