NewThreadTest.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/new_thread.h>
#include <folly/experimental/pushmi/strand.h>
#include <folly/experimental/pushmi/time_source.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	NewthreadExecutor

Typedefs
using	NT = decltype(mi::new_thread())

Functions
auto	make_time (mi::time_source<> &t, NT &ex)
	TEST_F (NewthreadExecutor, BlockingSubmitNow)
	TEST_F (NewthreadExecutor, BlockingGetNow)
	TEST_F (NewthreadExecutor, SubmissionsAreOrderedInTime)
	TEST_F (NewthreadExecutor, NowIsCalled)
	TEST_F (NewthreadExecutor, BlockingSubmit)
	TEST_F (NewthreadExecutor, BlockingGet)
	TEST_F (NewthreadExecutor, VirtualDerecursion)
	TEST_F (NewthreadExecutor, StaticDerecursion)
	TEST_F (NewthreadExecutor, UsedWithOn)
	TEST_F (NewthreadExecutor, UsedWithVia)

Typedef Documentation

using NT = decltype(mi::new_thread())

Definition at line 58 of file NewThreadTest.cpp.

Function Documentation

auto make_time ( mi::time_source<> &  t, NT &  ex  )

inline

Definition at line 60 of file NewThreadTest.cpp.

References folly::pushmi::time_source< E, TP >::make().

                                                  {
  return t.make(mi::systemNowF{}, [ex]() { return ex; })();
}

TEST_F	(	NewthreadExecutor	,
		BlockingSubmitNow
	)

Definition at line 78 of file NewThreadTest.cpp.

References folly::pushmi::operators::blocking_submit, testing::Eq(), EXPECT_THAT, testing::Lt(), folly::pushmi::__adl::noexcept(), now(), start, and folly::pushmi::operators::transform.

                                             {
  auto signals = 0;
  auto start = v::now(tnt_);
  auto signaled = start;
  tnt_ | op::transform([](auto tnt) { return tnt | ep::now(); }) |
      op::blocking_submit(
          [&](auto at) {
            signaled = at;
            signals += 100;
          },
          [&](auto) noexcept { signals += 1000; },
          [&]() { signals += 10; });

  EXPECT_THAT(signals, Eq(110))
      << "expected that the value and done signals are recorded once and the value signal did not drift much";
  auto delay =
      std::chrono::duration_cast<std::chrono::milliseconds>((signaled - start))
          .count();
  EXPECT_THAT(delay, Lt(1000)) << "The delay is " << delay;
}

TEST_F	(	NewthreadExecutor	,
		BlockingGetNow
	)

Definition at line 99 of file NewThreadTest.cpp.

References EXPECT_THAT, testing::Lt(), now(), start, and folly::pushmi::operators::transform.

                                          {
  auto start = v::now(tnt_);
  auto signaled = tnt_ | op::transform([](auto tnt) { return v::now(tnt); }) |
      op::get<std::chrono::system_clock::time_point>;

  auto delay =
      std::chrono::duration_cast<std::chrono::milliseconds>((signaled - start))
          .count();

  EXPECT_THAT(delay, Lt(1000)) << "The delay is " << delay;
}

TEST_F	(	NewthreadExecutor	,
		SubmissionsAreOrderedInTime
	)

Definition at line 111 of file NewThreadTest.cpp.

References testing::ElementsAre(), EXPECT_THAT, now(), folly::pushmi::on_value(), submit, folly::pushmi::operators::submit_after, folly::pushmi::operators::submit_at, folly::detail::distributed_mutex::time(), folly::times(), and folly::fibers::yield().

                                                       {
  std::vector<std::string> times;
  std::atomic<int> pushed{0};
  auto push = [&](int time) {
    return v::on_value([&, time](auto) {
      times.push_back(folly::to<std::string>(time));
      ++pushed;
    });
  };
  tnt_ | op::submit(v::on_value([push](auto tnt) {
    auto now = tnt | ep::now();
    tnt | op::submit_after(40ms, push(40)) |
        op::submit_at(now + 10ms, push(10)) | op::submit_after(20ms, push(20)) |
        op::submit_at(now + 10ms, push(11));
  }));

  while (pushed.load() < 4) {
    std::this_thread::yield();
  }

  EXPECT_THAT(times, ElementsAre("10", "11", "20", "40"))
      << "expected that the items were pushed in time order not insertion order";
}

TEST_F	(	NewthreadExecutor	,
		NowIsCalled
	)

Definition at line 135 of file NewThreadTest.cpp.

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

                                       {
  bool done = false;
  tnt_ | ep::now();
  tnt_ | op::blocking_submit([&](auto tnt) {
    tnt | ep::now();
    done = true;
  });

  EXPECT_THAT(done, Eq(true)) << "exptected that both calls to now() complete";
}

TEST_F	(	NewthreadExecutor	,
		BlockingSubmit
	)

Definition at line 146 of file NewThreadTest.cpp.

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

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

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

TEST_F	(	NewthreadExecutor	,
		BlockingGet
	)

Definition at line 158 of file NewThreadTest.cpp.

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

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

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

TEST_F	(	NewthreadExecutor	,
		VirtualDerecursion
	)

Definition at line 164 of file NewThreadTest.cpp.

References counter.

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

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

TEST_F	(	NewthreadExecutor	,
		StaticDerecursion
	)

Definition at line 178 of file NewThreadTest.cpp.

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

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

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

TEST_F	(	NewthreadExecutor	,
		UsedWithOn
	)

Definition at line 187 of file NewThreadTest.cpp.

References folly::pushmi::operators::blocking_submit, testing::ElementsAre(), EXPECT_THAT, folly::pushmi::make_single_sender, max, min, folly::pushmi::operators::on, folly::pushmi::on_value(), folly::pushmi::set_done, folly::pushmi::set_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());
  });
  sender | op::on([&]() { return nt_; }) |
      op::blocking_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";
}

TEST_F	(	NewthreadExecutor	,
		UsedWithVia
	)

Definition at line 205 of file NewThreadTest.cpp.

References folly::pushmi::operators::blocking_submit, testing::ElementsAre(), EXPECT_THAT, folly::pushmi::make_single_sender, max, min, folly::pushmi::on_value(), folly::pushmi::set_done, folly::pushmi::set_value, folly::pushmi::strands(), 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());
  });
  sender | op::via(mi::strands(nt_)) |
      op::blocking_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";
}