ExecutorTest.cpp File Reference

#include <folly/executors/InlineExecutor.h>
#include <folly/executors/ManualExecutor.h>
#include <folly/executors/QueuedImmediateExecutor.h>
#include <folly/futures/Future.h>
#include <folly/portability/GTest.h>
#include <folly/synchronization/Baton.h>

Go to the source code of this file.

Classes
class	CrappyExecutor
class	DoNothingExecutor

Functions
	TEST (ManualExecutor, runIsStable)
	TEST (ManualExecutor, drainIsNotStable)
	TEST (ManualExecutor, scheduleDur)
	TEST (ManualExecutor, laterThingsDontBlockEarlierOnes)
	TEST (ManualExecutor, orderWillNotBeQuestioned)
	TEST (ManualExecutor, evenWhenYouSkipAheadEventsRunInProperOrder)
	TEST (ManualExecutor, clockStartsAt0)
	TEST (ManualExecutor, scheduleAbs)
	TEST (ManualExecutor, advanceTo)
	TEST (ManualExecutor, advanceBack)
	TEST (ManualExecutor, advanceNeg)
	TEST (ManualExecutor, waitForDoesNotDeadlock)
	TEST (ManualExecutor, getViaDoesNotDeadlock)
	TEST (ManualExecutor, clear)
	TEST (ManualExecutor, drainsOnDestruction)
	TEST (Executor, InlineExecutor)
	TEST (Executor, QueuedImmediateExecutor)
	TEST (Executor, Runnable)
	TEST (Executor, ThrowableThen)
	TEST (Executor, CrappyExecutor)
	TEST (Executor, DoNothingExecutor)

Function Documentation

TEST	(	ManualExecutor	,
		runIsStable
	)

Definition at line 29 of file ExecutorTest.cpp.

References folly::ManualExecutor::add(), folly::ManualExecutor::clear(), count, EXPECT_EQ, folly::ManualExecutor::run(), and x.

                                  {
  ManualExecutor x;
  size_t count = 0;
  auto f1 = [&]() { count++; };
  auto f2 = [&]() {
    x.add(f1);
    x.add(f1);
  };
  x.add(f2);
  x.run();
  EXPECT_EQ(count, 0);

  // ManualExecutor's destructor drains, so explicitly clear the two added by
  // f2.
  EXPECT_EQ(2, x.clear());
}

TEST	(	ManualExecutor	,
		drainIsNotStable
	)

Definition at line 46 of file ExecutorTest.cpp.

References folly::ManualExecutor::add(), count, folly::ManualExecutor::drain(), EXPECT_EQ, and x.

                                       {
  ManualExecutor x;
  size_t count = 0;
  auto f1 = [&]() { count++; };
  auto f2 = [&]() {
    x.add(f1);
    x.add(f1);
  };
  x.add(f2);
  x.drain();
  EXPECT_EQ(count, 2);
}

TEST	(	ManualExecutor	,
		scheduleDur
	)

Definition at line 59 of file ExecutorTest.cpp.

References folly::ManualExecutor::advance(), count, EXPECT_EQ, folly::ManualExecutor::run(), folly::ScheduledExecutor::schedule(), and x.

                                  {
  ManualExecutor x;
  size_t count = 0;
  std::chrono::milliseconds dur{10};
  x.schedule([&] { count++; }, dur);
  EXPECT_EQ(count, 0);
  x.run();
  EXPECT_EQ(count, 0);
  x.advance(dur / 2);
  EXPECT_EQ(count, 0);
  x.advance(dur / 2);
  EXPECT_EQ(count, 1);
}

TEST	(	ManualExecutor	,
		laterThingsDontBlockEarlierOnes
	)

Definition at line 73 of file ExecutorTest.cpp.

References folly::ManualExecutor::advance(), EXPECT_FALSE, EXPECT_TRUE, folly::gen::first, folly::ScheduledExecutor::schedule(), and x.

                                                      {
  ManualExecutor x;
  auto first = false;
  std::chrono::milliseconds dur{10};
  x.schedule([&] { first = true; }, dur);
  x.schedule([] {}, 2 * dur);
  EXPECT_FALSE(first);
  x.advance(dur);
  EXPECT_TRUE(first);
}

TEST	(	ManualExecutor	,
		orderWillNotBeQuestioned
	)

Definition at line 84 of file ExecutorTest.cpp.

References folly::ManualExecutor::advance(), EXPECT_FALSE, EXPECT_TRUE, folly::gen::first, folly::ScheduledExecutor::schedule(), and x.

                                               {
  ManualExecutor x;
  auto first = false;
  auto second = false;
  std::chrono::milliseconds dur{10};
  x.schedule([&] { first = true; }, dur);
  x.schedule([&] { second = true; }, 2 * dur);
  EXPECT_FALSE(first);
  EXPECT_FALSE(second);
  x.advance(dur);
  EXPECT_TRUE(first);
  EXPECT_FALSE(second);
  x.advance(dur);
  EXPECT_TRUE(first);
  EXPECT_TRUE(second);
}

