PromiseTest.cpp File Reference

#include <folly/futures/Future.h>
#include <folly/portability/GTest.h>
#include <memory>

Go to the source code of this file.

Macros
#define	DOIT(CREATION_EXPR)
#define	DOIT(CREATION_EXPR)
#define	DOIT(STMT)
#define	DOIT(STMT)
#define	DOIT(STMT)
#define	DOIT(CTOR, STMT)

Typedefs
typedef FutureException	eggs_t

Functions
	TEST (Promise, makeEmpty)
	TEST (Promise, special)
	TEST (Promise, getSemiFuture)
	TEST (Promise, getFuture)
	TEST (Promise, setValueUnit)
	TEST (Promise, ctorPostconditionValid)
	TEST (Promise, ctorPostconditionInvalid)
	TEST (Promise, lacksPreconditionValid)
	TEST (Promise, hasPreconditionValid)
	TEST (Promise, hasPostconditionValid)
	TEST (Promise, hasPostconditionInvalid)
	TEST (Promise, setValueSemiFuture)
	TEST (Promise, setValue)
	TEST (Promise, setException)
	TEST (Promise, setWith)
	TEST (Promise, isFulfilled)
	TEST (Promise, isFulfilledWithFuture)
	TEST (Promise, brokenOnDelete)
	TEST (Promise, brokenPromiseHasTypeInfo)

Variables
static eggs_t	eggs ("eggs")

Macro Definition Documentation

#define DOIT

(

CREATION_EXPR

)

Value:

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

Referenced by TEST().

#define DOIT

(

CREATION_EXPR

)

Value:

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

#define DOIT

(

STMT

)

Value:

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

#define DOIT

(

STMT

)

Value:

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

#define DOIT

(

STMT

)

Value:

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

#define DOIT	(		CTOR,
			STMT
	)

Value:

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

Typedef Documentation

typedef FutureException eggs_t

Definition at line 26 of file PromiseTest.cpp.

Function Documentation

TEST	(	Promise	,
		makeEmpty
	)

Definition at line 29 of file PromiseTest.cpp.

References EXPECT_TRUE, and folly::Promise< T >::makeEmpty().

                         {
  auto p = Promise<int>::makeEmpty();
  EXPECT_TRUE(p.isFulfilled());
}

TEST	(	Promise	,
		special
	)

Definition at line 34 of file PromiseTest.cpp.

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

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

TEST	(	Promise	,
		getSemiFuture
	)

Definition at line 41 of file PromiseTest.cpp.

References EXPECT_FALSE, f, folly::Promise< T >::getSemiFuture(), and folly::futures::detail::FutureBase< T >::isReady().

                             {
  Promise<int> p;
  SemiFuture<int> f = p.getSemiFuture();
  EXPECT_FALSE(f.isReady());
}

TEST	(	Promise	,
		getFuture
	)

Definition at line 47 of file PromiseTest.cpp.

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

                         {
  Promise<int> p;
  Future<int> f = p.getFuture();
  EXPECT_FALSE(f.isReady());
}

TEST	(	Promise	,
		setValueUnit
	)

Definition at line 53 of file PromiseTest.cpp.

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

                            {
  Promise<Unit> p;
  p.setValue();
}

TEST	(	Promise	,
		ctorPostconditionValid
	)

Definition at line 71 of file PromiseTest.cpp.

References DOIT.

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

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

  DOIT(makeValid());
  DOIT(Promise<int>());
  DOIT(Promise<int>{});
  DOIT(Promise<Unit>());
  DOIT(Promise<Unit>{});

#undef DOIT
}

TEST	(	Promise	,
		ctorPostconditionInvalid
	)

Definition at line 92 of file PromiseTest.cpp.

References DOIT.

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

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

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

#undef DOIT
}

TEST	(	Promise	,
		lacksPreconditionValid
	)

Definition at line 110 of file PromiseTest.cpp.

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

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

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

  // misc methods that don't require isValid()
  DOIT(p.valid());
  DOIT(p.isFulfilled());

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

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

#undef DOIT
}

TEST	(	Promise	,
		hasPreconditionValid
	)

Definition at line 144 of file PromiseTest.cpp.

References DOIT.

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

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

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

  DOIT(p.getSemiFuture());
  DOIT(p.getFuture());
  DOIT(p.setException(except));
  DOIT(p.setException(ewrap));
  DOIT(p.setInterruptHandler([](auto&) {}));
  DOIT(p.setValue(42));
  DOIT(p.setTry(Try<int>(42)));
  DOIT(p.setTry(Try<int>(ewrap)));
  DOIT(p.setWith([] { return 42; }));

#undef DOIT
}

TEST	(	Promise	,
		hasPostconditionValid
	)

Definition at line 172 of file PromiseTest.cpp.

References DOIT.

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

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

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

  DOIT(swallow(p.valid())); // p.valid() itself preserves validity
  DOIT(swallow(p.isFulfilled()));

#undef DOIT
}

TEST	(	Promise	,
		hasPostconditionInvalid
	)

Definition at line 190 of file PromiseTest.cpp.

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

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

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

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

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

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

#undef DOIT
}

TEST	(	Promise	,
		setValueSemiFuture
	)

