boostorg/unordered
1
0
Fork 1
mirror of https://github.com/boostorg/unordered.git synced 2025-07-31 20:04:29 +02:00
Code Issues Packages Projects Releases Wiki Activity

Flesh out assign_tests

Browse Source
This commit is contained in:
Christian Mazakas
2023-04-25 13:14:08 -07:00
parent a7c15e86fc
commit 2b612ed120
1 changed files with 183 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

232
test/cfoa/assign_tests.cpp
View File

@@ -6,6 +6,12 @@
#include <boost/unordered/concurrent_flat_map.hpp> #include <boost/unordered/concurrent_flat_map.hpp>
#if defined(__clang__) && defined(__has_warning)
#if __has_warning("-Wself-assign-overloaded")
#pragma clang diagnostic ignored "-Wself-assign-overloaded"
#endif
#endif
test::seed_t initialize_seed{2762556623}; test::seed_t initialize_seed{2762556623};
using test::default_generator; using test::default_generator;
@@ -21,6 +27,43 @@ using map_type = boost::unordered::concurrent_flat_map<raii, raii, hasher,
using map_value_type = typename map_type::value_type; using map_value_type = typename map_type::value_type;
template <class T> struct pocca_allocator
{
using propagate_on_container_copy_assignment = std::true_type;
int x_ = -1;
using value_type = T;
pocca_allocator() = default;
pocca_allocator(pocca_allocator const&) = default;
pocca_allocator(pocca_allocator&&) = default;
pocca_allocator(int const x) : x_{x} {}
pocca_allocator& operator=(pocca_allocator const& rhs)
{
if (this != &rhs) {
x_ = rhs.x_;
}
return *this;
}
template <class U> pocca_allocator(pocca_allocator<U> const& rhs) : x_{rhs.x_}
{
}
T* allocate(std::size_t n)
{
return static_cast<T*>(::operator new(n * sizeof(T)));
}
void deallocate(T* p, std::size_t) { ::operator delete(p); }
bool operator==(pocca_allocator const& rhs) const { return x_ == rhs.x_; }
bool operator!=(pocca_allocator const& rhs) const { return x_ != rhs.x_; }
};
namespace { namespace {
template <class G> void copy_assign(G gen, test::random_generator rg) template <class G> void copy_assign(G gen, test::random_generator rg)
{ {
@@ -28,30 +71,31 @@ namespace {
auto reference_map = auto reference_map =
boost::unordered_flat_map<raii, raii>(values.begin(), values.end()); boost::unordered_flat_map<raii, raii>(values.begin(), values.end());
// to test:
// self-assign
// propagation
//
// lhs empty, rhs empty // lhs empty, rhs empty
{ {
raii::reset_counts(); raii::reset_counts();
map_type x(0, hasher(1), key_equal(2), allocator_type(3)); map_type x(0, hasher(1), key_equal(2), allocator_type(3));
map_type y;
BOOST_TEST(x.empty()); thread_runner(values, [&x](boost::span<map_value_type> s) {
BOOST_TEST(y.empty()); (void)s;
y = x;
map_type y;
BOOST_TEST(x.empty());
BOOST_TEST(y.empty());
y = x;
BOOST_TEST_EQ(x.hash_function(), y.hash_function());
BOOST_TEST_EQ(x.key_eq(), y.key_eq());
BOOST_TEST(x.get_allocator() != y.get_allocator());
});
BOOST_TEST_EQ(raii::destructor, 0u); BOOST_TEST_EQ(raii::destructor, 0u);
BOOST_TEST_EQ(raii::copy_assignment, 0u); BOOST_TEST_EQ(raii::copy_assignment, 0u);
BOOST_TEST_EQ(raii::move_assignment, 0u); BOOST_TEST_EQ(raii::move_assignment, 0u);
BOOST_TEST_EQ(raii::copy_constructor, 0u); BOOST_TEST_EQ(raii::copy_constructor, 0u);
BOOST_TEST_EQ(x.hash_function(), y.hash_function());
BOOST_TEST_EQ(x.key_eq(), y.key_eq());
BOOST_TEST(x.get_allocator() != y.get_allocator());
} }
// lhs non-empty, rhs empty // lhs non-empty, rhs empty
@@ -60,23 +104,28 @@ namespace {
map_type x(0, hasher(1), key_equal(2), allocator_type(3)); map_type x(0, hasher(1), key_equal(2), allocator_type(3));
map_type y(values.begin(), values.end(), values.size()); auto const old_size = reference_map.size();
auto const old_cc = +raii::copy_constructor; thread_runner(values, [&x, &values](boost::span<map_value_type> s) {
auto const old_size = y.size(); (void)s;
BOOST_TEST(x.empty()); map_type y(values.begin(), values.end(), values.size());
BOOST_TEST(!y.empty());
y = x;
BOOST_TEST_EQ(raii::destructor, 2 * old_size); BOOST_TEST(x.empty());
BOOST_TEST(!y.empty());
y = x;
BOOST_TEST_EQ(x.hash_function(), y.hash_function());
BOOST_TEST_EQ(x.key_eq(), y.key_eq());
BOOST_TEST(x.get_allocator() != y.get_allocator());
});
BOOST_TEST_EQ(raii::destructor, num_threads * (2 * old_size));
BOOST_TEST_EQ(raii::copy_assignment, 0u); BOOST_TEST_EQ(raii::copy_assignment, 0u);
BOOST_TEST_EQ(raii::move_assignment, 0u); BOOST_TEST_EQ(raii::move_assignment, 0u);
BOOST_TEST_EQ(raii::copy_constructor, old_cc); BOOST_TEST_EQ(
raii::copy_constructor, num_threads * 2 * reference_map.size());
BOOST_TEST_EQ(x.hash_function(), y.hash_function());
BOOST_TEST_EQ(x.key_eq(), y.key_eq());
BOOST_TEST(x.get_allocator() != y.get_allocator());
} }
check_raii_counts(); check_raii_counts();
@@ -87,23 +136,31 @@ namespace {
map_type x(values.begin(), values.end(), values.size(), hasher(1), map_type x(values.begin(), values.end(), values.size(), hasher(1),
key_equal(2), allocator_type(3)); key_equal(2), allocator_type(3));
map_type y;
auto const old_cc = +raii::copy_constructor; auto const old_cc = +raii::copy_constructor;
BOOST_TEST(!x.empty()); thread_runner(
BOOST_TEST(y.empty()); values, [&x, &reference_map](boost::span<map_value_type> s) {
y = x; (void)s;
BOOST_TEST_EQ(raii::destructor, 0u); map_type y;
BOOST_TEST(!x.empty());
BOOST_TEST(y.empty());
y = x;
BOOST_TEST_EQ(x.hash_function(), y.hash_function());
BOOST_TEST_EQ(x.key_eq(), y.key_eq());
BOOST_TEST(x.get_allocator() != y.get_allocator());
test_matches_reference(y, reference_map);
});
BOOST_TEST_EQ(raii::destructor, num_threads * 2 * x.size());
BOOST_TEST_EQ(raii::copy_assignment, 0u); BOOST_TEST_EQ(raii::copy_assignment, 0u);
BOOST_TEST_EQ(raii::move_assignment, 0u); BOOST_TEST_EQ(raii::move_assignment, 0u);
BOOST_TEST_EQ(raii::copy_constructor, old_cc + (2 * x.size())); BOOST_TEST_EQ(
raii::copy_constructor, old_cc + (num_threads * 2 * x.size()));
BOOST_TEST_EQ(x.hash_function(), y.hash_function());
BOOST_TEST_EQ(x.key_eq(), y.key_eq());
BOOST_TEST(x.get_allocator() != y.get_allocator());
test_matches_reference(y, reference_map);
} }
check_raii_counts(); check_raii_counts();
@@ -114,27 +171,104 @@ namespace {
map_type x(values.begin(), values.end(), values.size(), hasher(1), map_type x(values.begin(), values.end(), values.size(), hasher(1),
key_equal(2), allocator_type(3)); key_equal(2), allocator_type(3));
map_type y(values.begin(), values.end(), values.size()); auto const old_size = x.size();
auto const old_size = y.size();
auto const old_cc = +raii::copy_constructor; auto const old_cc = +raii::copy_constructor;
BOOST_TEST(!x.empty()); thread_runner(values, [&x, &values](boost::span<map_value_type> s) {
BOOST_TEST(!y.empty()); (void)s;
y = x;
BOOST_TEST_EQ(raii::destructor, 2 * old_size); map_type y(values.begin(), values.end(), values.size());
BOOST_TEST(!x.empty());
BOOST_TEST(!y.empty());
y = x;
BOOST_TEST_EQ(x.hash_function(), y.hash_function());
BOOST_TEST_EQ(x.key_eq(), y.key_eq());
BOOST_TEST(x.get_allocator() != y.get_allocator());
});
BOOST_TEST_EQ(raii::destructor, 2 * num_threads * 2 * old_size);
BOOST_TEST_EQ(raii::copy_assignment, 0u); BOOST_TEST_EQ(raii::copy_assignment, 0u);
BOOST_TEST_EQ(raii::move_assignment, 0u); BOOST_TEST_EQ(raii::move_assignment, 0u);
BOOST_TEST_EQ(raii::copy_constructor, old_cc + (2 * x.size())); BOOST_TEST_EQ(
raii::copy_constructor, old_cc + (2 * num_threads * 2 * x.size()));
}
check_raii_counts();
BOOST_TEST_EQ(x.hash_function(), y.hash_function()); // self-assign
BOOST_TEST_EQ(x.key_eq(), y.key_eq()); {
BOOST_TEST(x.get_allocator() != y.get_allocator()); raii::reset_counts();
map_type x(values.begin(), values.end(), values.size(), hasher(1),
key_equal(2), allocator_type(3));
auto const old_cc = +raii::copy_constructor;
thread_runner(
values, [&x, &reference_map](boost::span<map_value_type> s) {
(void)s;
BOOST_TEST(!x.empty());
x = x;
BOOST_TEST_EQ(x.hash_function(), hasher(1));
BOOST_TEST_EQ(x.key_eq(), key_equal(2));
BOOST_TEST(x.get_allocator() == allocator_type(3));
test_matches_reference(x, reference_map);
});
BOOST_TEST_EQ(raii::destructor, 0u);
BOOST_TEST_EQ(raii::copy_assignment, 0u);
BOOST_TEST_EQ(raii::move_assignment, 0u);
BOOST_TEST_EQ(raii::copy_constructor, old_cc);
}
check_raii_counts();
// propagation
{
using pocca_allocator_type =
pocca_allocator<std::pair<const raii, raii> >;
using pocca_map_type = boost::unordered::concurrent_flat_map<raii, raii,
hasher, key_equal, pocca_allocator_type>;
raii::reset_counts();
pocca_map_type x(values.begin(), values.end(), values.size(), hasher(1),
key_equal(2), pocca_allocator_type(3));
auto const old_size = x.size();
auto const old_cc = +raii::copy_constructor;
thread_runner(values, [&x, &values](boost::span<map_value_type> s) {
(void)s;
pocca_map_type y(values.begin(), values.end(), values.size());
BOOST_TEST(!x.empty());
BOOST_TEST(!y.empty());
BOOST_TEST(x.get_allocator() != y.get_allocator());
y = x;
BOOST_TEST_EQ(x.hash_function(), y.hash_function());
BOOST_TEST_EQ(x.key_eq(), y.key_eq());
BOOST_TEST(x.get_allocator() == y.get_allocator());
});
BOOST_TEST_EQ(raii::destructor, 2 * num_threads * 2 * old_size);
BOOST_TEST_EQ(raii::copy_assignment, 0u);
BOOST_TEST_EQ(raii::move_assignment, 0u);
BOOST_TEST_EQ(
raii::copy_constructor, old_cc + (2 * num_threads * 2 * x.size()));
} }
check_raii_counts(); check_raii_counts();
} }
} // namespace } // namespace
// clang-format off // clang-format off