FlowManyTest.cpp File Reference

#include <array>
#include <type_traits>
#include <chrono>
#include <folly/experimental/pushmi/flow_many_sender.h>
#include <folly/experimental/pushmi/o/for_each.h>
#include <folly/experimental/pushmi/o/from.h>
#include <folly/experimental/pushmi/o/submit.h>
#include <folly/experimental/pushmi/entangle.h>
#include <folly/experimental/pushmi/new_thread.h>
#include <folly/experimental/pushmi/time_source.h>
#include <folly/experimental/pushmi/trampoline.h>
#include <folly/portability/GMock.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Classes
class	ImmediateFlowManySender
class	ConcurrentFlowManySender

Macros
#define	MAKE(x)   make_##x

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

Functions
	TEST_F (ImmediateFlowManySender, EarlyCancellation)
	TEST_F (ImmediateFlowManySender, LateCancellation)
auto	make_time (mi::time_source<> &t, NT &ex)
	TEST_F (ConcurrentFlowManySender, EarlyCancellation)
	TEST_F (ConcurrentFlowManySender, LateCancellation)
	TEST_F (ConcurrentFlowManySender, RacingCancellation)
	TEST (FlowManySender, From)

Macro Definition Documentation

#define MAKE

(

x

)

make_##x

Definition at line 46 of file FlowManyTest.cpp.

Referenced by ConcurrentFlowManySender::cancellation_test(), ImmediateFlowManySender::make_consumer(), ImmediateFlowManySender::make_producer(), and TEST().

Typedef Documentation

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

Definition at line 124 of file FlowManyTest.cpp.

Function Documentation

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

inline

Definition at line 126 of file FlowManyTest.cpp.

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

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

TEST	(	FlowManySender	,
		From
	)

Definition at line 293 of file FlowManyTest.cpp.

References testing::Eq(), EXPECT_THAT, f, folly::pushmi::operators::flow_from, for_each(), and MAKE.

                           {
  auto v = std::array<int, 5>{0, 1, 2, 3, 4};
  auto f = op::flow_from(v);

  int actual = 0;
  f | op::for_each(mi::MAKE(receiver)([&](int) { ++actual; }));

  EXPECT_THAT(actual, Eq(5)) << "expexcted that all the values are sent once";
}

TEST_F	(	ImmediateFlowManySender	,
		EarlyCancellation
	)

Definition at line 104 of file FlowManyTest.cpp.

References testing::Eq(), EXPECT_THAT, folly::pushmi::set_done, and submit.

                                                   {
  make_producer() | op::submit(make_consumer([](auto up) {
    // immediately stop producer
    ::mi::set_done(up);
  }));

  EXPECT_THAT(signals_, Eq(10011))
      << "expected that the starting, up.done and out.done signals are each recorded once";
}

TEST_F	(	ImmediateFlowManySender	,
		LateCancellation
	)

Definition at line 114 of file FlowManyTest.cpp.

References testing::Eq(), EXPECT_THAT, folly::pushmi::set_value, and submit.

                                                  {
  make_producer() | op::submit(make_consumer([](auto up) {
    // do not stop producer before it is scheduled to run
    ::mi::set_value(up, 1);
  }));

  EXPECT_THAT(signals_, Eq(1000111))
      << "expected that the starting, up.value, value and done signals are each recorded once";
}

TEST_F	(	ConcurrentFlowManySender	,
		EarlyCancellation
	)

Definition at line 240 of file FlowManyTest.cpp.

References testing::Eq(), EXPECT_THAT, and join.

                                                    {
  // this nightmare brought to you by ASAN stack-use-after-return.
  cancellation_test(at_ - 50ms);

  join();

  EXPECT_THAT(signals_, Eq(1010011))
      << "expected that the starting, up.done and out.done signals are each recorded once";
}

TEST_F	(	ConcurrentFlowManySender	,
		LateCancellation
	)

Definition at line 250 of file FlowManyTest.cpp.

References testing::Eq(), EXPECT_THAT, and join.

                                                   {
  // this nightmare brought to you by ASAN stack-use-after-return.
  cancellation_test(at_ + 50ms);

  join();

  EXPECT_THAT(signals_, Eq(1010111))
      << "expected that the starting, up.done and out.value signals are each recorded once";
}

TEST_F	(	ConcurrentFlowManySender	,
		RacingCancellation
	)

Definition at line 260 of file FlowManyTest.cpp.

References ASSERT_THAT, testing::Eq(), EXPECT_THAT, join, and testing::Lt().

                                                     {
  int total = 0;
  int cancellostrace = 0; // 1010111
  int cancelled = 0; // 1010011

  for (;;) {
    reset();
    cancellation_test(at_);

    // accumulate known signals
    ++total;
    cancellostrace += signals_ == 1010111;
    cancelled += signals_ == 1010011;

    EXPECT_THAT(total, Eq(cancellostrace + cancelled))
        << signals_ << " <- this set of signals is unrecognized";

    ASSERT_THAT(total, Lt(100))
        // too long, abort and show the signals distribution
        << "total " << total << ", cancel-lost-race " << cancellostrace
        << ", cancelled " << cancelled;

    if (cancellostrace > 4 && cancelled > 4) {
      // yay all known outcomes were observed!
      break;
    }
    // try again
    continue;
  }

  join();
}