TEST	(	ManualExecutor	,
		evenWhenYouSkipAheadEventsRunInProperOrder
	)

Definition at line 101 of file ExecutorTest.cpp.

References folly::ManualExecutor::advance(), counter, EXPECT_EQ, folly::gen::first, folly::ScheduledExecutor::schedule(), and x.

                                                                 {
  ManualExecutor x;
  auto counter = 0;
  auto first = 0;
  auto second = 0;
  std::chrono::milliseconds dur{10};
  x.schedule([&] { first = ++counter; }, dur);
  x.schedule([&] { second = ++counter; }, 2 * dur);
  EXPECT_EQ(first, 0);
  EXPECT_EQ(second, 0);
  x.advance(3 * dur);
  EXPECT_EQ(first, 1);
  EXPECT_EQ(second, 2);
}

TEST	(	ManualExecutor	,
		clockStartsAt0
	)

Definition at line 116 of file ExecutorTest.cpp.

References EXPECT_EQ, folly::ManualExecutor::now(), and x.

                                     {
  ManualExecutor x;
  EXPECT_EQ(x.now(), x.now().min());
}

TEST	(	ManualExecutor	,
		scheduleAbs
	)

Definition at line 121 of file ExecutorTest.cpp.

References folly::ManualExecutor::advance(), count, EXPECT_EQ, folly::ManualExecutor::now(), folly::ManualExecutor::scheduleAt(), and x.

                                  {
  ManualExecutor x;
  size_t count = 0;
  x.scheduleAt([&] { count++; }, x.now() + std::chrono::milliseconds(10));
  EXPECT_EQ(count, 0);
  x.advance(std::chrono::milliseconds(10));
  EXPECT_EQ(count, 1);
}

TEST	(	ManualExecutor	,
		advanceTo
	)

Definition at line 130 of file ExecutorTest.cpp.

References folly::ManualExecutor::advanceTo(), count, EXPECT_EQ, now(), folly::ManualExecutor::scheduleAt(), and x.

                                {
  ManualExecutor x;
  size_t count = 0;
  x.scheduleAt([&] { count++; }, std::chrono::steady_clock::now());
  EXPECT_EQ(count, 0);
  x.advanceTo(std::chrono::steady_clock::now());
  EXPECT_EQ(count, 1);
}

TEST	(	ManualExecutor	,
		advanceBack
	)

Definition at line 139 of file ExecutorTest.cpp.

References folly::ManualExecutor::advance(), folly::ManualExecutor::advanceTo(), count, EXPECT_EQ, folly::ManualExecutor::now(), folly::ScheduledExecutor::schedule(), and x.

                                  {
  ManualExecutor x;
  size_t count = 0;
  x.advance(std::chrono::microseconds(5));
  x.schedule([&] { count++; }, std::chrono::microseconds(6));
  EXPECT_EQ(count, 0);
  x.advanceTo(x.now() - std::chrono::microseconds(1));
  EXPECT_EQ(count, 0);
}

TEST	(	ManualExecutor	,
		advanceNeg
	)

Definition at line 149 of file ExecutorTest.cpp.

References folly::ManualExecutor::advance(), count, EXPECT_EQ, folly::ScheduledExecutor::schedule(), and x.

                                 {
  ManualExecutor x;
  size_t count = 0;
  x.advance(std::chrono::microseconds(5));
  x.schedule([&] { count++; }, std::chrono::microseconds(6));
  EXPECT_EQ(count, 0);
  x.advance(std::chrono::microseconds(-1));
  EXPECT_EQ(count, 0);
}

TEST	(	ManualExecutor	,
		waitForDoesNotDeadlock
	)

Definition at line 159 of file ExecutorTest.cpp.

References f, folly::makeFuture(), folly::Baton< MayBlock, Atom >::post(), folly::ManualExecutor::run(), folly::pushmi::detail::t, folly::via(), folly::Baton< MayBlock, Atom >::wait(), and folly::ManualExecutor::waitFor().

                                             {
  ManualExecutor east, west;
  folly::Baton<> baton;
  auto f = makeFuture()
               .via(&east)
               .then([](Try<Unit>) { return makeFuture(); })
               .via(&west);
  std::thread t([&] {
    baton.post();
    west.waitFor(f);
  });
  baton.wait();
  east.run();
  t.join();
}

TEST	(	ManualExecutor	,
		getViaDoesNotDeadlock
	)

Definition at line 175 of file ExecutorTest.cpp.

