test_env.cpp

Go to the documentation of this file.

#include <concepts>
 
#include "gtest/gtest.h"
 
#include "kokkos-execution/stdexec.hpp"
 
#include "kokkos-execution/impl/env.hpp"

 
namespace Tests::Impl {
 
constexpr struct PropA : public stdexec::__query<PropA> {
} prop_a{};
 
constexpr struct PropB : public stdexec::__query<PropB> {
} prop_b{};
 
constexpr struct FwdPropC
    : public stdexec::__query<FwdPropC>
    , stdexec::forwarding_query_t {
    using stdexec::__query<FwdPropC>::operator();
} fwd_prop_c{};
 
constexpr struct FwdPropD
    : public stdexec::__query<FwdPropD>
    , stdexec::forwarding_query_t {
    using stdexec::__query<FwdPropD>::operator();
} fwd_prop_d{};

TEST(forwarding, queryable) {
    static_assert([]() {
        auto env = stdexec::env{
            stdexec::prop{    prop_a, 123},
            stdexec::prop{fwd_prop_c, 123}
        };
 
        static_assert(stdexec::__queryable_with<decltype(env), PropA>);
        static_assert(stdexec::__queryable_with<decltype(env), FwdPropC>);
 
        auto fwd_env = stdexec::__fwd_env(stdexec::__fwd_env(env));
 
        static_assert(
            std::same_as<
                decltype(fwd_env),
                stdexec::__env::__fwd<
                    stdexec::env<stdexec::prop<Tests::Impl::PropA, int>, stdexec::prop<Tests::Impl::FwdPropC, int>> &
                >
            >);
 
        static_assert(!stdexec::__queryable_with<decltype(fwd_env), PropA>);
        static_assert(stdexec::__queryable_with<decltype(fwd_env), FwdPropC>);
 
        return true;
    }());
}

TEST(upsert, set_prop_in_empty_env) {
    constexpr auto new_env = Kokkos::Execution::Impl::upsert_in_env(prop_a, stdexec::env<>{}, 42);
 
    static_assert(std::same_as<decltype(new_env), const stdexec::env<stdexec::prop<PropA, int>, stdexec::env<>>>);
 
    constexpr auto value = prop_a(new_env);
 
    static_assert(value == 42);
}

TEST(upsert, replace_prop_in_single_prop) {
    static_assert([]() {
        auto env = stdexec::prop{prop_a, 123};
 
        auto new_env = Kokkos::Execution::Impl::upsert_in_env(prop_a, env, 42.);
 
        auto value = prop_a(new_env);
 
        static_assert(std::same_as<decltype(new_env), stdexec::prop<Tests::Impl::PropA, double>>);
 
        return value == 42.;
    }());
}

TEST(upsert, replace_prop_in_env_with_single_prop) {
    static_assert([]() {
        auto env = stdexec::env{
            stdexec::prop{prop_a, 123},
        };
 
        auto new_env = Kokkos::Execution::Impl::upsert_in_env(prop_a, env, 42.);
 
        auto value = prop_a(new_env);
 
        static_assert(std::same_as<decltype(new_env), stdexec::env<stdexec::prop<Tests::Impl::PropA, double>>>);
 
        return value == 42.;
    }());
}

TEST(upsert, add_prop_to_another_prop) {
    static_assert([]() {
        auto env = stdexec::prop{prop_b, 123};
 
        auto new_env = Kokkos::Execution::Impl::upsert_in_env(prop_a, env, 42.);
 
        static_assert(std::same_as<
                      decltype(new_env),
                      stdexec::env<stdexec::prop<Tests::Impl::PropA, double>, stdexec::prop<Tests::Impl::PropB, int>>
        >);
 
        auto value = prop_a(new_env);
 
        return value == 42.;
    }());
}

TEST(upsert, replace_prop_in_env_with_two_props) {
    static_assert([]() {
        auto env = stdexec::env{
            stdexec::prop{prop_b, 123},
            stdexec::prop{prop_a, 123},
        };
 
        auto new_env = Kokkos::Execution::Impl::upsert_in_env(prop_a, env, 42.);
 
        static_assert(std::same_as<
                      decltype(new_env),
                      stdexec::env<stdexec::prop<Tests::Impl::PropB, int>, stdexec::prop<Tests::Impl::PropA, double>>
        >);
 
        auto value = prop_a(new_env);
 
        return value == 42.;
    }());
}

TEST(upsert, replace_prop_in_forwarding_env_with_two_props) {
    static_assert([]() {
        auto env = stdexec::__fwd_env(
            stdexec::env{
                stdexec::prop{fwd_prop_d, 123},
                stdexec::prop{fwd_prop_c, 123},
        });
 
        auto new_env = Kokkos::Execution::Impl::upsert_in_env(fwd_prop_c, env, 42.);
 
        static_assert(
            std::same_as<
                decltype(new_env),
                stdexec::__env::__fwd<
                    stdexec::env<stdexec::prop<Tests::Impl::FwdPropD, int>, stdexec::prop<Tests::Impl::FwdPropC, double>>
                >
            >);
 
        auto value = fwd_prop_c(new_env);
 
        return value == 42.;
    }());
}

TEST(upsert, add_prop_to_env_with_multiple_props) {
    static_assert([]() {
        auto env = stdexec::env{
            stdexec::prop{    prop_b, 123},
            stdexec::prop{fwd_prop_c, 456},
        };
 
        auto new_env = Kokkos::Execution::Impl::upsert_in_env(prop_a, env, 42.);
 
        static_assert(
            std::same_as<
                decltype(new_env),
                stdexec::env<
                    stdexec::prop<Tests::Impl::PropA, double>,
                    stdexec::env<stdexec::prop<Tests::Impl::PropB, int>, stdexec::prop<Tests::Impl::FwdPropC, int>>
                >
            >);
 
        return prop_a(new_env) == 42.;
    }());
}

TEST(upsert, add_fwd_prop_to_forwarding_env) {
    static_assert([]() {
        auto env = stdexec::__fwd_env(
            stdexec::env{
                stdexec::prop{fwd_prop_d, 123},
        });
 
        auto new_env = Kokkos::Execution::Impl::upsert_in_env(fwd_prop_c, env, 42.);
 
        static_assert(std::same_as<
                      decltype(new_env),
                      stdexec::env<
                          stdexec::prop<Tests::Impl::FwdPropC, double>,
                          stdexec::__env::__fwd<stdexec::env<stdexec::prop<Tests::Impl::FwdPropD, int>>>
                      >
        >);
 
        return fwd_prop_c(new_env) == 42.;
    }());
}

TEST(upsert, upsert_with_move_only) {
    static_assert([]() {
        auto env = stdexec::prop{prop_a, 123};
 
        struct MoveOnly : public stdexec::__move_only {
            int value;
            constexpr explicit MoveOnly(int value_)
                : value(value_) {
            }
        };
 
        auto new_env = Kokkos::Execution::Impl::upsert_in_env(prop_b, env, MoveOnly(42));
 
        static_assert(std::same_as<
                      decltype(new_env),
                      stdexec::env<stdexec::prop<Tests::Impl::PropB, MoveOnly>, stdexec::prop<Tests::Impl::PropA, int>>
        >);
 
        return prop_b(new_env).value == 42;
    }());
}

TEST(upsert, chain_multiple_upserts) {
    static_assert([]() {
        auto env = stdexec::env{
            stdexec::prop{prop_a, 1.},
        };
 
        auto new_env = Kokkos::Execution::Impl::upsert_in_env(
            prop_a,
            Kokkos::Execution::Impl::upsert_in_env(prop_a, Kokkos::Execution::Impl::upsert_in_env(prop_a, env, 2.), 3.),
            4.);
 
        static_assert(std::same_as<decltype(new_env), stdexec::env<stdexec::prop<Tests::Impl::PropA, double>>>);
 
        return prop_a(new_env) == 4.;
    }());
}

TEST(upsert, ref_join_upsert) {
    double fwd_prop_c_value = 42.;
 
    auto env = stdexec::prop{fwd_prop_c, std::ref(fwd_prop_c_value)};
    auto env_ref_join = stdexec::__env::__join(stdexec::prop{prop_b, 2}, stdexec::__fwd_env(env));
    const auto env_ref_join_upsert = Kokkos::Execution::Impl::upsert_in_env(prop_b, env_ref_join, 3.);
 
    static_assert(std::same_as<
                  decltype(env_ref_join),
                  stdexec::env<
                      stdexec::prop<Tests::Impl::PropB, int>,
                      stdexec::__env::__fwd<stdexec::prop<Tests::Impl::FwdPropC, double &> &>
                  >
    >);
 
    static_assert(std::same_as<
                  std::remove_const_t<decltype(env_ref_join_upsert)>,
                  stdexec::env<
                      stdexec::prop<Tests::Impl::PropB, double>,
                      stdexec::__env::__fwd<stdexec::prop<Tests::Impl::FwdPropC, double &> &>
                  >
    >);
 
    ASSERT_EQ(prop_b(env_ref_join_upsert), 3.);
    ASSERT_EQ(fwd_prop_c(env_ref_join_upsert), 42.);
 
    fwd_prop_c_value = 666.;
    ASSERT_EQ(fwd_prop_c(env_ref_join_upsert), 666.);
 
    env.__value = 3.14;
    ASSERT_EQ(fwd_prop_c(env_ref_join_upsert), 3.14);
}
 
} // namespace Tests::Impl