FutureTest.cpp File Reference

#include <folly/futures/Future.h>
#include <folly/Executor.h>
#include <folly/Memory.h>
#include <folly/Unit.h>
#include <folly/dynamic.h>
#include <folly/executors/ManualExecutor.h>
#include <folly/portability/GTest.h>
#include <folly/synchronization/Baton.h>
#include <algorithm>
#include <atomic>
#include <memory>
#include <numeric>
#include <queue>
#include <string>
#include <thread>
#include <type_traits>

Go to the source code of this file.

Macros
#define	EXPECT_TYPE(x, T)   EXPECT_TRUE((std::is_same<decltype(x), T>::value))
#define	DOIT(CREATION_EXPR)
#define	DOIT(CREATION_EXPR)
#define	DOIT(STMT)
#define	DOIT(STMT)
#define	DOIT(STMT)
#define	DOIT(CTOR, STMT)
#define	EXPECT_FLAG()
#define	EXPECT_NO_FLAG()
#define	EXPECT_FLAG()
#define	EXPECT_NO_FLAG()

Typedefs
typedef FutureException	eggs_t

Functions
	TEST (Future, makeEmpty)
	TEST (Future, futureDefaultCtor)
	TEST (Future, futureToUnit)
	TEST (Future, voidFutureToUnit)
	TEST (Future, unitFutureToUnitIdentity)
	TEST (Future, toUnitWhileInProgress)
	TEST (Future, makeFutureWithUnit)
	TEST (Future, getRequiresOnlyMoveCtor)
	TEST (Future, ctorPostconditionValid)
	TEST (Future, ctorPostconditionInvalid)
	TEST (Future, lacksPreconditionValid)
	TEST (Future, hasPreconditionValid)
	TEST (Future, hasPostconditionValid)
	TEST (Future, hasPostconditionInvalid)
	TEST (Future, onError)
	TEST (Future, thenError)
	TEST (Future, special)
	TEST (Future, then)
static folly::Future< std::string >	doWorkStaticTry (Try< std::string > &&t)
	TEST (Future, thenTrythenValue)
	TEST (Future, thenTry)
	TEST (Future, thenValue)
	TEST (Future, thenValueFuture)
static std::string	doWorkStatic (Try< std::string > &&t)
static std::string	doWorkStaticValue (std::string &&t)
	TEST (Future, thenFunction)
static Future< std::string >	doWorkStaticFuture (Try< std::string > &&t)
	TEST (Future, thenFunctionFuture)
	TEST (Future, thenStdFunction)
	TEST (Future, thenBind)
	TEST (Future, thenBindTry)
	TEST (Future, value)
	TEST (Future, isReady)
	TEST (Future, futureNotReady)
	TEST (Future, hasException)
	TEST (Future, hasValue)
	TEST (Future, makeFuture)
	TEST (Future, finish)
	TEST (Future, finishBigLambda)
	TEST (Future, unwrap)
	TEST (Future, throwCaughtInImmediateThen)
	TEST (Future, throwIfFailed)
	TEST (Future, getFutureAfterSetValue)
	TEST (Future, getFutureAfterSetException)
	TEST (Future, detachRace)
	TEST (Future, CircularDependencySharedPtrSelfReset)
	TEST (Future, Constructor)
	TEST (Future, ImplicitConstructor)
	TEST (Future, InPlaceConstructor)
	TEST (Future, thenDynamic)
	TEST (Future, RequestContext)
	TEST (Future, makeFutureNoThrow)
	TEST (Future, invokeCallbackReturningValueAsRvalue)
	TEST (Future, invokeCallbackReturningFutureAsRvalue)
	TEST (Future, futureWithinCtxCleanedUpWhenTaskFinishedInTime)
	TEST (Future, futureWithinNoValueReferenceWhenTimeOut)
	TEST (Future, makePromiseContract)
Future< bool >	call (int depth, Executor *executor)
Future< int >	recursion (Executor *executor, int depth)
	TEST (Future, ThenRecursion)

Variables
static eggs_t	eggs ("eggs")

Macro Definition Documentation

#define DOIT

(

CREATION_EXPR

)

Value:

do {                         \
    auto f1 = (CREATION_EXPR); \
    EXPECT_TRUE(f1.valid());   \
    auto f2 = std::move(f1);   \
    EXPECT_FALSE(f1.valid());  \
    EXPECT_TRUE(f2.valid());   \
  } while (false)

Referenced by TEST().

#define DOIT

(

CREATION_EXPR

)

Value:

do {                         \
    auto f1 = (CREATION_EXPR); \
    EXPECT_FALSE(f1.valid());  \
    auto f2 = std::move(f1);   \
    EXPECT_FALSE(f1.valid());  \
    EXPECT_FALSE(f2.valid());  \
  } while (false)

#define DOIT

(

STMT

)

Value:

do {                     \
    auto f = makeValid();  \
    { STMT; }              \
    copy(std::move(f));    \
    EXPECT_NO_THROW(STMT); \
  } while (false)

#define DOIT

(

STMT

)

Value:

do {                                 \
    auto f = makeValid();              \
    EXPECT_NO_THROW(STMT);             \
    copy(std::move(f));                \
    EXPECT_THROW(STMT, FutureInvalid); \
  } while (false)

#define DOIT

(

STMT

)

Value:

do {                      \
    auto f = makeValid();   \
    EXPECT_NO_THROW(STMT);  \
    EXPECT_TRUE(f.valid()); \
  } while (false)

#define DOIT	(		CTOR,
			STMT
	)

Value:

do {                       \
    auto f = (CTOR);         \
    EXPECT_NO_THROW(STMT);   \
    EXPECT_FALSE(f.valid()); \
  } while (false)

#define EXPECT_FLAG

(

)

Value:

do {                    \
    EXPECT_TRUE(theFlag); \
    theFlag = false;      \
  } while (0);

Referenced by TEST().

#define EXPECT_FLAG

(

)

Value:

do {                    \
    EXPECT_TRUE(theFlag); \
    theFlag = false;      \
  } while (0);

#define EXPECT_NO_FLAG

(

)

Value:

do {                     \
    EXPECT_FALSE(theFlag); \
    theFlag = false;       \
  } while (0);

Referenced by TEST().

#define EXPECT_NO_FLAG

(

)

Value:

do {                     \
    EXPECT_FALSE(theFlag); \
    theFlag = false;       \
  } while (0);

#define EXPECT_TYPE	(		x,
			T
	)		EXPECT_TRUE((std::is_same<decltype(x), T>::value))

Definition at line 37 of file FutureTest.cpp.

Referenced by TEST().

Typedef Documentation

typedef FutureException eggs_t

Definition at line 39 of file FutureTest.cpp.

Function Documentation

Future<bool> call	(	int	depth,
		Executor *	executor
	)

Definition at line 1606 of file FutureTest.cpp.

References folly::makeFuture().

Referenced by TestFilterOddDeleteDo::doA(), testing::gmock_generated_function_mockers_test::MockOverloadedOnConstness::MockOverloadedOnConstness(), proxygen::FilterChain< HTTPCodec, HTTPCodec::Callback, PassThroughHTTPCodecFilter,&HTTPCodec::setCallback, true >::operator->(), recursion(), and testing::gmock_generated_function_mockers_test::TEST().

                                                 {
  return makeFuture().then(executor, [=] { return depth == 0; });
}

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

static

Definition at line 1066 of file FutureTest.cpp.

References folly::pushmi::detail::t.

Referenced by TEST().

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

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

static

Definition at line 1094 of file FutureTest.cpp.

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

Referenced by TEST().

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

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

static

Definition at line 956 of file FutureTest.cpp.

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

Referenced by TEST().

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

static std::string doWorkStaticValue ( std::string &&  t )

static

Definition at line 1070 of file FutureTest.cpp.

References folly::pushmi::detail::t.

Referenced by TEST().

                                                  {
  return t + ";value";
}

