ViaTest.cpp File Reference

#include <thread>
#include <folly/MPMCQueue.h>
#include <folly/executors/DrivableExecutor.h>
#include <folly/executors/InlineExecutor.h>
#include <folly/executors/ManualExecutor.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
struct	ManualWaiter
struct	ViaFixture
struct	PriorityExecutor
class	ThreadExecutor
	Simple executor that does work in another thread. More...
class	DummyDrivableExecutor

Functions
	TEST (Via, exceptionOnLaunch)
	TEST (Via, thenValue)
	TEST (Via, thenFuture)
static Future< std::string >	doWorkStatic (Try< std::string > &&t)
	TEST (Via, thenFunction)
	TEST_F (ViaFixture, threadHops)
	TEST_F (ViaFixture, chainVias)
	TEST_F (ViaFixture, bareViaAssignment)
	TEST_F (ViaFixture, viaAssignment)
	TEST (Via, chain1)
	TEST (Via, chain3)
	TEST (Via, priority)
	TEST_F (ViaFixture, chainX1)
	TEST_F (ViaFixture, chainX3)
	TEST (Via, then2)
	TEST (Via, then2Variadic)
	TEST (Via, viaThenGetWasRacy)
	TEST (Via, callbackRace)
	TEST (Via, getVia)
	TEST (Via, SimpleTimedGetVia)
	TEST (Via, getTryVia)
	TEST (Via, SimpleTimedGetTryVia)
	TEST (Via, waitVia)
	TEST (Via, viaRaces)
	TEST (Via, viaDummyExecutorFutureSetValueFirst)
	TEST (Via, viaDummyExecutorFutureSetCallbackFirst)
	TEST (Via, viaExecutorDiscardsTaskFutureSetValueFirst)
	TEST (Via, viaExecutorDiscardsTaskFutureSetCallbackFirst)
	TEST (ViaFunc, liftsVoid)
	TEST (ViaFunc, value)
	TEST (ViaFunc, exception)
	TEST (ViaFunc, future)
	TEST (ViaFunc, semi_future)
	TEST (ViaFunc, voidFuture)
	TEST (ViaFunc, isSticky)
	TEST (ViaFunc, moveOnly)
	TEST (ViaFunc, valueKeepAlive)
	TEST (ViaFunc, thenValueKeepAlive)

Function Documentation

static Future<std::string> doWorkStatic ( Try< std::string > &&  t )

static

Definition at line 95 of file ViaTest.cpp.

References folly::makeFuture(), and folly::pushmi::detail::t.

Referenced by TEST().

                                                          {
  return makeFuture(t.value() + ";static");
}

TEST	(	Via	,
		exceptionOnLaunch
	)

Definition at line 76 of file ViaTest.cpp.

References EXPECT_THROW.

                             {
  auto future = makeFuture<int>(std::runtime_error("E"));
  EXPECT_THROW(future.value(), std::runtime_error);
}

TEST	(	Via	,
		thenValue
	)

Definition at line 81 of file ViaTest.cpp.

References EXPECT_TRUE, folly::makeFuture(), folly::gen::move, and folly::pushmi::detail::t.

                     {
  auto future = makeFuture(std::move(1)).then([](Try<int>&& t) {
    return t.value() == 1;
  });

  EXPECT_TRUE(future.value());
}

TEST	(	Via	,
		thenFuture
	)

Definition at line 89 of file ViaTest.cpp.

References EXPECT_TRUE, folly::makeFuture(), and folly::pushmi::detail::t.

                      {
  auto future = makeFuture(1).then(
      [](Try<int>&& t) { return makeFuture(t.value() == 1); });
  EXPECT_TRUE(future.value());
}

TEST	(	Via	,
		thenFunction
	)

Definition at line 99 of file ViaTest.cpp.

References doWork(), doWorkStatic(), EXPECT_EQ, f, folly::makeFuture(), string, and folly::pushmi::detail::t.

                        {
  struct Worker {
    Future<std::string> doWork(Try<std::string>&& t) {
      return makeFuture(t.value() + ";class");
    }
    static Future<std::string> doWorkStatic(Try<std::string>&& t) {
      return makeFuture(t.value() + ";class-static");
    }
  } w;

  auto f = makeFuture(std::string("start"))
               .then(doWorkStatic)
               .then(Worker::doWorkStatic)
               .then(&Worker::doWork, &w);

  EXPECT_EQ(f.value(), "start;static;class-static;class");
}

