test_completion_signatures.cpp

Go to the documentation of this file.

#include "gmock/gmock.h"
 
#include "kokkos-execution/utils/ignore_warnings.hpp"
PRAGMA_DIAGNOSTIC_PUSH
KOKKOS_EXECUTION_STDEXEC_PRAGMA_DIAGNOSTIC_IGNORED
#include "exec/single_thread_context.hpp"
PRAGMA_DIAGNOSTIC_POP
 
#include "kokkos-execution/execution_space.hpp"
 
#include "tests/utils/execution_space_context.hpp"
#include "tests/utils/functors/increment.hpp"
#include "tests/utils/functors/throws_when_copied.hpp"

 
namespace Tests::Impl {
 
using sndr_t =
    decltype(stdexec::schedule(std::declval<experimental::execution::single_thread_context>().get_scheduler()) | stdexec::then([]() noexcept {
             }));

consteval bool test_add_nothing_empty_env() {
    static_assert(
        Kokkos::Execution::Impl::completion_signatures_add<sndr_t, stdexec::completion_signatures<>, stdexec::env<>>()
        == stdexec::completion_signatures<stdexec::set_value_t()>{});
 
    return true;
}
static_assert(test_add_nothing_empty_env());

consteval bool test_add_error_empty_env() {
    static_assert(
        Kokkos::Execution::Impl::completion_signatures_add<
            sndr_t,
            stdexec::completion_signatures<stdexec::set_error_t(float)>,
            stdexec::env<>
        >()
        == stdexec::completion_signatures<stdexec::set_value_t(), stdexec::set_error_t(float)>{});
 
    return true;
}
static_assert(test_add_error_empty_env());
 
using env_with_stop_token_t = stdexec::prop<stdexec::get_stop_token_t, stdexec::inplace_stop_token>;

consteval bool test_add_nothing_stop_env() {
    static_assert(
        Kokkos::Execution::Impl::completion_signatures_add<
            sndr_t,
            stdexec::completion_signatures<>,
            env_with_stop_token_t
        >()
        == stdexec::completion_signatures<stdexec::set_value_t(), stdexec::set_stopped_t()>{});
 
    return true;
}
static_assert(test_add_nothing_stop_env());

consteval bool test_add_error_stop_env() {
    static_assert(
        Kokkos::Execution::Impl::completion_signatures_add<
            sndr_t,
            stdexec::completion_signatures<stdexec::set_error_t(float)>,
            env_with_stop_token_t
        >()
        == stdexec::completion_signatures<
            stdexec::set_value_t(),
            stdexec::set_error_t(float),
            stdexec::set_stopped_t()
        >{});
 
    return true;
}
static_assert(test_add_error_stop_env());
 
class CompletionSignaturesTest : public Tests::Utils::ExecutionSpaceContextTest<TEST_EXECUTION_SPACE> { };

TEST_F(CompletionSignaturesTest, parallel_for) {
    const view_s_t data(Kokkos::view_alloc("data - shared space"));
 
    experimental::execution::single_thread_context stc{};
 
    const context_t esc{exec};
 
    stdexec::inplace_stop_source source;
 
    auto stc_then_continues_on_esc_sndr = stdexec::schedule(stc.get_scheduler()) | stdexec::then([]() noexcept { })
                                        | stdexec::continues_on(esc.get_scheduler());

    static_assert(
        stdexec::get_completion_signatures<decltype(stc_then_continues_on_esc_sndr), env_with_stop_token_t>()
        == stdexec::completion_signatures<stdexec::set_value_t(), stdexec::set_stopped_t()>{});
 
    auto stc_then_continues_on_esc_then_sndr =
        std::move(stc_then_continues_on_esc_sndr) // NOLINT(performance-move-const-arg)
        | stdexec::then(Tests::Utils::Functors::Increment<view_s_t, true, false>{.data = data});

    static_assert(
        stdexec::get_completion_signatures<decltype(stc_then_continues_on_esc_then_sndr), env_with_stop_token_t>()
        == stdexec::completion_signatures<
            stdexec::set_value_t(),
            stdexec::set_error_t(std::exception_ptr),
            stdexec::set_stopped_t()
        >{});
 
    auto stc_then_continues_on_esc_then_then_sndr =
        std::move(stc_then_continues_on_esc_then_sndr)
        | stdexec::then(Tests::Utils::Functors::Increment<view_s_t, true, false>{.data = data});

    static_assert(
        stdexec::get_completion_signatures<decltype(stc_then_continues_on_esc_then_then_sndr), env_with_stop_token_t>()
        == stdexec::completion_signatures<
            stdexec::set_value_t(),
            stdexec::set_error_t(std::exception_ptr),
            stdexec::set_stopped_t()
        >{});
 
    ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
 
    ASSERT_FALSE(source.stop_requested());
 
    KOKKOS_EXECUTION_THREADS_THROWS_ON_SYNC_WAIT_ASSERT_AND_SKIP(stc_then_continues_on_esc_then_then_sndr)
 
    const auto res_A = stdexec::sync_wait(
        stc_then_continues_on_esc_then_then_sndr
        | stdexec::write_env(stdexec::prop{stdexec::get_stop_token, source.get_token()}));
 
    ASSERT_TRUE(res_A.has_value());
 
    ASSERT_EQ(data(), 2);
 
    source.request_stop();
 
    const auto res_B = stdexec::sync_wait(
        std::move(stc_then_continues_on_esc_then_then_sndr)
        | stdexec::write_env(stdexec::prop{stdexec::get_stop_token, source.get_token()}));
 
    ASSERT_FALSE(res_B.has_value());
 
    ASSERT_EQ(data(), 2);
}
 
} // namespace Tests::Impl