Future<int> recursion	(	Executor *	executor,
		int	depth
	)

Definition at line 1610 of file FutureTest.cpp.

References call(), and folly::makeFuture().

Referenced by TEST().

                                                     {
  return makeFuture().thenValue([=](auto) {
    return call(depth, executor).thenValue([=](auto result) {
      if (result) {
        return folly::makeFuture(42);
      }

      return recursion(executor, depth - 1);
    });
  });
}

TEST	(	Future	,
		makeEmpty
	)

Definition at line 44 of file FutureTest.cpp.

References EXPECT_THROW, f, and folly::Future< T >::makeEmpty().

                        {
  auto f = Future<int>::makeEmpty();
  EXPECT_THROW(f.isReady(), FutureInvalid);
}

TEST	(	Future	,
		futureDefaultCtor
	)

Definition at line 49 of file FutureTest.cpp.

                                {
  Future<Unit>();
}

TEST	(	Future	,
		futureToUnit
	)

Definition at line 53 of file FutureTest.cpp.

References eggs, EXPECT_TRUE, folly::makeFuture(), folly::unit, and folly::futures::detail::FutureBase< T >::value().

                           {
  Future<Unit> fu = makeFuture(42).unit();
  fu.value();
  EXPECT_TRUE(makeFuture<int>(eggs).unit().hasException());
}

TEST	(	Future	,
		voidFutureToUnit
	)

Definition at line 59 of file FutureTest.cpp.

References eggs, EXPECT_TRUE, folly::makeFuture(), folly::unit, and folly::futures::detail::FutureBase< T >::value().

                               {
  Future<Unit> fu = makeFuture().unit();
  fu.value();
  EXPECT_TRUE(makeFuture<Unit>(eggs).unit().hasException());
}

TEST	(	Future	,
		unitFutureToUnitIdentity
	)

Definition at line 65 of file FutureTest.cpp.

References eggs, EXPECT_TRUE, folly::makeFuture(), folly::unit, and folly::futures::detail::FutureBase< T >::value().

                                       {
  Future<Unit> fu = makeFuture(Unit{}).unit();
  fu.value();
  EXPECT_TRUE(makeFuture<Unit>(eggs).unit().hasException());
}

TEST	(	Future	,
		toUnitWhileInProgress
	)

Definition at line 71 of file FutureTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, folly::Promise< T >::getFuture(), folly::futures::detail::FutureBase< T >::isReady(), and folly::Promise< T >::setValue().

                                    {
  Promise<int> p;
  Future<Unit> fu = p.getFuture().unit();
  EXPECT_FALSE(fu.isReady());
  p.setValue(42);
  EXPECT_TRUE(fu.isReady());
}

TEST	(	Future	,
		makeFutureWithUnit
	)

Definition at line 79 of file FutureTest.cpp.

References count, EXPECT_EQ, and folly::makeFutureWith().

                                 {
  int count = 0;
  Future<Unit> fu = makeFutureWith([&] { count++; });
  EXPECT_EQ(1, count);
}

TEST	(	Future	,
		getRequiresOnlyMoveCtor
	)

Definition at line 85 of file FutureTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, f, folly::Future< T >::makeEmpty(), and folly::gen::move.

                                      {
  struct MoveCtorOnly {
    explicit MoveCtorOnly(int id) : id_(id) {}
    MoveCtorOnly(const MoveCtorOnly&) = delete;
    MoveCtorOnly(MoveCtorOnly&&) = default;
    void operator=(MoveCtorOnly const&) = delete;
    void operator=(MoveCtorOnly&&) = delete;
    int id_;
  };
  {
    auto f = makeFuture<MoveCtorOnly>(MoveCtorOnly(42));
    EXPECT_TRUE(f.valid());
    EXPECT_TRUE(f.isReady());
    auto v = std::move(f).get();
    EXPECT_EQ(v.id_, 42);
  }
  {
    auto f = makeFuture<MoveCtorOnly>(MoveCtorOnly(42));
    EXPECT_TRUE(f.valid());
    EXPECT_TRUE(f.isReady());
    auto v = std::move(f).get();
    EXPECT_EQ(v.id_, 42);
  }
  {
    auto f = makeFuture<MoveCtorOnly>(MoveCtorOnly(42));
    EXPECT_TRUE(f.valid());
    EXPECT_TRUE(f.isReady());
    auto v = std::move(f).get(std::chrono::milliseconds(10));
    EXPECT_EQ(v.id_, 42);
  }
  {
    auto f = makeFuture<MoveCtorOnly>(MoveCtorOnly(42));
    EXPECT_TRUE(f.valid());
    EXPECT_TRUE(f.isReady());
    auto v = std::move(f).get(std::chrono::milliseconds(10));
    EXPECT_EQ(v.id_, 42);
  }
}

TEST	(	Future	,
		ctorPostconditionValid
	)

Definition at line 137 of file FutureTest.cpp.

References DOIT, and folly::makeFuture().

                                     {
  // Ctors/factories that promise valid -- postcondition: valid()

#define DOIT(CREATION_EXPR)    \
  do {                         \
    auto f1 = (CREATION_EXPR); \
    EXPECT_TRUE(f1.valid());   \
    auto f2 = std::move(f1);   \
    EXPECT_FALSE(f1.valid());  \
    EXPECT_TRUE(f2.valid());   \
  } while (false)

  auto const except = std::logic_error("foo");
  auto const ewrap = folly::exception_wrapper(except);

  DOIT(makeValid());
  DOIT(Future<int>(42));
  DOIT(Future<int>{42});
  DOIT(Future<Unit>());
  DOIT(Future<Unit>{});
  DOIT(makeFuture());
  DOIT(makeFuture(Unit{}));
  DOIT(makeFuture<Unit>(Unit{}));
  DOIT(makeFuture(42));
  DOIT(makeFuture<int>(42));
  DOIT(makeFuture<int>(except));
  DOIT(makeFuture<int>(ewrap));
  DOIT(makeFuture(Try<int>(42)));
  DOIT(makeFuture<int>(Try<int>(42)));
  DOIT(makeFuture<int>(Try<int>(ewrap)));

#undef DOIT
}

TEST	(	Future	,
		ctorPostconditionInvalid
	)

Definition at line 171 of file FutureTest.cpp.

References DOIT.

                                       {
  // Ctors/factories that promise invalid -- postcondition: !valid()

#define DOIT(CREATION_EXPR)    \
  do {                         \
    auto f1 = (CREATION_EXPR); \
    EXPECT_FALSE(f1.valid());  \
    auto f2 = std::move(f1);   \
    EXPECT_FALSE(f1.valid());  \
    EXPECT_FALSE(f2.valid());  \
  } while (false)

  DOIT(makeInvalid());
  DOIT(Future<int>::makeEmpty());

#undef DOIT
}

TEST	(	Future	,
		lacksPreconditionValid
	)

Definition at line 189 of file FutureTest.cpp.

References folly::copy(), DOIT, f, and folly::gen::move.

                                     {
  // Ops that don't throw FutureInvalid if !valid() --
  // without precondition: valid()

#define DOIT(STMT)         \
  do {                     \
    auto f = makeValid();  \
    { STMT; }              \
    copy(std::move(f));    \
    EXPECT_NO_THROW(STMT); \
  } while (false)

  // .valid() itself
  DOIT(f.valid());

  // move-ctor - move-copy to local, copy(), pass-by-move-value
  DOIT(auto other = std::move(f));
  DOIT(copy(std::move(f)));
  DOIT(([](auto) {})(std::move(f)));

  // move-assignment into either {valid | invalid}
  DOIT({
    auto other = makeValid();
    other = std::move(f);
  });
  DOIT({
    auto other = makeInvalid();
    other = std::move(f);
  });

#undef DOIT
}

TEST	(	Future	,
		hasPreconditionValid
	)

Definition at line 222 of file FutureTest.cpp.