Definition at line 235 of file PromiseTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, f, folly::Promise< T >::getSemiFuture(), folly::gen::move, name, ptr, folly::Promise< T >::setValue(), v, and folly::value().

                                  {
  Promise<int> fund;
  auto ffund = fund.getSemiFuture();
  fund.setValue(42);
  EXPECT_EQ(42, ffund.value());

  struct Foo {
    string name;
    int value;
  };

  Promise<Foo> pod;
  auto fpod = pod.getSemiFuture();
  Foo f = {"the answer", 42};
  pod.setValue(f);
  Foo f2 = fpod.value();
  EXPECT_EQ(f.name, f2.name);
  EXPECT_EQ(f.value, f2.value);

  pod = Promise<Foo>();
  fpod = pod.getSemiFuture();
  pod.setValue(std::move(f2));
  Foo f3 = fpod.value();
  EXPECT_EQ(f.name, f3.name);
  EXPECT_EQ(f.value, f3.value);

  Promise<unique_ptr<int>> mov;
  auto fmov = mov.getSemiFuture();
  mov.setValue(std::make_unique<int>(42));
  unique_ptr<int> ptr = std::move(fmov.value());
  EXPECT_EQ(42, *ptr);

  Promise<Unit> v;
  auto fv = v.getSemiFuture();
  v.setValue();
  EXPECT_TRUE(fv.isReady());
}

TEST	(	Promise	,
		setValue
	)

Definition at line 273 of file PromiseTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, f, folly::Promise< T >::getFuture(), folly::gen::move, name, ptr, folly::Promise< T >::setValue(), v, and folly::value().

                        {
  Promise<int> fund;
  auto ffund = fund.getFuture();
  fund.setValue(42);
  EXPECT_EQ(42, ffund.value());

  struct Foo {
    string name;
    int value;
  };

  Promise<Foo> pod;
  auto fpod = pod.getFuture();
  Foo f = {"the answer", 42};
  pod.setValue(f);
  Foo f2 = fpod.value();
  EXPECT_EQ(f.name, f2.name);
  EXPECT_EQ(f.value, f2.value);

  pod = Promise<Foo>();
  fpod = pod.getFuture();
  pod.setValue(std::move(f2));
  Foo f3 = fpod.value();
  EXPECT_EQ(f.name, f3.name);
  EXPECT_EQ(f.value, f3.value);

  Promise<unique_ptr<int>> mov;
  auto fmov = mov.getFuture();
  mov.setValue(std::make_unique<int>(42));
  unique_ptr<int> ptr = std::move(fmov.value());
  EXPECT_EQ(42, *ptr);

  Promise<Unit> v;
  auto fv = v.getFuture();
  v.setValue();
  EXPECT_TRUE(fv.isReady());
}

TEST	(	Promise	,
		setException
	)

Definition at line 311 of file PromiseTest.cpp.

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

                            {
  {
    Promise<Unit> p;
    auto f = p.getFuture();
    p.setException(eggs);
    EXPECT_THROW(f.value(), eggs_t);
  }
  {
    Promise<Unit> p;
    auto f = p.getFuture();
    p.setException(exception_wrapper(eggs));
    EXPECT_THROW(f.value(), eggs_t);
  }
}

TEST	(	Promise	,
		setWith
	)

Definition at line 326 of file PromiseTest.cpp.

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

                       {
  {
    Promise<int> p;
    auto f = p.getFuture();
    p.setWith([] { return 42; });
    EXPECT_EQ(42, f.value());
  }
  {
    Promise<int> p;
    auto f = p.getFuture();
    p.setWith([]() -> int { throw eggs; });
    EXPECT_THROW(f.value(), eggs_t);
  }
}

TEST	(	Promise	,
		isFulfilled
	)

Definition at line 341 of file PromiseTest.cpp.

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

                           {
  Promise<int> p;

  EXPECT_FALSE(p.isFulfilled());
  p.setValue(42);
  EXPECT_TRUE(p.isFulfilled());
}

TEST	(	Promise	,
		isFulfilledWithFuture
	)

Definition at line 349 of file PromiseTest.cpp.

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

                                     {
  Promise<int> p;
  auto f = p.getFuture(); // so core_ will become null

  EXPECT_FALSE(p.isFulfilled());
  p.setValue(42); // after here
  EXPECT_TRUE(p.isFulfilled());
}

TEST	(	Promise	,
		brokenOnDelete
	)

Definition at line 358 of file PromiseTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, f, and folly::pushmi::detail::t.

                              {
  auto p = std::make_unique<Promise<int>>();
  auto f = p->getFuture();

  EXPECT_FALSE(f.isReady());

  p.reset();

  EXPECT_TRUE(f.isReady());

  auto t = f.getTry();

  EXPECT_TRUE(t.hasException<BrokenPromise>());
}

TEST	(	Promise	,
		brokenPromiseHasTypeInfo
	)

Definition at line 373 of file PromiseTest.cpp.

References EXPECT_NE.

                                        {
  auto pInt = std::make_unique<Promise<int>>();
  auto fInt = pInt->getFuture();

  auto pFloat = std::make_unique<Promise<float>>();
  auto fFloat = pFloat->getFuture();

  pInt.reset();
  pFloat.reset();

  auto whatInt = fInt.getTry().exception().what();
  auto whatFloat = fFloat.getTry().exception().what();

  EXPECT_NE(whatInt, whatFloat);
}

Variable Documentation

eggs_t eggs("eggs")

static

Referenced by TEST().