TEST	(	Via	,
		chain1
	)

Definition at line 174 of file ViaTest.cpp.

References EXPECT_EQ, and folly::makeFuture().

                  {
  EXPECT_EQ(42, makeFuture().thenMulti([] { return 42; }).get());
}

TEST	(	Via	,
		chain3
	)

Definition at line 178 of file ViaTest.cpp.

References count, EXPECT_EQ, f, folly::makeFuture(), folly::gen::move, and string.

                  {
  int count = 0;
  auto f = makeFuture().thenMulti(
      [&] {
        count++;
        return 3.14159;
      },
      [&](double) {
        count++;
        return std::string("hello");
      },
      [&] {
        count++;
        return makeFuture(42);
      });
  EXPECT_EQ(42, std::move(f).get());
  EXPECT_EQ(3, count);
}

TEST	(	Via	,
		priority
	)

Definition at line 225 of file ViaTest.cpp.

References PriorityExecutor::count0, PriorityExecutor::count1, PriorityExecutor::count2, exe, EXPECT_EQ, folly::Executor::HI_PRI, folly::Executor::LO_PRI, and folly::via().

                    {
  PriorityExecutor exe;
  via(&exe, -1).thenValue([](auto&&) {});
  via(&exe, 0).thenValue([](auto&&) {});
  via(&exe, 1).thenValue([](auto&&) {});
  via(&exe, 42).thenValue([](auto&&) {}); // overflow should go to max priority
  via(&exe, -42).thenValue(
      [](auto&&) {}); // underflow should go to min priority
  via(&exe).thenValue([](auto&&) {}); // default to mid priority
  via(&exe, Executor::LO_PRI).thenValue([](auto&&) {});
  via(&exe, Executor::HI_PRI).thenValue([](auto&&) {});
  EXPECT_EQ(3, exe.count0);
  EXPECT_EQ(2, exe.count1);
  EXPECT_EQ(3, exe.count2);
}

TEST	(	Via	,
		then2
	)

Definition at line 273 of file ViaTest.cpp.

References a, b, c, EXPECT_FALSE, EXPECT_TRUE, folly::ManualExecutor::run(), and folly::via().

                 {
  ManualExecutor x1, x2;
  bool a = false, b = false, c = false;
  via(&x1)
      .thenValue([&](auto&&) { a = true; })
      .then(&x2, [&](auto&&) { b = true; })
      .thenValue([&](auto&&) { c = true; });

  EXPECT_FALSE(a);
  EXPECT_FALSE(b);

  x1.run();
  EXPECT_TRUE(a);
  EXPECT_FALSE(b);
  EXPECT_FALSE(c);

  x2.run();
  EXPECT_TRUE(b);
  EXPECT_FALSE(c);

  x1.run();
  EXPECT_TRUE(c);
}

TEST	(	Via	,
		then2Variadic
	)

Definition at line 297 of file ViaTest.cpp.

References a, EXPECT_FALSE, EXPECT_TRUE, f, folly::foo, testing::gmock_matchers_test::foo, folly::makeFuture(), folly::ManualExecutor::run(), and x.

                         {
  struct Foo {
    bool a = false;
    void foo(Try<Unit>) {
      a = true;
    }
  };
  Foo f;
  ManualExecutor x;
  makeFuture().then(&x, &Foo::foo, &f);
  EXPECT_FALSE(f.a);
  x.run();
  EXPECT_TRUE(f.a);
}

TEST	(	Via	,
		viaThenGetWasRacy
	)

Definition at line 351 of file ViaTest.cpp.

References ASSERT_TRUE, EXPECT_EQ, val, folly::via(), and x.

                             {
  ThreadExecutor x;
  std::unique_ptr<int> val =
      folly::via(&x)
          .thenValue([](auto&&) { return std::make_unique<int>(42); })
          .get();
  ASSERT_TRUE(!!val);
  EXPECT_EQ(42, *val);
}