References DOIT, f, and folly::gen::move.

                                   {
  // Ops that require validity; precondition: valid();
  // throw FutureInvalid if !valid()

#define DOIT(STMT)                     \
  do {                                 \
    auto f = makeValid();              \
    EXPECT_NO_THROW(STMT);             \
    copy(std::move(f));                \
    EXPECT_THROW(STMT, FutureInvalid); \
  } while (false)

  DOIT(f.isReady());
  DOIT(f.result());
  DOIT(std::move(f).get());
  DOIT(std::move(f).get(std::chrono::milliseconds(10)));
  DOIT(f.getTry());
  DOIT(f.hasValue());
  DOIT(f.hasException());
  DOIT(f.value());
  DOIT(f.poll());
  DOIT(std::move(f).then());
  DOIT(std::move(f).then([](auto&&) {}));

#undef DOIT
}

TEST	(	Future	,
		hasPostconditionValid
	)

Definition at line 249 of file FutureTest.cpp.

References DOIT, f, and folly::gen::move.

                                    {
  // Ops that preserve validity -- postcondition: valid()

#define DOIT(STMT)          \
  do {                      \
    auto f = makeValid();   \
    EXPECT_NO_THROW(STMT);  \
    EXPECT_TRUE(f.valid()); \
  } while (false)

  auto const swallow = [](auto) {};

  DOIT(swallow(f.valid())); // f.valid() itself preserves validity
  DOIT(swallow(f.isReady()));
  DOIT(swallow(f.hasValue()));
  DOIT(swallow(f.hasException()));
  DOIT(swallow(f.value()));
  DOIT(swallow(f.getTry()));
  DOIT(swallow(f.poll()));
  DOIT(f.raise(std::logic_error("foo")));
  DOIT(f.cancel());
  DOIT(swallow(f.getTry()));
  DOIT(f.wait());
  DOIT(std::move(f.wait()));

#undef DOIT
}

TEST	(	Future	,
		hasPostconditionInvalid
	)

Definition at line 277 of file FutureTest.cpp.

References DOIT, f, folly::makeFuture(), folly::gen::move, and folly::detail::distributed_mutex::wait().

                                      {
  // Ops that consume *this -- postcondition: !valid()

#define DOIT(CTOR, STMT)     \
  do {                       \
    auto f = (CTOR);         \
    EXPECT_NO_THROW(STMT);   \
    EXPECT_FALSE(f.valid()); \
  } while (false)

  // move-ctor of {valid|invalid}
  DOIT(makeValid(), { auto other{std::move(f)}; });
  DOIT(makeInvalid(), { auto other{std::move(f)}; });

  // move-assignment of {valid|invalid} into {valid|invalid}
  DOIT(makeValid(), {
    auto other = makeValid();
    other = std::move(f);
  });
  DOIT(makeValid(), {
    auto other = makeInvalid();
    other = std::move(f);
  });
  DOIT(makeInvalid(), {
    auto other = makeValid();
    other = std::move(f);
  });
  DOIT(makeInvalid(), {
    auto other = makeInvalid();
    other = std::move(f);
  });

  // pass-by-value of {valid|invalid}
  DOIT(makeValid(), {
    auto const byval = [](auto) {};
    byval(std::move(f));
  });
  DOIT(makeInvalid(), {
    auto const byval = [](auto) {};
    byval(std::move(f));
  });

  // other consuming ops
  auto const swallow = [](auto) {};
  DOIT(makeValid(), swallow(std::move(f).wait()));
  DOIT(makeValid(), swallow(std::move(f.wait())));
  DOIT(makeValid(), swallow(std::move(f).get()));
  DOIT(makeValid(), swallow(std::move(f).get(std::chrono::milliseconds(10))));
  DOIT(makeValid(), swallow(std::move(f).semi()));

#undef DOIT
}

TEST	(	Future	,
		onError
	)

Definition at line 342 of file FutureTest.cpp.

References eggs, EXPECT_EQ, EXPECT_FLAG, EXPECT_NO_FLAG, EXPECT_NO_THROW, EXPECT_THROW, f, flag, and folly::makeFuture().

                      {
  bool theFlag = false;
  auto flag = [&] { theFlag = true; };
#define EXPECT_FLAG()     \
  do {                    \
    EXPECT_TRUE(theFlag); \
    theFlag = false;      \
  } while (0);

#define EXPECT_NO_FLAG()   \
  do {                     \
    EXPECT_FALSE(theFlag); \
    theFlag = false;       \
  } while (0);

  // By reference
  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw eggs; })
                 .onError([&](eggs_t& /* e */) { flag(); });
    EXPECT_FLAG();
    EXPECT_NO_THROW(f.value());
  }

  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw eggs; })
                 .onError([&](eggs_t& /* e */) {
                   flag();
                   return makeFuture();
                 });
    EXPECT_FLAG();
    EXPECT_NO_THROW(f.value());
  }

  // By value
  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw eggs; })
                 .onError([&](eggs_t /* e */) { flag(); });
    EXPECT_FLAG();
    EXPECT_NO_THROW(f.value());
  }

  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw eggs; })
                 .onError([&](eggs_t /* e */) {
                   flag();
                   return makeFuture();
                 });
    EXPECT_FLAG();
    EXPECT_NO_THROW(f.value());
  }

  // Polymorphic
  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw eggs; })
                 .onError([&](std::exception& /* e */) { flag(); });
    EXPECT_FLAG();
    EXPECT_NO_THROW(f.value());
  }

  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw eggs; })
                 .onError([&](std::exception& /* e */) {
                   flag();
                   return makeFuture();
                 });
    EXPECT_FLAG();
    EXPECT_NO_THROW(f.value());
  }

  // Non-exceptions
  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw - 1; })
                 .onError([&](int /* e */) { flag(); });
    EXPECT_FLAG();
    EXPECT_NO_THROW(f.value());
  }

  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw - 1; })
                 .onError([&](int /* e */) {
                   flag();
                   return makeFuture();
                 });
    EXPECT_FLAG();
    EXPECT_NO_THROW(f.value());
  }

  // Mutable lambda
  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw eggs; })
                 .onError([&](eggs_t& /* e */) mutable { flag(); });
    EXPECT_FLAG();
    EXPECT_NO_THROW(f.value());
  }

  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw eggs; })
                 .onError([&](eggs_t& /* e */) mutable {
                   flag();
                   return makeFuture();
                 });
    EXPECT_FLAG();
    EXPECT_NO_THROW(f.value());
  }

  // Function pointer
  {
    auto f = makeFuture()
                 .thenValue([](auto &&) -> int { throw eggs; })
                 .onError(onErrorHelperEggs)
                 .onError(onErrorHelperGeneric);
    EXPECT_EQ(10, f.value());
  }
  {
    auto f =
        makeFuture()
            .thenValue([](auto &&) -> int { throw std::runtime_error("test"); })
            .onError(onErrorHelperEggs)
            .onError(onErrorHelperGeneric);
    EXPECT_EQ(20, f.value());
  }
  {
    auto f =
        makeFuture()
            .thenValue([](auto &&) -> int { throw std::runtime_error("test"); })
            .onError(onErrorHelperEggs);
    EXPECT_THROW(f.value(), std::runtime_error);
  }
  {
    auto f = makeFuture()
                 .thenValue([](auto &&) -> int { throw eggs; })
                 .thenError<eggs_t>(onErrorHelperEggs)
                 .thenError<std::exception>(onErrorHelperGeneric);
    EXPECT_EQ(10, f.value());
  }
  {
    auto f =
        makeFuture()
            .thenValue([](auto &&) -> int { throw std::runtime_error("test"); })
            .thenError<eggs_t>(onErrorHelperEggs)
            .thenError(onErrorHelperWrapper);
    EXPECT_EQ(30, f.value());
  }
  {
    auto f =
        makeFuture()
            .thenValue([](auto &&) -> int { throw std::runtime_error("test"); })
            .thenError<eggs_t>(onErrorHelperEggs);
    EXPECT_THROW(f.value(), std::runtime_error);
  }

  // No throw
  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { return 42; })
                 .onError([&](eggs_t& /* e */) {
                   flag();
                   return -1;
                 });
    EXPECT_NO_FLAG();
    EXPECT_EQ(42, f.value());
  }

  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { return 42; })
                 .onError([&](eggs_t& /* e */) {
                   flag();
                   return makeFuture<int>(-1);
                 });
    EXPECT_NO_FLAG();
    EXPECT_EQ(42, f.value());
  }

  // Catch different exception
  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw eggs; })
                 .onError([&](std::runtime_error& /* e */) { flag(); });
    EXPECT_NO_FLAG();
    EXPECT_THROW(f.value(), eggs_t);
  }

  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw eggs; })
                 .onError([&](std::runtime_error& /* e */) {
                   flag();
                   return makeFuture();
                 });
    EXPECT_NO_FLAG();
    EXPECT_THROW(f.value(), eggs_t);
  }

  // Returned value propagates
  {
    auto f = makeFuture()
                 .thenValue([](auto &&) -> int { throw eggs; })
                 .onError([&](eggs_t& /* e */) { return 42; });
    EXPECT_EQ(42, f.value());
  }

  // Returned future propagates
  {
    auto f = makeFuture()
                 .thenValue([](auto &&) -> int { throw eggs; })
                 .onError([&](eggs_t& /* e */) { return makeFuture<int>(42); });
    EXPECT_EQ(42, f.value());
  }

  // Throw in callback
  {
    auto f = makeFuture()
                 .thenValue([](auto &&) -> int { throw eggs; })
                 .onError([&](eggs_t& e) -> int { throw e; });
    EXPECT_THROW(f.value(), eggs_t);
  }

  {
    auto f = makeFuture()
                 .thenValue([](auto &&) -> int { throw eggs; })
                 .onError([&](eggs_t& e) -> Future<int> { throw e; });
    EXPECT_THROW(f.value(), eggs_t);
  }

  // exception_wrapper, return Future<T>
  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw eggs; })
                 .onError([&](exception_wrapper /* e */) {
                   flag();
                   return makeFuture();
                 });
    EXPECT_FLAG();
    EXPECT_NO_THROW(f.value());
  }

  // exception_wrapper, return Future<T> but throw
  {
    auto f = makeFuture()
                 .thenValue([](auto &&) -> int { throw eggs; })
                 .onError([&](exception_wrapper /* e */) -> Future<int> {
                   flag();
                   throw eggs;
                 });
    EXPECT_FLAG();
    EXPECT_THROW(f.value(), eggs_t);
  }

  // exception_wrapper, return T
  {
    auto f = makeFuture()
                 .thenValue([](auto &&) -> int { throw eggs; })
                 .onError([&](exception_wrapper /* e */) {
                   flag();
                   return -1;
                 });
    EXPECT_FLAG();
    EXPECT_EQ(-1, f.value());
  }

  // exception_wrapper, return T but throw
  {
    auto f = makeFuture()
                 .thenValue([](auto &&) -> int { throw eggs; })
                 .onError([&](exception_wrapper /* e */) -> int {
                   flag();
                   throw eggs;
                 });
    EXPECT_FLAG();
    EXPECT_THROW(f.value(), eggs_t);
  }

  // const exception_wrapper&
  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw eggs; })
                 .onError([&](const exception_wrapper& /* e */) {
                   flag();
                   return makeFuture();
                 });
    EXPECT_FLAG();
    EXPECT_NO_THROW(f.value());
  }
