mirror of
https://github.com/Naios/continuable.git
synced 2025-12-06 16:56:44 +08:00
Partial conversion of the async traversal unit test
This commit is contained in:
Denis Blank
parent
4b00f5ff8a
commit
f935d78c99
@ -22,65 +22,6 @@
|
||||
**/
|
||||
|
||||
#include <array>
|
||||
#include <memory>
|
||||
#include <tuple>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#include <continuable/continuable-traverse-async.hpp>
|
||||
|
||||
#include "test-continuable.hpp"
|
||||
|
||||
using std::get;
|
||||
using std::make_tuple;
|
||||
using std::tuple;
|
||||
|
||||
using cti::async_traverse_complete_tag;
|
||||
using cti::async_traverse_detach_tag;
|
||||
using cti::async_traverse_visit_tag;
|
||||
using cti::traverse_pack_async;
|
||||
|
||||
struct my_visitor : std::enable_shared_from_this<my_visitor> {
|
||||
virtual ~my_visitor() = default;
|
||||
|
||||
bool operator()(async_traverse_visit_tag, std::size_t i) {
|
||||
(void)i;
|
||||
return false;
|
||||
}
|
||||
|
||||
template <typename N>
|
||||
void operator()(async_traverse_detach_tag, std::size_t i, N&& next) {
|
||||
(void)i;
|
||||
next();
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void operator()(async_traverse_complete_tag, T&& pack) {
|
||||
(void)pack;
|
||||
}
|
||||
};
|
||||
|
||||
TEST(misc_as_test, my_test) {
|
||||
cti::traverse_pack_async(my_visitor{}, 0, 1, 2);
|
||||
}
|
||||
|
||||
// Copyright (c) 2017 Denis Blank
|
||||
// Copyright Andrey Semashev 2007 - 2013.
|
||||
//
|
||||
// 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)
|
||||
|
||||
// TODO Remove the boost dependency
|
||||
|
||||
/*
|
||||
#include <hpx/config.hpp>
|
||||
#include <hpx/util/atomic_count.hpp>
|
||||
#include <hpx/util/lightweight_test.hpp>
|
||||
#include <hpx/util/pack_traversal_async.hpp>
|
||||
#include <hpx/util/tuple.hpp>
|
||||
#include <hpx/util/unused.hpp>
|
||||
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <list>
|
||||
@ -90,455 +31,323 @@ TEST(misc_as_test, my_test) {
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#if defined(HPX_HAVE_CXX11_STD_ARRAY)
|
||||
#include <array>
|
||||
#endif
|
||||
#include <continuable/continuable-traverse-async.hpp>
|
||||
#include <continuable/detail/traits.hpp>
|
||||
#include <continuable/detail/util.hpp>
|
||||
|
||||
using hpx::util::async_traverse_complete_tag;
|
||||
using hpx::util::async_traverse_detach_tag;
|
||||
using hpx::util::async_traverse_visit_tag;
|
||||
using hpx::util::make_tuple;
|
||||
using hpx::util::traverse_pack_async;
|
||||
using hpx::util::tuple;
|
||||
#include "test-continuable.hpp"
|
||||
|
||||
using std::get;
|
||||
using std::make_tuple;
|
||||
using std::tuple;
|
||||
|
||||
using cti::async_traverse_complete_tag;
|
||||
using cti::async_traverse_detach_tag;
|
||||
using cti::async_traverse_in_place_tag;
|
||||
using cti::async_traverse_visit_tag;
|
||||
using cti::detail::util::unused;
|
||||
using cti::traverse_pack_async;
|
||||
|
||||
/// A tag which isn't accepted by any mapper
|
||||
struct not_accepted_tag
|
||||
{
|
||||
};
|
||||
|
||||
struct thread_safe_counter
|
||||
{
|
||||
typedef hpx::util::atomic_count type;
|
||||
|
||||
static unsigned int load(hpx::util::atomic_count const& counter) noexcept
|
||||
{
|
||||
return static_cast<unsigned int>(static_cast<long>(counter));
|
||||
}
|
||||
|
||||
static void increment(hpx::util::atomic_count& counter) noexcept
|
||||
{
|
||||
++counter;
|
||||
}
|
||||
|
||||
static unsigned int decrement(hpx::util::atomic_count& counter) noexcept
|
||||
{
|
||||
return static_cast<unsigned int>(--counter);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Derived, typename CounterPolicy = thread_safe_counter>
|
||||
class intrusive_ref_counter;
|
||||
|
||||
template <typename Derived, typename CounterPolicy>
|
||||
void intrusive_ptr_add_ref(
|
||||
intrusive_ref_counter<Derived, CounterPolicy> const* p) noexcept;
|
||||
|
||||
template <typename Derived, typename CounterPolicy>
|
||||
void intrusive_ptr_release(
|
||||
intrusive_ref_counter<Derived, CounterPolicy> const* p) noexcept;
|
||||
|
||||
template <typename Derived, typename CounterPolicy>
|
||||
class intrusive_ref_counter
|
||||
{
|
||||
private:
|
||||
typedef typename CounterPolicy::type counter_type;
|
||||
|
||||
mutable counter_type ref_counter;
|
||||
|
||||
public:
|
||||
intrusive_ref_counter() noexcept : ref_counter(1) {}
|
||||
|
||||
unsigned int use_count() const noexcept
|
||||
{
|
||||
return CounterPolicy::load(ref_counter);
|
||||
}
|
||||
|
||||
protected:
|
||||
~intrusive_ref_counter() = default;
|
||||
|
||||
friend void intrusive_ptr_add_ref<Derived, CounterPolicy>(
|
||||
intrusive_ref_counter<Derived, CounterPolicy> const* p)
|
||||
noexcept;
|
||||
|
||||
friend void intrusive_ptr_release<Derived, CounterPolicy>(
|
||||
intrusive_ref_counter<Derived, CounterPolicy> const* p)
|
||||
noexcept;
|
||||
};
|
||||
|
||||
template <typename Derived, typename CounterPolicy>
|
||||
inline void intrusive_ptr_add_ref(
|
||||
intrusive_ref_counter<Derived, CounterPolicy> const* p) noexcept
|
||||
{
|
||||
CounterPolicy::increment(p->ref_counter);
|
||||
}
|
||||
|
||||
template <typename Derived, typename CounterPolicy>
|
||||
inline void intrusive_ptr_release(
|
||||
intrusive_ref_counter<Derived, CounterPolicy> const* p) noexcept
|
||||
{
|
||||
if (CounterPolicy::decrement(p->ref_counter) == 0)
|
||||
delete static_cast<Derived const*>(p);
|
||||
}
|
||||
struct not_accepted_tag {};
|
||||
|
||||
template <typename Child>
|
||||
class async_counter_base : public intrusive_ref_counter<Child>
|
||||
{
|
||||
std::size_t counter_ = 0;
|
||||
class async_counter_base : public std::enable_shared_from_this<Child> {
|
||||
std::size_t counter_ = 0;
|
||||
|
||||
public:
|
||||
async_counter_base() = default;
|
||||
async_counter_base() = default;
|
||||
|
||||
virtual ~async_counter_base() {}
|
||||
virtual ~async_counter_base() {
|
||||
}
|
||||
|
||||
std::size_t const& counter() const noexcept
|
||||
{
|
||||
return counter_;
|
||||
}
|
||||
std::size_t const& counter() const noexcept {
|
||||
return counter_;
|
||||
}
|
||||
|
||||
std::size_t& counter() noexcept
|
||||
{
|
||||
return counter_;
|
||||
}
|
||||
std::size_t& counter() noexcept {
|
||||
return counter_;
|
||||
}
|
||||
};
|
||||
|
||||
template <std::size_t ArgCount>
|
||||
struct async_increasing_int_sync_visitor
|
||||
: async_counter_base<async_increasing_int_sync_visitor<ArgCount>>
|
||||
{
|
||||
explicit async_increasing_int_sync_visitor(int dummy) {}
|
||||
: async_counter_base<async_increasing_int_sync_visitor<ArgCount>> {
|
||||
explicit async_increasing_int_sync_visitor(int /*dummy*/) {
|
||||
}
|
||||
|
||||
bool operator()(async_traverse_visit_tag, std::size_t i)
|
||||
{
|
||||
EXPECT_EQ(i, this->counter());
|
||||
++this->counter();
|
||||
return true;
|
||||
}
|
||||
bool operator()(async_traverse_visit_tag, std::size_t i) {
|
||||
EXPECT_EQ(i, this->counter());
|
||||
++this->counter();
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename N>
|
||||
void operator()(async_traverse_detach_tag, std::size_t i, N&& next)
|
||||
{
|
||||
HPX_UNUSED(i);
|
||||
HPX_UNUSED(next);
|
||||
template <typename N>
|
||||
void operator()(async_traverse_detach_tag, std::size_t i, N&& next) {
|
||||
unused(i);
|
||||
unused(next);
|
||||
|
||||
// Should never be called!
|
||||
HPX_TEST(false);
|
||||
}
|
||||
// Should never be called!
|
||||
EXPECT_TRUE(false);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void operator()(async_traverse_complete_tag, T&& pack)
|
||||
{
|
||||
HPX_UNUSED(pack);
|
||||
template <typename T>
|
||||
void operator()(async_traverse_complete_tag, T&& pack) {
|
||||
unused(pack);
|
||||
|
||||
EXPECT_EQ(this->counter(), ArgCount);
|
||||
++this->counter();
|
||||
}
|
||||
EXPECT_EQ(this->counter(), ArgCount);
|
||||
++this->counter();
|
||||
}
|
||||
};
|
||||
|
||||
template <std::size_t ArgCount>
|
||||
struct async_increasing_int_visitor
|
||||
: async_counter_base<async_increasing_int_visitor<ArgCount>>
|
||||
{
|
||||
explicit async_increasing_int_visitor(int dummy) {}
|
||||
: async_counter_base<async_increasing_int_visitor<ArgCount>> {
|
||||
explicit async_increasing_int_visitor(int /*dummy*/) {
|
||||
}
|
||||
|
||||
bool operator()(async_traverse_visit_tag, std::size_t i) const
|
||||
{
|
||||
EXPECT_EQ(i, this->counter());
|
||||
return false;
|
||||
}
|
||||
bool operator()(async_traverse_visit_tag, std::size_t i) const {
|
||||
EXPECT_EQ(i, this->counter());
|
||||
return false;
|
||||
}
|
||||
|
||||
template <typename N>
|
||||
void operator()(async_traverse_detach_tag, std::size_t i, N&& next)
|
||||
{
|
||||
HPX_UNUSED(i);
|
||||
template <typename N>
|
||||
void operator()(async_traverse_detach_tag, std::size_t i, N&& next) {
|
||||
unused(i);
|
||||
|
||||
++this->counter();
|
||||
std::forward<N>(next)();
|
||||
}
|
||||
++this->counter();
|
||||
std::forward<N>(next)();
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void operator()(async_traverse_complete_tag, T&& pack)
|
||||
{
|
||||
HPX_UNUSED(pack);
|
||||
template <typename T>
|
||||
void operator()(async_traverse_complete_tag, T&& pack) {
|
||||
unused(pack);
|
||||
|
||||
EXPECT_EQ(this->counter(), ArgCount);
|
||||
++this->counter();
|
||||
}
|
||||
EXPECT_EQ(this->counter(), ArgCount);
|
||||
++this->counter();
|
||||
}
|
||||
};
|
||||
|
||||
template <std::size_t ArgCount, typename... Args>
|
||||
void test_async_traversal_base(Args&&... args)
|
||||
{
|
||||
// Test that every element is traversed in the correct order
|
||||
// when we detach the control flow on every visit.
|
||||
{
|
||||
auto result = traverse_pack_async(
|
||||
hpx::util::async_traverse_in_place_tag<
|
||||
async_increasing_int_sync_visitor<ArgCount>>{},
|
||||
42, args...);
|
||||
EXPECT_EQ(result->counter(), ArgCount + 1U);
|
||||
}
|
||||
void test_async_traversal_base(Args&&... args) {
|
||||
// Test that every element is traversed in the correct order
|
||||
// when we detach the control flow on every visit.
|
||||
{
|
||||
auto result =
|
||||
traverse_pack_async(async_traverse_in_place_tag<
|
||||
async_increasing_int_sync_visitor<ArgCount>>{},
|
||||
42, args...);
|
||||
EXPECT_EQ(result->counter(), ArgCount + 1U);
|
||||
}
|
||||
|
||||
// Test that every element is traversed in the correct order
|
||||
// when we detach the control flow on every visit.
|
||||
{
|
||||
auto result = traverse_pack_async(
|
||||
hpx::util::async_traverse_in_place_tag<
|
||||
async_increasing_int_visitor<ArgCount>>{},
|
||||
42, args...);
|
||||
EXPECT_EQ(result->counter(), ArgCount + 1U);
|
||||
}
|
||||
// Test that every element is traversed in the correct order
|
||||
// when we detach the control flow on every visit.
|
||||
{
|
||||
auto result = traverse_pack_async(
|
||||
async_traverse_in_place_tag<async_increasing_int_visitor<ArgCount>>{},
|
||||
42, args...);
|
||||
EXPECT_EQ(result->counter(), ArgCount + 1U);
|
||||
}
|
||||
}
|
||||
|
||||
static void test_async_traversal()
|
||||
{
|
||||
// Just test everything using a casual int pack
|
||||
test_async_traversal_base<4U>(not_accepted_tag{},
|
||||
0U,
|
||||
1U,
|
||||
not_accepted_tag{},
|
||||
2U,
|
||||
3U,
|
||||
not_accepted_tag{});
|
||||
void test_async_traversal() {
|
||||
// Just test everything using a casual int pack
|
||||
test_async_traversal_base<4U>(not_accepted_tag{}, 0U, 1U, not_accepted_tag{},
|
||||
2U, 3U, not_accepted_tag{});
|
||||
}
|
||||
|
||||
template <typename ContainerFactory>
|
||||
void test_async_container_traversal_impl(ContainerFactory&& container_of)
|
||||
{
|
||||
// Test by passing a containers in the middle
|
||||
test_async_traversal_base<4U>(0U, container_of(1U, 2U), 3U);
|
||||
// Test by splitting the pack in two containers
|
||||
test_async_traversal_base<4U>(container_of(0U, 1U), container_of(2U, 3U));
|
||||
// Test by passing a huge containers to the traversal
|
||||
test_async_traversal_base<4U>(container_of(0U, 1U, 2U, 3U));
|
||||
void test_async_container_traversal_impl(ContainerFactory&& container_of) {
|
||||
// Test by passing a containers in the middle
|
||||
test_async_traversal_base<4U>(0U, container_of(1U, 2U), 3U);
|
||||
// Test by splitting the pack in two containers
|
||||
test_async_traversal_base<4U>(container_of(0U, 1U), container_of(2U, 3U));
|
||||
// Test by passing a huge containers to the traversal
|
||||
test_async_traversal_base<4U>(container_of(0U, 1U, 2U, 3U));
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
struct common_container_factory
|
||||
{
|
||||
template <typename... Args>
|
||||
T operator()(Args&&... args)
|
||||
{
|
||||
return T{std::forward<Args>(args)...};
|
||||
}
|
||||
struct common_container_factory {
|
||||
template <typename... Args>
|
||||
T operator()(Args&&... args) {
|
||||
return T{std::forward<Args>(args)...};
|
||||
}
|
||||
};
|
||||
|
||||
#if defined(HPX_HAVE_CXX11_STD_ARRAY)
|
||||
template <typename T>
|
||||
struct array_container_factory
|
||||
{
|
||||
template <typename... Args, typename Array = std::array<T, sizeof...(Args)>>
|
||||
Array operator()(Args&&... args)
|
||||
{
|
||||
return Array{{std::forward<Args>(args)...}};
|
||||
}
|
||||
struct array_container_factory {
|
||||
template <typename... Args, typename Array = std::array<T, sizeof...(Args)>>
|
||||
Array operator()(Args&&... args) {
|
||||
return Array{{std::forward<Args>(args)...}};
|
||||
}
|
||||
};
|
||||
#endif
|
||||
|
||||
static void test_async_container_traversal()
|
||||
{
|
||||
{
|
||||
common_container_factory<std::vector<std::size_t>> factory;
|
||||
test_async_container_traversal_impl(factory);
|
||||
}
|
||||
void test_async_container_traversal() {
|
||||
{
|
||||
common_container_factory<std::vector<std::size_t>> factory;
|
||||
test_async_container_traversal_impl(factory);
|
||||
}
|
||||
|
||||
{
|
||||
common_container_factory<std::list<std::size_t>> factory;
|
||||
test_async_container_traversal_impl(factory);
|
||||
}
|
||||
{
|
||||
common_container_factory<std::list<std::size_t>> factory;
|
||||
test_async_container_traversal_impl(factory);
|
||||
}
|
||||
|
||||
{
|
||||
common_container_factory<std::set<std::size_t>> factory;
|
||||
test_async_container_traversal_impl(factory);
|
||||
}
|
||||
{
|
||||
common_container_factory<std::set<std::size_t>> factory;
|
||||
test_async_container_traversal_impl(factory);
|
||||
}
|
||||
|
||||
#if defined(HPX_HAVE_CXX11_STD_ARRAY)
|
||||
{
|
||||
array_container_factory<std::size_t> factory;
|
||||
test_async_container_traversal_impl(factory);
|
||||
}
|
||||
#endif
|
||||
{
|
||||
array_container_factory<std::size_t> factory;
|
||||
test_async_container_traversal_impl(factory);
|
||||
}
|
||||
}
|
||||
|
||||
static void test_async_tuple_like_traversal()
|
||||
{
|
||||
// Test by passing a tuple in the middle
|
||||
test_async_traversal_base<4U>(
|
||||
not_accepted_tag{}, 0U, make_tuple(1U, not_accepted_tag{}, 2U), 3U);
|
||||
// Test by splitting the pack in two tuples
|
||||
test_async_traversal_base<4U>(
|
||||
make_tuple(0U, not_accepted_tag{}, 1U), make_tuple(2U, 3U));
|
||||
// Test by passing a huge tuple to the traversal
|
||||
test_async_traversal_base<4U>(make_tuple(0U, 1U, 2U, 3U));
|
||||
void test_async_tuple_like_traversal() {
|
||||
// Test by passing a tuple in the middle
|
||||
test_async_traversal_base<4U>(not_accepted_tag{}, 0U,
|
||||
make_tuple(1U, not_accepted_tag{}, 2U), 3U);
|
||||
// Test by splitting the pack in two tuples
|
||||
test_async_traversal_base<4U>(make_tuple(0U, not_accepted_tag{}, 1U),
|
||||
make_tuple(2U, 3U));
|
||||
// Test by passing a huge tuple to the traversal
|
||||
test_async_traversal_base<4U>(make_tuple(0U, 1U, 2U, 3U));
|
||||
}
|
||||
|
||||
template <typename T,
|
||||
typename... Args,
|
||||
typename Vector = std::vector<typename std::decay<T>::type>>
|
||||
Vector vector_of(T&& first, Args&&... args)
|
||||
{
|
||||
return Vector{std::forward<T>(first), std::forward<Args>(args)...};
|
||||
template <typename T, typename... Args,
|
||||
typename Vector = std::vector<typename std::decay<T>::type>>
|
||||
Vector vector_of(T&& first, Args&&... args) {
|
||||
return Vector{std::forward<T>(first), std::forward<Args>(args)...};
|
||||
}
|
||||
|
||||
static void test_async_mixed_traversal()
|
||||
{
|
||||
using container_t = std::vector<std::size_t>;
|
||||
void test_async_mixed_traversal() {
|
||||
using container_t = std::vector<std::size_t>;
|
||||
|
||||
// Test hierarchies where container and tuple like types are mixed
|
||||
test_async_traversal_base<4U>(
|
||||
0U, hpx::util::make_tuple(container_t{1U, 2U}), 3U);
|
||||
// Test hierarchies where container and tuple like types are mixed
|
||||
test_async_traversal_base<4U>(0U, make_tuple(container_t{1U, 2U}), 3U);
|
||||
|
||||
test_async_traversal_base<4U>(
|
||||
hpx::util::make_tuple(
|
||||
0U, vector_of(not_accepted_tag{}), vector_of(vector_of(1U))),
|
||||
make_tuple(2U, 3U));
|
||||
test_async_traversal_base<4U>(
|
||||
make_tuple(0U, vector_of(not_accepted_tag{}), vector_of(vector_of(1U))),
|
||||
make_tuple(2U, 3U));
|
||||
|
||||
test_async_traversal_base<4U>(
|
||||
vector_of(vector_of(make_tuple(0U, 1U, 2U, 3U))));
|
||||
test_async_traversal_base<4U>(
|
||||
vector_of(vector_of(make_tuple(0U, 1U, 2U, 3U))));
|
||||
}
|
||||
|
||||
template <std::size_t ArgCount>
|
||||
struct async_unique_sync_visitor
|
||||
: async_counter_base<async_unique_sync_visitor<ArgCount>>
|
||||
{
|
||||
explicit async_unique_sync_visitor(int dummy) {}
|
||||
: async_counter_base<async_unique_sync_visitor<ArgCount>> {
|
||||
explicit async_unique_sync_visitor(int /*dummy*/) {
|
||||
}
|
||||
|
||||
bool operator()(async_traverse_visit_tag, std::unique_ptr<std::size_t>& i)
|
||||
{
|
||||
EXPECT_EQ(*i, this->counter());
|
||||
++this->counter();
|
||||
return true;
|
||||
}
|
||||
bool operator()(async_traverse_visit_tag, std::unique_ptr<std::size_t>& i) {
|
||||
EXPECT_EQ(*i, this->counter());
|
||||
++this->counter();
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename N>
|
||||
void operator()(async_traverse_detach_tag,
|
||||
std::unique_ptr<std::size_t>& i,
|
||||
N&& next)
|
||||
{
|
||||
HPX_UNUSED(i);
|
||||
HPX_UNUSED(next);
|
||||
template <typename N>
|
||||
void operator()(async_traverse_detach_tag, std::unique_ptr<std::size_t>& i,
|
||||
N&& next) {
|
||||
unused(i);
|
||||
unused(next);
|
||||
|
||||
// Should never be called!
|
||||
HPX_TEST(false);
|
||||
}
|
||||
// Should never be called!
|
||||
EXPECT_TRUE(false);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void operator()(async_traverse_complete_tag, T&& pack)
|
||||
{
|
||||
HPX_UNUSED(pack);
|
||||
template <typename T>
|
||||
void operator()(async_traverse_complete_tag, T&& pack) {
|
||||
unused(pack);
|
||||
|
||||
EXPECT_EQ(this->counter(), ArgCount);
|
||||
++this->counter();
|
||||
}
|
||||
EXPECT_EQ(this->counter(), ArgCount);
|
||||
++this->counter();
|
||||
}
|
||||
};
|
||||
|
||||
template <std::size_t ArgCount>
|
||||
struct async_unique_visitor : async_counter_base<async_unique_visitor<ArgCount>>
|
||||
{
|
||||
explicit async_unique_visitor(int dummy) {}
|
||||
struct async_unique_visitor
|
||||
: async_counter_base<async_unique_visitor<ArgCount>> {
|
||||
explicit async_unique_visitor(int /*dummy*/) {
|
||||
}
|
||||
|
||||
bool operator()(async_traverse_visit_tag,
|
||||
std::unique_ptr<std::size_t>& i) const
|
||||
{
|
||||
EXPECT_EQ(*i, this->counter());
|
||||
return false;
|
||||
}
|
||||
bool operator()(async_traverse_visit_tag,
|
||||
std::unique_ptr<std::size_t>& i) const {
|
||||
EXPECT_EQ(*i, this->counter());
|
||||
return false;
|
||||
}
|
||||
|
||||
template <typename N>
|
||||
void operator()(async_traverse_detach_tag,
|
||||
std::unique_ptr<std::size_t>& i,
|
||||
N&& next)
|
||||
{
|
||||
HPX_UNUSED(i);
|
||||
template <typename N>
|
||||
void operator()(async_traverse_detach_tag, std::unique_ptr<std::size_t>& i,
|
||||
N&& next) {
|
||||
unused(i);
|
||||
|
||||
++this->counter();
|
||||
std::forward<N>(next)();
|
||||
}
|
||||
++this->counter();
|
||||
std::forward<N>(next)();
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void operator()(async_traverse_complete_tag, T&& pack)
|
||||
{
|
||||
HPX_UNUSED(pack);
|
||||
template <typename T>
|
||||
void operator()(async_traverse_complete_tag, T&& pack) {
|
||||
unused(pack);
|
||||
|
||||
EXPECT_EQ(this->counter(), ArgCount);
|
||||
++this->counter();
|
||||
}
|
||||
EXPECT_EQ(this->counter(), ArgCount);
|
||||
++this->counter();
|
||||
}
|
||||
};
|
||||
|
||||
static void test_async_move_only_traversal()
|
||||
{
|
||||
auto const of = [](std::size_t i) {
|
||||
return std::unique_ptr<std::size_t>(new std::size_t(i));
|
||||
};
|
||||
|
||||
{
|
||||
auto result = traverse_pack_async(
|
||||
hpx::util::async_traverse_in_place_tag<
|
||||
async_unique_sync_visitor<4>>{},
|
||||
42, of(0), of(1), of(2), of(3));
|
||||
EXPECT_EQ(result->counter(), 5U);
|
||||
}
|
||||
|
||||
{
|
||||
auto result = traverse_pack_async(
|
||||
hpx::util::async_traverse_in_place_tag<
|
||||
async_unique_visitor<4>>{},
|
||||
42, of(0), of(1), of(2), of(3));
|
||||
EXPECT_EQ(result->counter(), 5U);
|
||||
}
|
||||
template <typename T>
|
||||
constexpr auto of(T i) {
|
||||
return std::make_unique<T>(i);
|
||||
}
|
||||
|
||||
struct invalidate_visitor : async_counter_base<invalidate_visitor>
|
||||
{
|
||||
explicit invalidate_visitor(int dummy) {}
|
||||
TEST(async_traverse_in_place, construct_inplace_sync) {
|
||||
auto result = traverse_pack_async(
|
||||
async_traverse_in_place_tag<async_unique_sync_visitor<4>>{}, 42, of(0),
|
||||
of(1), of(2), of(3));
|
||||
EXPECT_EQ(result->counter(), 5U);
|
||||
}
|
||||
|
||||
bool operator()(async_traverse_visit_tag, std::shared_ptr<int>& i) const
|
||||
{
|
||||
EXPECT_EQ(*i, 22);
|
||||
return false;
|
||||
}
|
||||
TEST(async_traverse_in_place, construct_inplace_async) {
|
||||
auto result = traverse_pack_async(
|
||||
async_traverse_in_place_tag<async_unique_visitor<4>>{}, 42, of(0), of(1),
|
||||
of(2), of(3));
|
||||
EXPECT_EQ(result->counter(), 5U);
|
||||
}
|
||||
|
||||
template <typename N>
|
||||
void operator()(async_traverse_detach_tag,
|
||||
std::shared_ptr<int>& i,
|
||||
N&& next)
|
||||
{
|
||||
HPX_UNUSED(i);
|
||||
struct invalidate_visitor : async_counter_base<invalidate_visitor> {
|
||||
explicit invalidate_visitor(int /*dummy*/) {
|
||||
}
|
||||
|
||||
std::forward<N>(next)();
|
||||
}
|
||||
bool operator()(async_traverse_visit_tag, std::shared_ptr<int>& i) const {
|
||||
EXPECT_EQ(*i, 22);
|
||||
return false;
|
||||
}
|
||||
|
||||
// Test whether the passed pack was passed as r-value reference
|
||||
void operator()(async_traverse_complete_tag,
|
||||
tuple<std::shared_ptr<int>>&& pack) const
|
||||
{
|
||||
// Invalidate the moved object
|
||||
tuple<std::shared_ptr<int>> moved = std::move(pack);
|
||||
template <typename N>
|
||||
void operator()(async_traverse_detach_tag, std::shared_ptr<int>& i,
|
||||
N&& next) {
|
||||
unused(i);
|
||||
|
||||
HPX_UNUSED(moved);
|
||||
}
|
||||
std::forward<N>(next)();
|
||||
}
|
||||
|
||||
// Test whether the passed pack was passed as r-value reference
|
||||
void operator()(async_traverse_complete_tag,
|
||||
tuple<std::shared_ptr<int>>&& pack) const {
|
||||
// Invalidate the moved object
|
||||
tuple<std::shared_ptr<int>> moved = std::move(pack);
|
||||
|
||||
unused(moved);
|
||||
}
|
||||
};
|
||||
|
||||
// Check whether the arguments are invalidated (moved out) when called
|
||||
static void test_async_complete_invalidation()
|
||||
{
|
||||
auto value = std::make_shared<int>(22);
|
||||
TEST(async_complete_invalidation, check_whether_frame_released) {
|
||||
auto value = std::make_shared<int>(22);
|
||||
|
||||
auto frame = traverse_pack_async(
|
||||
hpx::util::async_traverse_in_place_tag<invalidate_visitor>{},
|
||||
42, value);
|
||||
auto frame = traverse_pack_async(
|
||||
async_traverse_in_place_tag<invalidate_visitor>{}, 42, value);
|
||||
|
||||
EXPECT_EQ(value.use_count(), 1U);
|
||||
EXPECT_EQ(value.use_count(), 1L);
|
||||
}
|
||||
|
||||
int main(int, char**)
|
||||
{
|
||||
test_async_traversal();
|
||||
test_async_container_traversal();
|
||||
test_async_tuple_like_traversal();
|
||||
test_async_mixed_traversal();
|
||||
test_async_move_only_traversal();
|
||||
test_async_complete_invalidation();
|
||||
|
||||
return hpx::util::report_errors();
|
||||
}
|
||||
*/
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user