test_closure.cpp

Go to the documentation of this file.

#include "gtest/gtest.h"
 
#include "kokkos-execution/impl/empty.hpp"
#include "kokkos-execution/stdexec.hpp"
 
#include "tests/utils/functors/counter.hpp"
#include "tests/utils/functors/no_op.hpp"
#include "tests/utils/functors/throws_when_copied.hpp"

 
namespace Tests {
 
using Empty = Kokkos::Execution::Impl::Empty;
using NoOp = Tests::Utils::Functors::NoOp<false, false, false>;
using ThrowsWhenCopied = Tests::Utils::Functors::ThrowsWhenCopied;

consteval bool test_closure_from_rvalue() {
    ThrowsWhenCopied value;
 
    [[maybe_unused]]
    const auto res_from_xvalue = stdexec::__closure(std::move(value));
 
    [[maybe_unused]]
    const auto res_from_prvalue = stdexec::__closure(ThrowsWhenCopied{});
 
    return true;
}
 
static_assert(test_closure_from_rvalue());
 
 
#if defined(__cpp_constexpr_exceptions)
consteval bool test_closure_from_lvalue() {
    const ThrowsWhenCopied value;
    try {
        [[maybe_unused]]
        const auto res = stdexec::__closure(value);
        return false;
    } catch (...) {
        return true;
    }
}
 
static_assert(test_closure_from_lvalue());
#endif

consteval bool test_nothrow_constructibility() {
    static_assert(!std::is_nothrow_constructible_v<stdexec::__closure<ThrowsWhenCopied>, ThrowsWhenCopied&>);
    static_assert(std::is_nothrow_constructible_v<stdexec::__closure<ThrowsWhenCopied>, ThrowsWhenCopied>);
    return true;
}
 
static_assert(test_nothrow_constructibility());

consteval bool test_decays() {
    static_assert(std::same_as<decltype(stdexec::__closure(std::declval<Empty&>())), stdexec::__closure<Empty>>);
    static_assert(std::same_as<decltype(stdexec::__closure(std::declval<Empty&&>())), stdexec::__closure<Empty>>);
    static_assert(std::same_as<decltype(stdexec::__closure(std::declval<const Empty&>())), stdexec::__closure<Empty>>);
    static_assert(std::same_as<
                  decltype(stdexec::__closure(std::declval<int&>(), std::declval<double&&>())),
                  stdexec::__closure<int, double>
    >);
 
    return true;
}
 
static_assert(test_decays());

consteval bool test_may_be_composed_with_closure_of_the_same_type() {
    auto clsr_a = stdexec::then(NoOp{});
    auto clsr_b = stdexec::then(NoOp{});
 
    using clsr_t = decltype(clsr_a);
    static_assert(std::same_as<clsr_t, stdexec::__closure<stdexec::then_t, NoOp>>);
 
    const auto clsr_composed = clsr_a | clsr_b;
 
    static_assert(
        std::same_as<std::remove_const_t<decltype(clsr_composed)>, stdexec::__clsur::__composed<clsr_t, clsr_t>>);
    static_assert(std::derived_from<decltype(clsr_composed), stdexec::__composed<clsr_t, clsr_t>>);
    static_assert(stdexec::__sender_adaptor_closure<decltype(clsr_composed)>);
 
    return true;
}
 
static_assert(test_may_be_composed_with_closure_of_the_same_type());
 
class ClosureTest : public testing::Test {
   protected:
    using counter_t = Tests::Utils::Functors::Counter;
   public:
    void SetUp() override {
        counter_t::reset();
    }
};

TEST_F(ClosureTest, stored_by_value) {
    counter_t counter{};
 
    [[maybe_unused]]
    const auto res1 = stdexec::__closure(counter);
    [[maybe_unused]]
    const auto res2 = stdexec::__closure(counter);
 
    ASSERT_EQ(counter_t::copy_constructions, 2);
    ASSERT_EQ(counter_t::copy_assignments, 0);
    ASSERT_EQ(counter_t::move_constructions, 0);
    ASSERT_EQ(counter_t::move_assignments, 0);
 
    [[maybe_unused]]
    const auto res3 = stdexec::__closure(std::move(counter));
 
    ASSERT_EQ(counter_t::copy_constructions, 2);
    ASSERT_EQ(counter_t::copy_assignments, 0);
    ASSERT_EQ(counter_t::move_constructions, 1);
    ASSERT_EQ(counter_t::move_assignments, 0);
 
    [[maybe_unused]]
    const auto res4 = stdexec::__closure(counter_t{});
 
    ASSERT_EQ(counter_t::copy_constructions, 2);
    ASSERT_EQ(counter_t::copy_assignments, 0);
    ASSERT_EQ(counter_t::move_constructions, 2);
    ASSERT_EQ(counter_t::move_assignments, 0);
}
 
} // namespace Tests