#undef EXPECT_FLAG
#undef EXPECT_NO_FLAG
}

TEST	(	Future	,
		thenError
	)

Definition at line 640 of file FutureTest.cpp.

References eggs, EXPECT_EQ, EXPECT_FLAG, EXPECT_NO_FLAG, EXPECT_NO_THROW, EXPECT_THROW, f, flag, and folly::makeFuture().

                        {
  bool theFlag = false;
  auto flag = [&] { theFlag = true; };
#define EXPECT_FLAG()     \
  do {                    \
    EXPECT_TRUE(theFlag); \
    theFlag = false;      \
  } while (0);

#define EXPECT_NO_FLAG()   \
  do {                     \
    EXPECT_FALSE(theFlag); \
    theFlag = false;       \
  } while (0);

  // By reference
  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw eggs; })
                 .thenError<eggs_t>([&](const eggs_t& /* e */) { flag(); });
    EXPECT_FLAG();
    EXPECT_NO_THROW(f.value());
  }

  // By auto reference
  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw eggs; })
                 .thenError<eggs_t>([&](auto const& /* e */) { flag(); });
    EXPECT_FLAG();
    EXPECT_NO_THROW(f.value());
  }

  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw eggs; })
                 .onError([&](eggs_t& /* e */) {
                   flag();
                   return makeFuture();
                 });
    EXPECT_FLAG();
    EXPECT_NO_THROW(f.value());
  }

  // By value
  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw eggs; })
                 .onError([&](eggs_t /* e */) { flag(); });
    EXPECT_FLAG();
    EXPECT_NO_THROW(f.value());
  }

  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw eggs; })
                 .onError([&](eggs_t /* e */) {
                   flag();
                   return makeFuture();
                 });
    EXPECT_FLAG();
    EXPECT_NO_THROW(f.value());
  }

  // Polymorphic
  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw eggs; })
                 .onError([&](std::exception& /* e */) { flag(); });
    EXPECT_FLAG();
    EXPECT_NO_THROW(f.value());
  }

  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw eggs; })
                 .onError([&](std::exception& /* e */) {
                   flag();
                   return makeFuture();
                 });
    EXPECT_FLAG();
    EXPECT_NO_THROW(f.value());
  }

  // Non-exceptions
  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw - 1; })
                 .onError([&](int /* e */) { flag(); });
    EXPECT_FLAG();
    EXPECT_NO_THROW(f.value());
  }

  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw - 1; })
                 .onError([&](int /* e */) {
                   flag();
                   return makeFuture();
                 });
    EXPECT_FLAG();
    EXPECT_NO_THROW(f.value());
  }

  // Mutable lambda
  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw eggs; })
                 .onError([&](eggs_t& /* e */) mutable { flag(); });
    EXPECT_FLAG();
    EXPECT_NO_THROW(f.value());
  }

  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw eggs; })
                 .onError([&](eggs_t& /* e */) mutable {
                   flag();
                   return makeFuture();
                 });
    EXPECT_FLAG();
    EXPECT_NO_THROW(f.value());
  }

  // Function pointer
  {
    auto f = makeFuture()
                 .thenValue([](auto &&) -> int { throw eggs; })
                 .onError(onErrorHelperEggs)
                 .onError(onErrorHelperGeneric);
    EXPECT_EQ(10, f.value());
  }
  {
    auto f =
        makeFuture()
            .thenValue([](auto &&) -> int { throw std::runtime_error("test"); })
            .onError(onErrorHelperEggs)
            .onError(onErrorHelperGeneric);
    EXPECT_EQ(20, f.value());
  }
  {
    auto f =
        makeFuture()
            .thenValue([](auto &&) -> int { throw std::runtime_error("test"); })
            .onError(onErrorHelperEggs);
    EXPECT_THROW(f.value(), std::runtime_error);
  }

  // No throw
  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { return 42; })
                 .onError([&](eggs_t& /* e */) {
                   flag();
                   return -1;
                 });
    EXPECT_NO_FLAG();
    EXPECT_EQ(42, f.value());
  }

  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { return 42; })
                 .onError([&](eggs_t& /* e */) {
                   flag();
                   return makeFuture<int>(-1);
                 });
    EXPECT_NO_FLAG();
    EXPECT_EQ(42, f.value());
  }

  // Catch different exception
  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw eggs; })
                 .onError([&](std::runtime_error& /* e */) { flag(); });
    EXPECT_NO_FLAG();
    EXPECT_THROW(f.value(), eggs_t);
  }

  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw eggs; })
                 .onError([&](std::runtime_error& /* e */) {
                   flag();
                   return makeFuture();
                 });
    EXPECT_NO_FLAG();
    EXPECT_THROW(f.value(), eggs_t);
  }

  // Returned value propagates
  {
    auto f = makeFuture()
                 .thenValue([](auto &&) -> int { throw eggs; })
                 .onError([&](eggs_t& /* e */) { return 42; });
    EXPECT_EQ(42, f.value());
  }

  // Returned future propagates
  {
    auto f = makeFuture()
                 .thenValue([](auto &&) -> int { throw eggs; })
                 .onError([&](eggs_t& /* e */) { return makeFuture<int>(42); });
    EXPECT_EQ(42, f.value());
  }

  // Throw in callback
  {
    auto f = makeFuture()
                 .thenValue([](auto &&) -> int { throw eggs; })
                 .onError([&](eggs_t& e) -> int { throw e; });
    EXPECT_THROW(f.value(), eggs_t);
  }

  {
    auto f = makeFuture()
                 .thenValue([](auto &&) -> int { throw eggs; })
                 .onError([&](eggs_t& e) -> Future<int> { throw e; });
    EXPECT_THROW(f.value(), eggs_t);
  }

  // exception_wrapper, return Future<T>
  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw eggs; })
                 .onError([&](exception_wrapper /* e */) {
                   flag();
                   return makeFuture();
                 });
    EXPECT_FLAG();
    EXPECT_NO_THROW(f.value());
  }

  // exception_wrapper, return Future<T> but throw
  {
    auto f = makeFuture()
                 .thenValue([](auto &&) -> int { throw eggs; })
                 .onError([&](exception_wrapper /* e */) -> Future<int> {
                   flag();
                   throw eggs;
                 });
    EXPECT_FLAG();
    EXPECT_THROW(f.value(), eggs_t);
  }

  // exception_wrapper, return T
  {
    auto f = makeFuture()
                 .thenValue([](auto &&) -> int { throw eggs; })
                 .onError([&](exception_wrapper /* e */) {
                   flag();
                   return -1;
                 });
    EXPECT_FLAG();
    EXPECT_EQ(-1, f.value());
  }

  // exception_wrapper, return T but throw
  {
    auto f = makeFuture()
                 .thenValue([](auto &&) -> int { throw eggs; })
                 .onError([&](exception_wrapper /* e */) -> int {
                   flag();
                   throw eggs;
                 });
    EXPECT_FLAG();
    EXPECT_THROW(f.value(), eggs_t);
  }

  // const exception_wrapper&
  {
    auto f = makeFuture()
                 .thenValue([](auto&&) { throw eggs; })
                 .onError([&](const exception_wrapper& /* e */) {
                   flag();
                   return makeFuture();
                 });
    EXPECT_FLAG();
    EXPECT_NO_THROW(f.value());
  }