TEST	(	Via	,
		callbackRace
	)

Definition at line 361 of file ViaTest.cpp.

References ThreadExecutor::add(), folly::collectAll(), ThreadExecutor::waitForStartup(), and x.

                        {
  ThreadExecutor x;

  auto fn = [&x] {
    auto promises = std::make_shared<std::vector<Promise<Unit>>>(4);
    std::vector<Future<Unit>> futures;

    for (auto& p : *promises) {
      futures.emplace_back(p.getFuture().via(&x).then([](Try<Unit>&&) {}));
    }

    x.waitForStartup();
    x.add([promises] {
      for (auto& p : *promises) {
        p.setValue();
      }
    });

    return collectAll(futures);
  };

  fn().wait();
}

TEST	(	Via	,
		getVia
	)

Definition at line 395 of file ViaTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, f, folly::makeFuture(), DummyDrivableExecutor::ran, folly::via(), and x.

                  {
  {
    // non-void
    ManualExecutor x;
    auto f = via(&x).thenValue([](auto&&) { return true; });
    EXPECT_TRUE(f.getVia(&x));
  }

  {
    // void
    ManualExecutor x;
    auto f = via(&x).then();
    f.getVia(&x);
  }

  {
    DummyDrivableExecutor x;
    auto f = makeFuture(true);
    EXPECT_TRUE(f.getVia(&x));
    EXPECT_FALSE(x.ran);
  }
}

TEST	(	Via	,
		SimpleTimedGetVia
	)

Definition at line 418 of file ViaTest.cpp.

References EXPECT_THROW, f, and folly::Promise< T >::getFuture().

                             {
  TimedDrivableExecutor e2;
  Promise<folly::Unit> p;
  auto f = p.getFuture();
  EXPECT_THROW(f.getVia(&e2, std::chrono::seconds(1)), FutureTimeout);
}

TEST	(	Via	,
		getTryVia
	)

Definition at line 425 of file ViaTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, f, folly::makeFuture(), DummyDrivableExecutor::ran, folly::pushmi::detail::t, folly::via(), and x.

                     {
  {
    // non-void
    ManualExecutor x;
    auto f = via(&x).thenValue([](auto&&) { return 23; });
    EXPECT_FALSE(f.isReady());
    EXPECT_EQ(23, f.getTryVia(&x).value());
  }

  {
    // void
    ManualExecutor x;
    auto f = via(&x).then();
    EXPECT_FALSE(f.isReady());
    auto t = f.getTryVia(&x);
    EXPECT_TRUE(t.hasValue());
  }

  {
    DummyDrivableExecutor x;
    auto f = makeFuture(23);
    EXPECT_EQ(23, f.getTryVia(&x).value());
    EXPECT_FALSE(x.ran);
  }
}

TEST	(	Via	,
		SimpleTimedGetTryVia
	)

Definition at line 451 of file ViaTest.cpp.

References EXPECT_THROW, f, and folly::Promise< T >::getFuture().

                                {
  TimedDrivableExecutor e2;
  Promise<folly::Unit> p;
  auto f = p.getFuture();
  EXPECT_THROW(f.getTryVia(&e2, std::chrono::seconds(1)), FutureTimeout);
}

TEST	(	Via	,
		waitVia
	)

Definition at line 458 of file ViaTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, f, folly::makeFuture(), DummyDrivableExecutor::ran, folly::via(), and x.

                   {
  {
    ManualExecutor x;
    auto f = via(&x).then();
    EXPECT_FALSE(f.isReady());
    f.waitVia(&x);
    EXPECT_TRUE(f.isReady());
  }

  {
    // try rvalue as well
    ManualExecutor x;
    auto f = via(&x).then().waitVia(&x);
    EXPECT_TRUE(f.isReady());
  }

  {
    DummyDrivableExecutor x;
    makeFuture(true).waitVia(&x);
    EXPECT_FALSE(x.ran);
  }
}

TEST	(	Via	,
		viaRaces
	)

Definition at line 481 of file ViaTest.cpp.

