test_get_start_scheduler.cpp

Go to the documentation of this file.

#include "gtest/gtest.h"
 
#include <thread>
 
#include "kokkos-execution/utils/ignore_warnings.hpp"
PRAGMA_DIAGNOSTIC_PUSH
KOKKOS_EXECUTION_STDEXEC_PRAGMA_DIAGNOSTIC_IGNORED
#include "exec/static_thread_pool.hpp"
PRAGMA_DIAGNOSTIC_POP
 
#include "kokkos-execution/stdexec.hpp"
 
#include "tests/utils/functors/store_thread_id.hpp"

 
namespace Tests {
 
consteval bool test_is_forwarding_query() {
    return stdexec::forwarding_query(stdexec::get_start_scheduler);
}
 
static_assert(test_is_forwarding_query());

TEST(get_start_scheduler, sync_wait) {
    std::thread::id tid;
 
    auto sndr_read_env_start_sch = stdexec::read_env(stdexec::get_start_scheduler) | stdexec::let_value([&](auto schd) {
                                       static_assert(std::same_as<decltype(schd), stdexec::run_loop::scheduler>);
                                       return stdexec::schedule(schd) | THEN_STORE_THREAD_ID(&tid);
                                   });
 
    stdexec::sync_wait(std::move(sndr_read_env_start_sch)); // NOLINT(performance-move-const-arg)
 
    ASSERT_EQ(tid, std::this_thread::get_id());

    auto sndr_read_env_delegation_sch = stdexec::read_env(stdexec::get_delegation_scheduler)
                                      | stdexec::let_value([&](auto schd) {
                                            static_assert(std::same_as<decltype(schd), stdexec::run_loop::scheduler>);
                                            return stdexec::schedule(schd) | THEN_STORE_THREAD_ID(&tid);
                                        });
 
    stdexec::sync_wait(std::move(sndr_read_env_delegation_sch)); // NOLINT(performance-move-const-arg)
 
    ASSERT_EQ(tid, std::this_thread::get_id());
}

TEST(get_start_scheduler, let_value) {
    std::thread::id pool_tid, tid;
 
    experimental::execution::static_thread_pool pool{1};
 
    auto sndr = stdexec::schedule(pool.get_scheduler()) | THEN_STORE_THREAD_ID(&pool_tid) | stdexec::let_value([&]() {
                    return stdexec::read_env(stdexec::get_start_scheduler) | stdexec::let_value([&](auto schd) {
                               static_assert(std::same_as<decltype(schd), decltype(pool.get_scheduler())>);
                               return stdexec::schedule(schd) | THEN_STORE_THREAD_ID(&tid);
                           });
                });
 
    stdexec::sync_wait(std::move(sndr)); // NOLINT(performance-move-const-arg)
 
    ASSERT_EQ(tid, pool_tid);
    ASSERT_NE(tid, std::this_thread::get_id());
}

TEST(get_start_scheduler, continues_on) {
    std::thread::id pool_tid, tid;
 
    experimental::execution::static_thread_pool pool{1};
 
    auto sndr = stdexec::schedule(pool.get_scheduler()) | THEN_STORE_THREAD_ID(&pool_tid)
              | stdexec::continues_on(stdexec::inline_scheduler{}) | THEN_STORE_THREAD_ID(&tid);
 
    static_assert(std::same_as<
                  stdexec::__completion_scheduler_of_t<
                      stdexec::set_value_t,
                      decltype(sndr),
                      stdexec::prop<stdexec::get_start_scheduler_t, stdexec::run_loop::scheduler>
                  >,
                  decltype(pool.get_scheduler())
    >);
 
    stdexec::sync_wait(std::move(sndr)); // NOLINT(performance-move-const-arg)
 
    ASSERT_EQ(tid, pool_tid);
    ASSERT_NE(tid, std::this_thread::get_id());
}

TEST(get_start_scheduler, continues_on_error_completion) {
    experimental::execution::static_thread_pool pool{1};
    std::thread::id pool_tid, tid;
 
    auto sndr = stdexec::schedule(pool.get_scheduler()) | THEN_STORE_THREAD_ID(&pool_tid)
              | stdexec::then([]() { throw std::runtime_error{"error"}; })
              | stdexec::continues_on(stdexec::inline_scheduler{});
 
    static_assert(std::same_as<
                  stdexec::__completion_scheduler_of_t<
                      stdexec::set_error_t,
                      decltype(sndr),
                      stdexec::prop<stdexec::get_start_scheduler_t, stdexec::run_loop::scheduler>
                  >,
                  decltype(pool.get_scheduler())
    >);
 
    auto sndr_with_upon_error = std::move(sndr) // NOLINT(performance-move-const-arg)
                              | UPON_ERROR_STORE_THREAD_ID(&tid);
 
    static_assert(stdexec::__never_sends<
                  stdexec::set_error_t,
                  decltype(sndr_with_upon_error),
                  stdexec::prop<stdexec::get_start_scheduler_t, stdexec::run_loop::scheduler>
    >);
 
    static_assert(std::same_as<
                  stdexec::__completion_scheduler_of_t<
                      stdexec::set_value_t,
                      decltype(sndr_with_upon_error),
                      stdexec::prop<stdexec::get_start_scheduler_t, stdexec::run_loop::scheduler>
                  >,
                  decltype(pool.get_scheduler())
    >);
 
    stdexec::sync_wait(std::move(sndr_with_upon_error)); // NOLINT(performance-move-const-arg)
 
    ASSERT_EQ(tid, pool_tid);
    ASSERT_NE(tid, std::this_thread::get_id());
}
 
} // namespace Tests