#undef EXPECT_FLAG
#undef EXPECT_NO_FLAG
}

TEST	(	Future	,
		special
	)

Definition at line 925 of file FutureTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, and folly::value().

                      {
  EXPECT_FALSE(std::is_copy_constructible<Future<int>>::value);
  EXPECT_FALSE(std::is_copy_assignable<Future<int>>::value);
  EXPECT_TRUE(std::is_move_constructible<Future<int>>::value);
  EXPECT_TRUE(std::is_move_assignable<Future<int>>::value);
}

TEST	(	Future	,
		then
	)

Definition at line 932 of file FutureTest.cpp.

References EXPECT_EQ, f, folly::makeFuture(), s, string, folly::pushmi::detail::t, and folly::Try< T >::value().

                   {
  auto f =
      makeFuture<std::string>("0")
          .thenValue([](auto&&) { return makeFuture<std::string>("1"); })
          .then(
              [](Try<std::string>&& t) { return makeFuture(t.value() + ";2"); })
          .then([](const Try<std::string>&& t) {
            return makeFuture(t.value() + ";3");
          })
          .then([](const Try<std::string>& t) {
            return makeFuture(t.value() + ";4");
          })
          .then([](Try<std::string> t) { return makeFuture(t.value() + ";5"); })
          .then([](const Try<std::string> t) {
            return makeFuture(t.value() + ";6");
          })
          .then([](std::string&& s) { return makeFuture(s + ";7"); })
          .then([](const std::string&& s) { return makeFuture(s + ";8"); })
          .then([](const std::string& s) { return makeFuture(s + ";9"); })
          .then([](std::string s) { return makeFuture(s + ";10"); })
          .then([](const std::string s) { return makeFuture(s + ";11"); });
  EXPECT_EQ(f.value(), "1;2;3;4;5;6;7;8;9;10;11");
}

TEST	(	Future	,
		thenTrythenValue
	)

Definition at line 960 of file FutureTest.cpp.

References doWorkStaticTry(), EXPECT_EQ, f, folly::makeFuture(), s, string, folly::pushmi::detail::t, and folly::Try< T >::value().

                               {
  auto f =
      makeFuture()
          .thenTry([](auto&&) { return makeFuture<std::string>("1"); })
          .thenTry(
              [](Try<std::string>&& t) { return makeFuture(t.value() + ";2"); })
          .thenTry([](const Try<std::string>&& t) {
            return makeFuture(t.value() + ";3");
          })
          .thenTry([](const Try<std::string>& t) {
            return makeFuture(t.value() + ";4");
          })
          .thenTry(
              [](Try<std::string> t) { return makeFuture(t.value() + ";5"); })
          .thenTry([](const Try<std::string> t) {
            return makeFuture(t.value() + ";6");
          })
          .thenTry(doWorkStaticTry)
          .thenValue([](std::string&& s) { return makeFuture(s + ";8"); })
          .thenValue([](const std::string&& s) { return makeFuture(s + ";9"); })
          .thenValue([](const std::string& s) { return makeFuture(s + ";10"); })
          .thenValue([](std::string s) { return makeFuture(s + ";11"); })
          .thenValue([](const std::string s) { return makeFuture(s + ";12"); });
  EXPECT_EQ(f.value(), "1;2;3;4;5;6;7;8;9;10;11;12");
}

TEST	(	Future	,
		thenTry
	)

Definition at line 986 of file FutureTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, f, flag, folly::Promise< T >::getFuture(), folly::makeFuture(), folly::Promise< T >::setValue(), and folly::pushmi::detail::t.

                      {
  bool flag = false;

  makeFuture<int>(42).then([&](Try<int>&& t) {
    flag = true;
    EXPECT_EQ(42, t.value());
  });
  EXPECT_TRUE(flag);
  flag = false;

  makeFuture<int>(42)
      .then([](Try<int>&& t) { return t.value(); })
      .then([&](Try<int>&& t) {
        flag = true;
        EXPECT_EQ(42, t.value());
      });
  EXPECT_TRUE(flag);
  flag = false;

  makeFuture().then([&](Try<Unit>&& t) {
    flag = true;
    t.value();
  });
  EXPECT_TRUE(flag);
  flag = false;

  Promise<Unit> p;
  auto f = p.getFuture().then([&](Try<Unit>&& /* t */) { flag = true; });
  EXPECT_FALSE(flag);
  EXPECT_FALSE(f.isReady());
  p.setValue();
  EXPECT_TRUE(flag);
  EXPECT_TRUE(f.isReady());
}

TEST	(	Future	,
		thenValue
	)

Definition at line 1021 of file FutureTest.cpp.