References EXPECT_EQ, folly::Promise< T >::getFuture(), folly::ManualExecutor::run(), folly::Promise< T >::setValue(), and x.

                    {
  ManualExecutor x;
  Promise<Unit> p;
  auto tid = std::this_thread::get_id();
  bool done = false;

  std::thread t1([&] {
    p.getFuture()
        .via(&x)
        .then([&](Try<Unit>&&) { EXPECT_EQ(tid, std::this_thread::get_id()); })
        .then([&](Try<Unit>&&) { EXPECT_EQ(tid, std::this_thread::get_id()); })
        .then([&](Try<Unit>&&) { done = true; });
  });

  std::thread t2([&] { p.setValue(); });

  while (!done) {
    x.run();
  }
  t1.join();
  t2.join();
}

TEST	(	Via	,
		viaDummyExecutorFutureSetValueFirst
	)

Definition at line 504 of file ViaTest.cpp.

References c, EXPECT_THROW, folly::Promise< T >::getFuture(), folly::makeFuture(), folly::gen::move, and x.

                                               {
  // The callback object will get destroyed when passed to the executor.

  // A promise will be captured by the callback lambda so we can observe that
  // it will be destroyed.
  Promise<Unit> captured_promise;
  auto captured_promise_future = captured_promise.getFuture();

  DummyDrivableExecutor x;
  auto future = makeFuture().via(&x).thenValue(
      [c = std::move(captured_promise)](auto&&) { return 42; });

  EXPECT_THROW(std::move(future).get(std::chrono::seconds(5)), BrokenPromise);
  EXPECT_THROW(
      std::move(captured_promise_future).get(std::chrono::seconds(5)),
      BrokenPromise);
}

TEST	(	Via	,
		viaDummyExecutorFutureSetCallbackFirst
	)

Definition at line 522 of file ViaTest.cpp.

References c, EXPECT_THROW, folly::Promise< T >::getFuture(), folly::gen::move, folly::Promise< T >::setValue(), and x.

                                                  {
  // The callback object will get destroyed when passed to the executor.

  // A promise will be captured by the callback lambda so we can observe that
  // it will be destroyed.
  Promise<Unit> captured_promise;
  auto captured_promise_future = captured_promise.getFuture();

  DummyDrivableExecutor x;
  Promise<Unit> trigger;
  auto future = trigger.getFuture().via(&x).thenValue(
      [c = std::move(captured_promise)](auto&&) { return 42; });
  trigger.setValue();

  EXPECT_THROW(std::move(future).get(std::chrono::seconds(5)), BrokenPromise);
  EXPECT_THROW(
      std::move(captured_promise_future).get(std::chrono::seconds(5)),
      BrokenPromise);
}

TEST	(	Via	,
		viaExecutorDiscardsTaskFutureSetValueFirst
	)

Definition at line 542 of file ViaTest.cpp.

References c, folly::ManualExecutor::clear(), EXPECT_THROW, folly::Promise< T >::getFuture(), folly::makeFuture(), folly::gen::move, and x.

                                                      {
  // The callback object will get destroyed when the ManualExecutor runs out
  // of scope.

  // A promise will be captured by the callback lambda so we can observe that
  // it will be destroyed.
  Promise<Unit> captured_promise;
  auto captured_promise_future = captured_promise.getFuture();

  Optional<Future<int>> future;
  {
    ManualExecutor x;
    future = makeFuture().via(&x).thenValue(
        [c = std::move(captured_promise)](auto&&) { return 42; });
    x.clear();
  }

  EXPECT_THROW(std::move(*future).get(std::chrono::seconds(5)), BrokenPromise);
  EXPECT_THROW(
      std::move(captured_promise_future).get(std::chrono::seconds(5)),
      BrokenPromise);
}

TEST	(	Via	,
		viaExecutorDiscardsTaskFutureSetCallbackFirst
	)

Definition at line 565 of file ViaTest.cpp.

