TrampolineTest.cpp File Reference

#include <type_traits>
#include <chrono>
#include <folly/experimental/pushmi/flow_single_sender.h>
#include <folly/experimental/pushmi/o/empty.h>
#include <folly/experimental/pushmi/o/extension_operators.h>
#include <folly/experimental/pushmi/o/just.h>
#include <folly/experimental/pushmi/o/on.h>
#include <folly/experimental/pushmi/o/submit.h>
#include <folly/experimental/pushmi/o/tap.h>
#include <folly/experimental/pushmi/o/transform.h>
#include <folly/experimental/pushmi/o/via.h>
#include <folly/experimental/pushmi/inline.h>
#include <folly/experimental/pushmi/trampoline.h>
#include <folly/Conv.h>
#include <folly/portability/GMock.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Classes
struct	countdownsingle
class	TrampolineExecutor

Typedefs
using	TR = decltype(mi::trampoline())

Functions
	TEST_F (TrampolineExecutor, TransformAndSubmit)
	TEST_F (TrampolineExecutor, BlockingGet)
	TEST_F (TrampolineExecutor, VirtualDerecursion)
	TEST_F (TrampolineExecutor, StaticDerecursion)
	TEST_F (TrampolineExecutor, UsedWithOn)
	TEST_F (TrampolineExecutor, UsedWithVia)

Typedef Documentation

using TR = decltype(mi::trampoline())

Definition at line 57 of file TrampolineTest.cpp.

Function Documentation

TEST_F	(	TrampolineExecutor	,
		TransformAndSubmit
	)

Definition at line 64 of file TrampolineTest.cpp.

References testing::Eq(), EXPECT_THAT, folly::pushmi::__adl::noexcept(), submit, and folly::pushmi::operators::transform.

                                               {
  auto signals = 0;
  tr_ | op::transform([](auto) { return 42; }) |
      op::submit(
          [&](auto) { signals += 100; },
          [&](auto) noexcept { signals += 1000; },
          [&]() { signals += 10; });

  EXPECT_THAT(signals, Eq(110))
      << "expected that the value and done signals are each recorded once";
}

TEST_F	(	TrampolineExecutor	,
		BlockingGet
	)

Definition at line 76 of file TrampolineTest.cpp.

References testing::Eq(), EXPECT_THAT, and folly::pushmi::operators::transform.

                                        {
  auto v = tr_ | op::transform([](auto) { return 42; }) | op::get<int>;

  EXPECT_THAT(v, Eq(42)) << "expected that the result would be different";
}

TEST_F	(	TrampolineExecutor	,
		VirtualDerecursion
	)

Definition at line 82 of file TrampolineTest.cpp.

References counter.

                                               {
  int counter = 100'000;
  std::function<void(::folly::pushmi::any_executor_ref<> exec)> recurse;
  recurse = [&](::folly::pushmi::any_executor_ref<> tr) {
    if (--counter <= 0)
      return;
    tr | op::submit(recurse);
  };
  tr_ | op::submit([&](auto exec) { recurse(exec); });

  EXPECT_THAT(counter, Eq(0))
      << "expected that all nested submissions complete";
}

TEST_F	(	TrampolineExecutor	,
		StaticDerecursion
	)

Definition at line 96 of file TrampolineTest.cpp.

References testing::Eq(), EXPECT_THAT, single, and submit.

                                              {
  int counter = 100'000;
  countdownsingle single{counter};
  tr_ | op::submit(single);

  EXPECT_THAT(counter, Eq(0))
      << "expected that all nested submissions complete";
}

TEST_F	(	TrampolineExecutor	,
		UsedWithOn
	)

Definition at line 105 of file TrampolineTest.cpp.

References testing::ElementsAre(), testing::Eq(), EXPECT_THAT, folly::pushmi::inline_executor(), folly::pushmi::make_single_sender, max, min, folly::pushmi::operators::on, folly::pushmi::on_value(), folly::pushmi::set_done, folly::pushmi::set_value, submit, value, and values().

                                       {
  std::vector<std::string> values;
  auto sender = ::folly::pushmi::make_single_sender([](auto out) {
    ::folly::pushmi::set_value(out, 2.0);
    ::folly::pushmi::set_done(out);
    // ignored
    ::folly::pushmi::set_value(out, 1);
    ::folly::pushmi::set_value(out, std::numeric_limits<int8_t>::min());
    ::folly::pushmi::set_value(out, std::numeric_limits<int8_t>::max());
  });
  auto inlineon = sender | op::on([&]() { return mi::inline_executor(); });
  inlineon | op::submit(v::on_value([&](auto v) {
    values.push_back(folly::to<std::string>(v));
  }));

  EXPECT_THAT(values, ElementsAre(folly::to<std::string>(2.0)))
      << "expected that only the first item was pushed";

  EXPECT_THAT(
      (std::is_same<
          mi::executor_t<decltype(sender)>,
          mi::executor_t<decltype(inlineon)>>::value),
      Eq(true))
      << "expected that executor was not changed by on";
}

TEST_F	(	TrampolineExecutor	,
		UsedWithVia
	)

Definition at line 131 of file TrampolineTest.cpp.

References testing::ElementsAre(), testing::Eq(), EXPECT_THAT, folly::pushmi::inline_executor(), folly::pushmi::make_single_sender, max, min, folly::pushmi::on_value(), folly::pushmi::set_done, folly::pushmi::set_value, submit, value, values(), and folly::pushmi::operators::via.

                                        {
  std::vector<std::string> values;
  auto sender = ::folly::pushmi::make_single_sender([](auto out) {
    ::folly::pushmi::set_value(out, 2.0);
    ::folly::pushmi::set_done(out);
    // ignored
    ::folly::pushmi::set_value(out, 1);
    ::folly::pushmi::set_value(out, std::numeric_limits<int8_t>::min());
    ::folly::pushmi::set_value(out, std::numeric_limits<int8_t>::max());
  });
  auto inlinevia = sender | op::via([&]() { return mi::inline_executor(); });
  inlinevia | op::submit(v::on_value([&](auto v) {
    values.push_back(folly::to<std::string>(v));
  }));

  EXPECT_THAT(values, ElementsAre(folly::to<std::string>(2.0)))
      << "expected that only the first item was pushed";

  EXPECT_THAT(
      (!std::is_same<
          mi::executor_t<decltype(sender)>,
          mi::executor_t<decltype(inlinevia)>>::value),
      Eq(true))
      << "expected that executor was changed by via";
}