References eggs, EXPECT_EQ, EXPECT_THROW, EXPECT_TRUE, f, flag, i, and folly::makeFuture().

                        {
  bool flag = false;
  makeFuture<int>(42).then([&](int i) {
    EXPECT_EQ(42, i);
    flag = true;
  });
  EXPECT_TRUE(flag);
  flag = false;

  makeFuture<int>(42).then([](int i) { return i; }).then([&](int i) {
    flag = true;
    EXPECT_EQ(42, i);
  });
  EXPECT_TRUE(flag);
  flag = false;

  makeFuture().thenValue([&](auto&&) { flag = true; });
  EXPECT_TRUE(flag);
  flag = false;

  auto f = makeFuture<int>(eggs).thenValue([&](int /* i */) {});
  EXPECT_THROW(f.value(), eggs_t);

  f = makeFuture<Unit>(eggs).thenValue([&](auto&&) {});
  EXPECT_THROW(f.value(), eggs_t);
}

TEST	(	Future	,
		thenValueFuture
	)

Definition at line 1048 of file FutureTest.cpp.

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

                              {
  bool flag = false;
  makeFuture<int>(42)
      .then([](int i) { return makeFuture<int>(std::move(i)); })
      .then([&](Try<int>&& t) {
        flag = true;
        EXPECT_EQ(42, t.value());
      });
  EXPECT_TRUE(flag);
  flag = false;

  makeFuture()
      .thenValue([](auto&&) { return makeFuture(); })
      .then([&](Try<Unit>&& /* t */) { flag = true; });
  EXPECT_TRUE(flag);
  flag = false;
}

TEST	(	Future	,
		thenFunction
	)

Definition at line 1074 of file FutureTest.cpp.

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

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

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

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

TEST	(	Future	,
		thenFunctionFuture
	)

Definition at line 1098 of file FutureTest.cpp.

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

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

  auto f = makeFuture<std::string>("start")
               .then(doWorkStaticFuture)
               .then(Worker::doWorkStaticFuture)
               .then(&Worker::doWorkFuture, &w);

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

TEST	(	Future	,
		thenStdFunction
	)

Definition at line 1116 of file FutureTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, f, flag, i, folly::makeFuture(), folly::gen::move, folly::pushmi::detail::t, and folly::Try< T >::value().

                              {
  {
    std::function<int(folly::Unit)> fn = [](folly::Unit) { return 42; };
    auto f = makeFuture().then(std::move(fn));
    EXPECT_EQ(f.value(), 42);
  }
  {
    std::function<int(int)> fn = [](int i) { return i + 23; };
    auto f = makeFuture(19).then(std::move(fn));
    EXPECT_EQ(f.value(), 42);
  }
  {
    std::function<int(int)> fn = [](int i) { return i + 23; };
    auto f = makeFuture(19).thenValue(std::move(fn));
    EXPECT_EQ(f.value(), 42);
  }
  {
    std::function<int(Try<int>)> fn = [](Try<int> t) { return t.value() + 2; };
    auto f = makeFuture(1).then(std::move(fn));
    EXPECT_EQ(f.value(), 3);
  }
  {
    bool flag = false;
    std::function<void(folly::Unit)> fn = [&flag](folly::Unit) { flag = true; };
    auto f = makeFuture().then(std::move(fn));
    EXPECT_TRUE(f.isReady());
    EXPECT_TRUE(flag);
  }
}

TEST	(	Future	,
		thenBind
	)

Definition at line 1146 of file FutureTest.cpp.

References b, folly::netops::bind(), EXPECT_EQ, f, folly::makeFuture(), and folly::gen::move.

                       {
  auto l = [](folly::Unit) { return makeFuture("bind"); };
  auto b = std::bind(l, std::placeholders::_1);
  auto f = makeFuture().thenValue(std::move(b));
  EXPECT_EQ(f.value(), "bind");
}

TEST	(	Future	,
		thenBindTry
	)

Definition at line 1153 of file FutureTest.cpp.

References b, folly::netops::bind(), EXPECT_EQ, f, folly::makeFuture(), folly::gen::move, and folly::pushmi::detail::t.

                          {
  auto l = [](Try<std::string>&& t) { return makeFuture(t.value() + ";bind"); };
  auto b = std::bind(l, std::placeholders::_1);
  auto f = makeFuture<std::string>("start").then(std::move(b));

  EXPECT_EQ(f.value(), "start;bind");
}

TEST	(	Future	,
		value
	)

Definition at line 1161 of file FutureTest.cpp.

References eggs, EXPECT_EQ, EXPECT_THROW, f, folly::makeFuture(), folly::gen::move, and folly::value().

                    {
  auto f = makeFuture(std::make_unique<int>(42));
  auto up = std::move(f.value());
  EXPECT_EQ(42, *up);

  EXPECT_THROW(makeFuture<int>(eggs).value(), eggs_t);
}

TEST	(	Future	,
		isReady
	)

Definition at line 1169 of file FutureTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, f, folly::Promise< T >::getFuture(), and folly::Promise< T >::setValue().

                      {
  Promise<int> p;
  auto f = p.getFuture();
  EXPECT_FALSE(f.isReady());
  p.setValue(42);
  EXPECT_TRUE(f.isReady());
}

TEST	(	Future	,
		futureNotReady
	)

Definition at line 1177 of file FutureTest.cpp.

References EXPECT_THROW, f, folly::Promise< T >::getFuture(), and folly::futures::detail::FutureBase< T >::value().

                             {
  Promise<int> p;
  Future<int> f = p.getFuture();
  EXPECT_THROW(f.value(), eggs_t);
}

TEST	(	Future	,
		hasException
	)

Definition at line 1183 of file FutureTest.cpp.

References eggs, EXPECT_FALSE, EXPECT_TRUE, and folly::makeFuture().

                           {
  EXPECT_TRUE(makeFuture<int>(eggs).getTry().hasException());
  EXPECT_FALSE(makeFuture(42).getTry().hasException());
}

TEST	(	Future	,
		hasValue
	)

Definition at line 1188 of file FutureTest.cpp.

References eggs, EXPECT_FALSE, EXPECT_TRUE, and folly::makeFuture().

                       {
  EXPECT_TRUE(makeFuture(42).getTry().hasValue());
  EXPECT_FALSE(makeFuture<int>(eggs).getTry().hasValue());
}

TEST	(	Future	,
		makeFuture
	)

Definition at line 1193 of file FutureTest.cpp.

References eggs, EXPECT_EQ, EXPECT_NO_THROW, EXPECT_THROW, EXPECT_TYPE, fun(), folly::makeFuture(), folly::makeFutureWith(), and folly::value().

                         {
  EXPECT_TYPE(makeFuture(42), Future<int>);
  EXPECT_EQ(42, makeFuture(42).value());

  EXPECT_TYPE(makeFuture<float>(42), Future<float>);
  EXPECT_EQ(42, makeFuture<float>(42).value());

  auto fun = [] { return 42; };
  EXPECT_TYPE(makeFutureWith(fun), Future<int>);
  EXPECT_EQ(42, makeFutureWith(fun).value());

  auto funf = [] { return makeFuture<int>(43); };
  EXPECT_TYPE(makeFutureWith(funf), Future<int>);
  EXPECT_EQ(43, makeFutureWith(funf).value());

  auto failfun = []() -> int { throw eggs; };
  EXPECT_TYPE(makeFutureWith(failfun), Future<int>);
  EXPECT_NO_THROW(makeFutureWith(failfun));
  EXPECT_THROW(makeFutureWith(failfun).value(), eggs_t);

  auto failfunf = []() -> Future<int> { throw eggs; };
  EXPECT_TYPE(makeFutureWith(failfunf), Future<int>);
  EXPECT_NO_THROW(makeFutureWith(failfunf));
  EXPECT_THROW(makeFutureWith(failfunf).value(), eggs_t);

  EXPECT_TYPE(makeFuture(), Future<Unit>);
}

TEST	(	Future	,
		finish
	)

Definition at line 1221 of file FutureTest.cpp.