References c, folly::ManualExecutor::clear(), EXPECT_THROW, folly::Promise< T >::getFuture(), folly::gen::move, folly::Promise< T >::setValue(), and x.

                                                         {
  // The callback object will get destroyed when the ManualExecutor runs out
  // of scope.

  // A promise will be captured by the callback lambda so we can observe that
  // it will be destroyed.
  Promise<Unit> captured_promise;
  auto captured_promise_future = captured_promise.getFuture();

  Optional<Future<int>> future;
  {
    ManualExecutor x;
    Promise<Unit> trigger;
    future = trigger.getFuture().via(&x).thenValue(
        [c = std::move(captured_promise)](auto&&) { return 42; });
    trigger.setValue();
    x.clear();
  }

  EXPECT_THROW(std::move(*future).get(std::chrono::seconds(5)), BrokenPromise);
  EXPECT_THROW(
      std::move(captured_promise_future).get(std::chrono::seconds(5)),
      BrokenPromise);
}

TEST	(	ViaFunc	,
		liftsVoid
	)

Definition at line 590 of file ViaTest.cpp.

References count, EXPECT_EQ, f, folly::ManualExecutor::run(), folly::via(), and x.

                         {
  ManualExecutor x;
  int count = 0;
  Future<Unit> f = via(&x, [&] { count++; });

  EXPECT_EQ(0, count);
  x.run();
  EXPECT_EQ(1, count);
}

TEST	(	ViaFunc	,
		value
	)

Definition at line 600 of file ViaTest.cpp.

References EXPECT_EQ, folly::via(), and x.

                     {
  ManualExecutor x;
  EXPECT_EQ(42, via(&x, [] { return 42; }).getVia(&x));
}

TEST	(	ViaFunc	,
		exception
	)

Definition at line 605 of file ViaTest.cpp.

References EXPECT_THROW, folly::via(), and x.

                         {
  ManualExecutor x;
  EXPECT_THROW(
      via(&x, []() -> int { throw std::runtime_error("expected"); }).getVia(&x),
      std::runtime_error);
}

TEST	(	ViaFunc	,
		future
	)

Definition at line 612 of file ViaTest.cpp.

References EXPECT_EQ, folly::makeFuture(), folly::via(), and x.

                      {
  ManualExecutor x;
  EXPECT_EQ(42, via(&x, [] { return makeFuture(42); }).getVia(&x));
}

TEST	(	ViaFunc	,
		semi_future
	)

Definition at line 617 of file ViaTest.cpp.

References EXPECT_EQ, folly::makeSemiFuture(), folly::via(), and x.

                           {
  ManualExecutor x;
  EXPECT_EQ(42, via(&x, [] { return makeSemiFuture(42); }).getVia(&x));
}

TEST	(	ViaFunc	,
		voidFuture
	)

Definition at line 622 of file ViaTest.cpp.

References count, EXPECT_EQ, folly::via(), and x.

                          {
  ManualExecutor x;
  int count = 0;
  via(&x, [&] { count++; }).getVia(&x);
  EXPECT_EQ(1, count);
}

TEST	(	ViaFunc	,
		isSticky
	)

Definition at line 629 of file ViaTest.cpp.

References count, EXPECT_EQ, f, folly::gen::move, folly::ManualExecutor::run(), folly::via(), and x.

                        {
  ManualExecutor x;
  int count = 0;

  auto f = via(&x, [&] { count++; });
  x.run();

  std::move(f).thenValue([&](auto&&) { count++; });
  EXPECT_EQ(1, count);
  x.run();
  EXPECT_EQ(2, count);
}

TEST	(	ViaFunc	,
		moveOnly
	)

Definition at line 642 of file ViaTest.cpp.

References EXPECT_EQ, folly::gen::move, folly::via(), and x.

                        {
  ManualExecutor x;
  auto intp = std::make_unique<int>(42);

  EXPECT_EQ(42, via(&x, [intp = std::move(intp)] { return *intp; }).getVia(&x));
}

TEST	(	ViaFunc	,
		valueKeepAlive
	)

Definition at line 649 of file ViaTest.cpp.

References EXPECT_EQ, folly::getKeepAliveToken(), folly::via(), and x.

                              {
  ManualExecutor x;
  EXPECT_EQ(42, via(getKeepAliveToken(&x), [] { return 42; }).getVia(&x));
}

TEST	(	ViaFunc	,
		thenValueKeepAlive
	)

Definition at line 654 of file ViaTest.cpp.