References f, folly::makeFuture(), folly::Baton< MayBlock, Atom >::post(), folly::ManualExecutor::run(), folly::pushmi::detail::t, folly::via(), and folly::Baton< MayBlock, Atom >::wait().

                                            {
  ManualExecutor east, west;
  folly::Baton<> baton;
  auto f = makeFuture()
               .via(&east)
               .then([](Try<Unit>) { return makeFuture(); })
               .via(&west);
  std::thread t([&] {
    baton.post();
    f.getVia(&west);
  });
  baton.wait();
  east.run();
  t.join();
}

TEST	(	ManualExecutor	,
		clear
	)

Definition at line 191 of file ExecutorTest.cpp.

References folly::ManualExecutor::add(), folly::ManualExecutor::advance(), folly::ManualExecutor::clear(), count, EXPECT_EQ, folly::ManualExecutor::now(), folly::ManualExecutor::run(), folly::ManualExecutor::scheduleAt(), and x.

                            {
  ManualExecutor x;
  size_t count = 0;
  x.add([&] { ++count; });
  x.scheduleAt([&] { ++count; }, x.now() + std::chrono::milliseconds(10));
  EXPECT_EQ(0, count);

  x.clear();
  x.advance(std::chrono::milliseconds(10));
  x.run();
  EXPECT_EQ(0, count);
}

TEST	(	ManualExecutor	,
		drainsOnDestruction
	)

Definition at line 204 of file ExecutorTest.cpp.

References folly::ManualExecutor::add(), count, EXPECT_EQ, and x.

                                          {
  size_t count = 0;
  {
    ManualExecutor x;
    x.add([&] { ++count; });
  }
  EXPECT_EQ(1, count);
}

TEST	(	Executor	,
		InlineExecutor
	)

Definition at line 213 of file ExecutorTest.cpp.

References folly::InlineExecutor::add(), counter, EXPECT_EQ, and x.

                               {
  InlineExecutor x;
  size_t counter = 0;
  x.add([&] {
    x.add([&] {
      EXPECT_EQ(counter, 0);
      counter++;
    });
    EXPECT_EQ(counter, 1);
    counter++;
  });
  EXPECT_EQ(counter, 2);
}

TEST	(	Executor	,
		QueuedImmediateExecutor
	)

Definition at line 227 of file ExecutorTest.cpp.

References folly::QueuedImmediateExecutor::add(), counter, EXPECT_EQ, and x.

                                        {
  QueuedImmediateExecutor x;
  size_t counter = 0;
  x.add([&] {
    x.add([&] {
      EXPECT_EQ(1, counter);
      counter++;
    });
    EXPECT_EQ(0, counter);
    counter++;
  });
  EXPECT_EQ(2, counter);
}

TEST	(	Executor	,
		Runnable
	)

Definition at line 241 of file ExecutorTest.cpp.

References folly::InlineExecutor::add(), counter, EXPECT_EQ, f, and x.

                         {
  InlineExecutor x;
  size_t counter = 0;
  struct Runnable {
    std::function<void()> fn;
    void operator()() {
      fn();
    }
  };
  Runnable f;
  f.fn = [&] { counter++; };
  x.add(f);
  EXPECT_EQ(counter, 1);
}

TEST	(	Executor	,
		ThrowableThen
	)

Definition at line 256 of file ExecutorTest.cpp.

References EXPECT_THROW, f, and x.

                              {
  InlineExecutor x;
  auto f = Future<Unit>().thenValue(
      [](auto&&) { throw std::runtime_error("Faildog"); });

  /*
  auto f = Future<Unit>().via(&x).then([](){
    throw std::runtime_error("Faildog");
  });*/
  EXPECT_THROW(f.value(), std::exception);
}

TEST	(	Executor	,
		CrappyExecutor
	)

Definition at line 275 of file ExecutorTest.cpp.

References EXPECT_STREQ, EXPECT_TRUE, f, flag, folly::via(), and x.

                               {
  CrappyExecutor x;
  bool flag = false;
  auto f = folly::via(&x).onError([&](std::runtime_error& e) {
    EXPECT_STREQ("bad", e.what());
    flag = true;
  });
  EXPECT_TRUE(flag);
}

TEST	(	Executor	,
		DoNothingExecutor
	)

Definition at line 295 of file ExecutorTest.cpp.

References DoNothingExecutor::add(), EXPECT_FALSE, EXPECT_THROW, EXPECT_TRUE, f, folly::gen::move, folly::via(), and x.

                                  {
  DoNothingExecutor x;

  // Submit future callback to DoNothingExecutor
  auto f = folly::via(&x).thenValue([](auto&&) { return 42; });

  // Callback function is stored in DoNothingExecutor, but not executed.
  EXPECT_FALSE(f.isReady());

  // Destroy the function stored in DoNothingExecutor. The future callback
  // will never get executed.
  x.add({});

  EXPECT_TRUE(f.isReady());
  EXPECT_THROW(std::move(f).get(), folly::BrokenPromise);
}