References EXPECT_EQ, f, and folly::pushmi::detail::t.

                     {
  auto x = std::make_shared<int>(0);

  Promise<int> p;
  auto f = p.getFuture().then([x](Try<int>&& t) { *x = t.value(); });

  // The callback hasn't executed
  EXPECT_EQ(0, *x);

  // The callback has a reference to x
  EXPECT_EQ(2, x.use_count());

  p.setValue(42);

  // the callback has executed
  EXPECT_EQ(42, *x);

  // the callback has been destructed
  // and has released its reference to x
  EXPECT_EQ(1, x.use_count());
}

TEST	(	Future	,
		finishBigLambda
	)

Definition at line 1243 of file FutureTest.cpp.

References EXPECT_EQ, f, folly::Promise< T >::getFuture(), folly::Promise< T >::setValue(), and folly::pushmi::detail::t.

                              {
  auto x = std::make_shared<int>(0);

  // bulk_data, to be captured in the lambda passed to Future::then.
  // This is meant to force that the lambda can't be stored inside
  // the Future object.
  std::array<char, sizeof(futures::detail::Core<int>)> bulk_data = {{0}};

  // suppress gcc warning about bulk_data not being used
  EXPECT_EQ(bulk_data[0], 0);

  Promise<int> p;
  auto f = p.getFuture().then([x, bulk_data](Try<int>&& t) {
    (void)bulk_data;
    *x = t.value();
  });

  // The callback hasn't executed
  EXPECT_EQ(0, *x);

  // The callback has a reference to x
  EXPECT_EQ(2, x.use_count());

  p.setValue(42);

  // the callback has executed
  EXPECT_EQ(42, *x);

  // the callback has been destructed
  // and has released its reference to x
  EXPECT_EQ(1, x.use_count());
}

TEST	(	Future	,
		unwrap
	)

Definition at line 1276 of file FutureTest.cpp.

References a, b, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, f, folly::Promise< T >::getFuture(), folly::futures::detail::FutureBase< T >::isReady(), folly::gen::move, folly::Promise< T >::setValue(), and folly::futures::detail::FutureBase< T >::value().

                     {
  Promise<int> a;
  Promise<int> b;

  auto fa = a.getFuture();
  auto fb = b.getFuture();

  bool flag1 = false;
  bool flag2 = false;

  // do a, then do b, and get the result of a + b.
  Future<int> f = std::move(fa).then([&](Try<int>&& ta) {
    auto va = ta.value();
    flag1 = true;
    return std::move(fb).then([va, &flag2](Try<int>&& tb) {
      flag2 = true;
      return va + tb.value();
    });
  });

  EXPECT_FALSE(flag1);
  EXPECT_FALSE(flag2);
  EXPECT_FALSE(f.isReady());

  a.setValue(3);
  EXPECT_TRUE(flag1);
  EXPECT_FALSE(flag2);
  EXPECT_FALSE(f.isReady());

  b.setValue(4);
  EXPECT_TRUE(flag1);
  EXPECT_TRUE(flag2);
  EXPECT_EQ(7, f.value());
}

TEST	(	Future	,
		throwCaughtInImmediateThen
	)

Definition at line 1311 of file FutureTest.cpp.

References folly::makeFuture().

                                         {
  // Neither of these should throw "Promise already satisfied"
  makeFuture().then([=](Try<Unit> &&) -> int { throw std::exception(); });
  makeFuture().then(
      [=](Try<Unit> &&) -> Future<int> { throw std::exception(); });
}

TEST	(	Future	,
		throwIfFailed
	)

Definition at line 1318 of file FutureTest.cpp.

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

                            {
  makeFuture<Unit>(eggs).then(
      [=](Try<Unit>&& t) { EXPECT_THROW(t.throwIfFailed(), eggs_t); });
  makeFuture().then([=](Try<Unit>&& t) { EXPECT_NO_THROW(t.throwIfFailed()); });

  makeFuture<int>(eggs).then(
      [=](Try<int>&& t) { EXPECT_THROW(t.throwIfFailed(), eggs_t); });
  makeFuture<int>(42).then(
      [=](Try<int>&& t) { EXPECT_NO_THROW(t.throwIfFailed()); });
}

TEST	(	Future	,
		getFutureAfterSetValue
	)

Definition at line 1329 of file FutureTest.cpp.

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

                                     {
  Promise<int> p;
  p.setValue(42);
  EXPECT_EQ(42, p.getFuture().value());
}

TEST	(	Future	,
		getFutureAfterSetException
	)

Definition at line 1335 of file FutureTest.cpp.

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

                                         {
  Promise<Unit> p;
  p.setWith([]() -> void { throw std::logic_error("foo"); });
  EXPECT_THROW(p.getFuture().value(), std::logic_error);
}

TEST	(	Future	,
		detachRace
	)

Definition at line 1341 of file FutureTest.cpp.

References f, and folly::Baton< MayBlock, Atom >::wait().

                         {
  // Task #5438209
  // This test is designed to detect a race that was in Core::detachOne()
  // where detached_ was incremented and then tested, and that
  // allowed a race where both Promise and Future would think they were the
  // second and both try to delete. This showed up at scale but was very
  // difficult to reliably repro in a test. As it is, this only fails about
  // once in every 1,000 executions. Doing this 1,000 times is going to make a
  // slow test so I won't do that but if it ever fails, take it seriously, and
  // run the test binary with "--gtest_repeat=10000 --gtest_filter=*detachRace"
  // (Don't forget to enable ASAN)
  auto p = std::make_unique<Promise<bool>>();
  auto f = std::make_unique<Future<bool>>(p->getFuture());
  folly::Baton<> baton;
  std::thread t1([&] {
    baton.post();
    p.reset();
  });
  baton.wait();
  f.reset();
  t1.join();
}

TEST	(	Future	,
		CircularDependencySharedPtrSelfReset
	)

Definition at line 1367 of file FutureTest.cpp.

References EXPECT_EQ, folly::Promise< T >::getFuture(), folly::gen::move, ptr, and folly::Promise< T >::setValue().

                                                   {
  Promise<int64_t> promise;
  auto ptr = std::make_shared<Future<int64_t>>(promise.getFuture());

  std::move(*ptr).thenTry([ptr](folly::Try<int64_t>&& /* uid */) mutable {
    EXPECT_EQ(1, ptr.use_count());

    // Leaving no references to ourselves.
    ptr.reset();
    EXPECT_EQ(0, ptr.use_count());
  });

  EXPECT_EQ(2, ptr.use_count());

  ptr.reset();

  promise.setValue(1);
}

TEST	(	Future	,
		Constructor
	)

Definition at line 1386 of file FutureTest.cpp.

References EXPECT_EQ, EXPECT_NO_THROW, and folly::futures::detail::FutureBase< T >::value().

                          {
  auto f1 = []() -> Future<int> { return Future<int>(3); }();
  EXPECT_EQ(f1.value(), 3);
  auto f2 = []() -> Future<Unit> { return Future<Unit>(); }();
  EXPECT_NO_THROW(f2.value());
}

TEST	(	Future	,
		ImplicitConstructor
	)

Definition at line 1393 of file FutureTest.cpp.

References EXPECT_EQ.

                                  {
  auto f1 = []() -> Future<int> { return 3; }();
  EXPECT_EQ(f1.value(), 3);
  // Unfortunately, the C++ standard does not allow the
  // following implicit conversion to work:
  // auto f2 = []() -> Future<Unit> { }();
}

TEST	(	Future	,
		InPlaceConstructor
	)

Definition at line 1401 of file FutureTest.cpp.

References EXPECT_EQ, f, and folly::in_place().

                                 {
  auto f = Future<std::pair<int, double>>(in_place, 5, 3.2);
  EXPECT_EQ(5, f.value().first);
}

TEST	(	Future	,
		thenDynamic
	)

Definition at line 1406 of file FutureTest.cpp.