References EXPECT_EQ, folly::getKeepAliveToken(), folly::via(), and x.

                                  {
  ManualExecutor x;
  EXPECT_EQ(
      42,
      via(getKeepAliveToken(&x))
          .thenValue([](auto&&) { return 42; })
          .getVia(&x));
}

TEST_F	(	ViaFixture	,
		threadHops
	)

Definition at line 117 of file ViaTest.cpp.

References EXPECT_EQ, EXPECT_NE, f, folly::pushmi::detail::t, and folly::via().

                               {
  auto westThreadId = std::this_thread::get_id();
  auto f = via(eastExecutor.get())
               .then([=](Try<Unit>&& /* t */) {
                 EXPECT_NE(std::this_thread::get_id(), westThreadId);
                 return makeFuture<int>(1);
               })
               .via(westExecutor.get())
               .then([=](Try<int>&& t) {
                 EXPECT_EQ(std::this_thread::get_id(), westThreadId);
                 return t.value();
               });
  EXPECT_EQ(f.getVia(waiter.get()), 1);
}

TEST_F	(	ViaFixture	,
		chainVias
	)

Definition at line 132 of file ViaTest.cpp.

References EXPECT_EQ, EXPECT_NE, f, folly::makeFuture(), val, and folly::via().

                              {
  auto westThreadId = std::this_thread::get_id();
  auto f = via(eastExecutor.get())
               .thenValue([=](auto&&) {
                 EXPECT_NE(std::this_thread::get_id(), westThreadId);
                 return 1;
               })
               .then([=](int val) {
                 return makeFuture(val)
                     .via(westExecutor.get())
                     .then([=](int v) mutable {
                       EXPECT_EQ(std::this_thread::get_id(), westThreadId);
                       return v + 1;
                     });
               })
               .then([=](int val) {
                 // even though ultimately the future that triggers this one
                 // executed in the west thread, this then() inherited the
                 // executor from its predecessor, ie the eastExecutor.
                 EXPECT_NE(std::this_thread::get_id(), westThreadId);
                 return val + 1;
               })
               .via(westExecutor.get())
               .then([=](int val) {
                 // go back to west, so we can wait on it
                 EXPECT_EQ(std::this_thread::get_id(), westThreadId);
                 return val + 1;
               });

  EXPECT_EQ(f.getVia(waiter.get()), 4);
}

TEST_F	(	ViaFixture	,
		bareViaAssignment
	)

Definition at line 164 of file ViaTest.cpp.

References f, and folly::via().

                                      {
  auto f = via(eastExecutor.get());
}

TEST_F	(	ViaFixture	,
		viaAssignment
	)

Definition at line 167 of file ViaTest.cpp.

References f, and folly::makeFuture().

                                  {
  // via()&&
  auto f = makeFuture().via(eastExecutor.get());
  // via()&
  auto f2 = f.via(eastExecutor.get());
}

TEST_F	(	ViaFixture	,
		chainX1
	)

Definition at line 241 of file ViaTest.cpp.

References EXPECT_EQ, and folly::makeFuture().

                            {
  EXPECT_EQ(
      42,
      makeFuture()
          .thenMultiWithExecutor(eastExecutor.get(), [] { return 42; })
          .get());
}

TEST_F	(	ViaFixture	,
		chainX3
	)

Definition at line 249 of file ViaTest.cpp.

References count, EXPECT_EQ, EXPECT_NE, f, folly::makeFuture(), string, and folly::via().

                            {
  auto westThreadId = std::this_thread::get_id();
  int count = 0;
  auto f = via(westExecutor.get())
               .thenMultiWithExecutor(
                   eastExecutor.get(),
                   [&] {
                     EXPECT_NE(std::this_thread::get_id(), westThreadId);
                     count++;
                     return 3.14159;
                   },
                   [&](double) {
                     count++;
                     return std::string("hello");
                   },
                   [&] { count++; })
               .thenValue([&](auto&&) {
                 EXPECT_EQ(std::this_thread::get_id(), westThreadId);
                 return makeFuture(42);
               });
  EXPECT_EQ(42, f.getVia(waiter.get()));
  EXPECT_EQ(3, count);
}