coffee/continuable
1
0
Fork 0
mirror of https://github.com/Naios/continuable.git synced 2025-12-06 16:56:44 +08:00
Code Issues Packages Projects Releases Wiki Activity

Partial conversion of the async traversal unit test

Browse Source
This commit is contained in:
Denis Blank 2018-02-10 01:37:38 +01:00
parent 4b00f5ff8a
commit f935d78c99
1 changed files with 231 additions and 422 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

401
test/unit-test/test-continuable-traverse-async.cpp
View File

@ -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,144 +31,69 @@ 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>
{
class async_counter_base : public std::enable_shared_from_this<Child> {
std::size_t counter_ = 0;
public:
async_counter_base() = default;
virtual ~async_counter_base() {}
virtual ~async_counter_base() {
}
std::size_t const& counter() const noexcept
{
std::size_t const& counter() const noexcept {
return counter_;
}
std::size_t& counter() noexcept
{
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)
{
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);
void operator()(async_traverse_detach_tag, std::size_t i, N&& next) {
unused(i);
unused(next);
// Should never be called!
HPX_TEST(false);
EXPECT_TRUE(false);
}
template <typename T>
void operator()(async_traverse_complete_tag, T&& pack)
{
HPX_UNUSED(pack);
void operator()(async_traverse_complete_tag, T&& pack) {
unused(pack);
EXPECT_EQ(this->counter(), ArgCount);
++this->counter();
@ -236,29 +102,26 @@ struct async_increasing_int_sync_visitor
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
{
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);
void operator()(async_traverse_detach_tag, std::size_t i, N&& next) {
unused(i);
++this->counter();
std::forward<N>(next)();
}
template <typename T>
void operator()(async_traverse_complete_tag, T&& pack)
{
HPX_UNUSED(pack);
void operator()(async_traverse_complete_tag, T&& pack) {
unused(pack);
EXPECT_EQ(this->counter(), ArgCount);
++this->counter();
@ -266,13 +129,12 @@ struct async_increasing_int_visitor
};
template <std::size_t ArgCount, typename... Args>
void test_async_traversal_base(Args&&... 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<
auto result =
traverse_pack_async(async_traverse_in_place_tag<
async_increasing_int_sync_visitor<ArgCount>>{},
42, args...);
EXPECT_EQ(result->counter(), ArgCount + 1U);
@ -282,28 +144,20 @@ void test_async_traversal_base(Args&&... args)
// 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>>{},
async_traverse_in_place_tag<async_increasing_int_visitor<ArgCount>>{},
42, args...);
EXPECT_EQ(result->counter(), ArgCount + 1U);
}
}
static void test_async_traversal()
{
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{});
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)
{
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
@ -313,29 +167,22 @@ void test_async_container_traversal_impl(ContainerFactory&& container_of)
}
template <typename T>
struct common_container_factory
{
struct common_container_factory {
template <typename... Args>
T operator()(Args&&... 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
{
struct array_container_factory {
template <typename... Args, typename Array = std::array<T, sizeof...(Args)>>
Array operator()(Args&&... args)
{
Array operator()(Args&&... args) {
return Array{{std::forward<Args>(args)...}};
}
};
#endif
static void test_async_container_traversal()
{
void test_async_container_traversal() {
{
common_container_factory<std::vector<std::size_t>> factory;
test_async_container_traversal_impl(factory);
@ -351,45 +198,37 @@ static void test_async_container_traversal()
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
}
static void test_async_tuple_like_traversal()
{
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_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_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,
template <typename T, typename... Args,
typename Vector = std::vector<typename std::decay<T>::type>>
Vector vector_of(T&& first, Args&&... args)
{
Vector vector_of(T&& first, Args&&... args) {
return Vector{std::forward<T>(first), std::forward<Args>(args)...};
}
static void test_async_mixed_traversal()
{
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_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(0U, vector_of(not_accepted_tag{}), vector_of(vector_of(1U))),
make_tuple(2U, 3U));
test_async_traversal_base<4U>(
@ -398,33 +237,29 @@ static void test_async_mixed_traversal()
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)
{
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);
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);
EXPECT_TRUE(false);
}
template <typename T>
void operator()(async_traverse_complete_tag, T&& pack)
{
HPX_UNUSED(pack);
void operator()(async_traverse_complete_tag, T&& pack) {
unused(pack);
EXPECT_EQ(this->counter(), ArgCount);
++this->counter();
@ -432,113 +267,87 @@ struct async_unique_sync_visitor
};
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
{
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);
void operator()(async_traverse_detach_tag, std::unique_ptr<std::size_t>& i,
N&& next) {
unused(i);
++this->counter();
std::forward<N>(next)();
}
template <typename T>
void operator()(async_traverse_complete_tag, T&& pack)
{
HPX_UNUSED(pack);
void operator()(async_traverse_complete_tag, T&& pack) {
unused(pack);
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));
};
template <typename T>
constexpr auto of(T i) {
return std::make_unique<T>(i);
}
{
TEST(async_traverse_in_place, construct_inplace_sync) {
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));
async_traverse_in_place_tag<async_unique_sync_visitor<4>>{}, 42, of(0),
of(1), of(2), of(3));
EXPECT_EQ(result->counter(), 5U);
}
{
TEST(async_traverse_in_place, construct_inplace_async) {
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));
async_traverse_in_place_tag<async_unique_visitor<4>>{}, 42, of(0), of(1),
of(2), of(3));
EXPECT_EQ(result->counter(), 5U);
}
struct invalidate_visitor : async_counter_base<invalidate_visitor> {
explicit invalidate_visitor(int /*dummy*/) {
}
struct invalidate_visitor : async_counter_base<invalidate_visitor>
{
explicit invalidate_visitor(int dummy) {}
bool operator()(async_traverse_visit_tag, std::shared_ptr<int>& i) const
{
bool operator()(async_traverse_visit_tag, std::shared_ptr<int>& i) const {
EXPECT_EQ(*i, 22);
return false;
}
template <typename N>
void operator()(async_traverse_detach_tag,
std::shared_ptr<int>& i,
N&& next)
{
HPX_UNUSED(i);
void operator()(async_traverse_detach_tag, std::shared_ptr<int>& i,
N&& next) {
unused(i);
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
{
tuple<std::shared_ptr<int>>&& pack) const {
// Invalidate the moved object
tuple<std::shared_ptr<int>> moved = std::move(pack);
HPX_UNUSED(moved);
unused(moved);
}
};
// Check whether the arguments are invalidated (moved out) when called
static void test_async_complete_invalidation()
{
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);
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();
}
*/