References folly::dynamic::asInt(), EXPECT_EQ, f, folly::Promise< T >::getFuture(), folly::gen::move, and folly::Promise< T >::setValue().

                          {
  // folly::dynamic has a constructor that takes any T, this test makes
  // sure that we call the then lambda with folly::dynamic and not
  // Try<folly::dynamic> because that then fails to compile
  Promise<folly::dynamic> p;
  Future<folly::dynamic> f = p.getFuture().then(
      [](const folly::dynamic& d) { return folly::dynamic(d.asInt() + 3); });
  p.setValue(2);
  EXPECT_EQ(std::move(f).get(), 5);
}

TEST	(	Future	,
		RequestContext
	)

Definition at line 1417 of file FutureTest.cpp.

References add, EXPECT_FALSE, EXPECT_TRUE, f, for_each(), folly::RequestContext::get(), folly::RequestContext::getContextData(), folly::Promise< T >::getFuture(), int8_t, folly::makeFuture(), folly::gen::move, folly::RequestContext::saveContext(), folly::RequestContext::setContextData(), folly::Promise< T >::setValue(), folly::pushmi::detail::t, uint8_t, and folly::value().

                             {
  class NewThreadExecutor : public Executor {
   public:
    ~NewThreadExecutor() override {
      std::for_each(v_.begin(), v_.end(), [](std::thread& t) { t.join(); });
    }
    void add(Func f) override {
      if (throwsOnAdd_) {
        throw std::exception();
      }
      v_.emplace_back(std::move(f));
    }
    void addWithPriority(Func f, int8_t /* prio */) override {
      add(std::move(f));
    }
    uint8_t getNumPriorities() const override {
      return numPriorities_;
    }

    void setHandlesPriorities() {
      numPriorities_ = 2;
    }
    void setThrowsOnAdd() {
      throwsOnAdd_ = true;
    }

   private:
    std::vector<std::thread> v_;
    uint8_t numPriorities_ = 1;
    bool throwsOnAdd_ = false;
  };

  struct MyRequestData : RequestData {
    MyRequestData(bool value_ = false) : value(value_) {}

    bool hasCallback() override {
      return false;
    }

    bool value;
  };

  Promise<int> p1, p2;
  NewThreadExecutor e;
  {
    folly::RequestContextScopeGuard rctx;
    RequestContext::get()->setContextData(
        "key", std::make_unique<MyRequestData>(true));
    auto checker = [](int lineno) {
      return [lineno](Try<int>&& /* t */) {
        auto d = static_cast<MyRequestData*>(
            RequestContext::get()->getContextData("key"));
        EXPECT_TRUE(d && d->value) << "on line " << lineno;
      };
    };

    makeFuture(1).via(&e).then(checker(__LINE__));

    e.setHandlesPriorities();
    makeFuture(2).via(&e).then(checker(__LINE__));

    p1.getFuture().then(checker(__LINE__));

    e.setThrowsOnAdd();
    p2.getFuture().via(&e).then(checker(__LINE__));
  }
  // Assert that no RequestContext is set
  EXPECT_FALSE(RequestContext::saveContext());
  p1.setValue(3);
  p2.setValue(4);
}

TEST	(	Future	,
		makeFutureNoThrow
	)

Definition at line 1489 of file FutureTest.cpp.

References folly::makeFuture().

                                {
  makeFuture().value();
}

TEST	(	Future	,
		invokeCallbackReturningValueAsRvalue
	)

Definition at line 1493 of file FutureTest.cpp.

References EXPECT_EQ, folly::foo, and folly::value().

                                                   {
  struct Foo {
    int operator()(int x) & {
      return x + 1;
    }
    int operator()(int x) const& {
      return x + 2;
    }
    int operator()(int x) && {
      return x + 3;
    }
  };

  Foo foo;
  Foo const cfoo;

  // The continuation will be forward-constructed - copied if given as & and
  // moved if given as && - everywhere construction is required.
  // The continuation will be invoked with the same cvref as it is passed.
  EXPECT_EQ(101, makeFuture<int>(100).then(foo).value());
  EXPECT_EQ(202, makeFuture<int>(200).then(cfoo).value());
  EXPECT_EQ(303, makeFuture<int>(300).then(Foo()).value());
}

TEST	(	Future	,
		invokeCallbackReturningFutureAsRvalue
	)

Definition at line 1517 of file FutureTest.cpp.

References EXPECT_EQ, folly::foo, and folly::value().

                                                    {
  struct Foo {
    Future<int> operator()(int x) & {
      return x + 1;
    }
    Future<int> operator()(int x) const& {
      return x + 2;
    }
    Future<int> operator()(int x) && {
      return x + 3;
    }
  };

  Foo foo;
  Foo const cfoo;

  // The continuation will be forward-constructed - copied if given as & and
  // moved if given as && - everywhere construction is required.
  // The continuation will be invoked with the same cvref as it is passed.
  EXPECT_EQ(101, makeFuture<int>(100).then(foo).value());
  EXPECT_EQ(202, makeFuture<int>(200).then(cfoo).value());
  EXPECT_EQ(303, makeFuture<int>(300).then(Foo()).value());

  EXPECT_EQ(101, makeFuture<int>(100).thenValue(foo).value());
  EXPECT_EQ(202, makeFuture<int>(200).thenValue(cfoo).value());
  EXPECT_EQ(303, makeFuture<int>(300).thenValue(Foo()).value());
}

TEST	(	Future	,
		futureWithinCtxCleanedUpWhenTaskFinishedInTime
	)

Definition at line 1545 of file FutureTest.cpp.

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

                                                             {
  // Used to track the use_count of callbackInput even outside of its scope
  std::weak_ptr<int> target;
  {
    Promise<std::shared_ptr<int>> promise;
    auto input = std::make_shared<int>(1);
    auto longEnough = std::chrono::milliseconds(1000);

    promise.getFuture()
        .within(longEnough)
        .then([&target](
                  folly::Try<std::shared_ptr<int>>&& callbackInput) mutable {
          target = callbackInput.value();
        });
    promise.setValue(input);
  }
  // After promise's life cycle is finished, make sure no one is holding the
  // input anymore, in other words, ctx should have been cleaned up.
  EXPECT_EQ(0, target.use_count());
}

TEST	(	Future	,
		futureWithinNoValueReferenceWhenTimeOut
	)

Definition at line 1566 of file FutureTest.cpp.

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

                                                      {
  Promise<std::shared_ptr<int>> promise;
  auto veryShort = std::chrono::milliseconds(1);

  promise.getFuture().within(veryShort).then(
      [](folly::Try<std::shared_ptr<int>>&& callbackInput) {
        // Timeout is fired. Verify callbackInput is not referenced
        EXPECT_EQ(0, callbackInput.value().use_count());
      });
}

TEST	(	Future	,
		makePromiseContract
	)

Definition at line 1577 of file FutureTest.cpp.

References testing::_, add, ASSERT_TRUE, c, folly::ManualExecutor::drain(), EXPECT_EQ, EXPECT_FALSE, f, and folly::gen::move.

                                  {
  class ManualExecutor : public Executor {
   private:
    std::queue<Func> queue_;

   public:
    void add(Func f) override {
      queue_.push(std::move(f));
    }
    void drain() {
      while (!queue_.empty()) {
        auto f = std::move(queue_.front());
        queue_.pop();
        f();
      }
    }
  };

  ManualExecutor e;
  auto c = makePromiseContract<int>(&e);
  c.second = std::move(c.second).then([](int _) { return _ + 1; });
  EXPECT_FALSE(c.second.isReady());
  c.first.setValue(3);
  EXPECT_FALSE(c.second.isReady());
  e.drain();
  ASSERT_TRUE(c.second.isReady());
  EXPECT_EQ(4, std::move(c.second).get());
}

TEST	(	Future	,
		ThenRecursion
	)

Definition at line 1622 of file FutureTest.cpp.

References folly::pushmi::executor, EXPECT_EQ, and recursion().

                            {
  ManualExecutor executor;

  EXPECT_EQ(42, recursion(&executor, 100000).getVia(&executor));
}

Variable Documentation

eggs_t eggs("eggs")

static

Referenced by TEST().