TimesTest.cpp File Reference

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

Go to the source code of this file.

Functions
void	popAndFulfillPromise (std::queue< std::shared_ptr< Promise< Unit >>> &ps, std::mutex &ps_mutex)
std::function< Future< Unit >void)>	makeThunk (std::queue< std::shared_ptr< Promise< Unit >>> &ps, int &interrupt, std::mutex &ps_mutex)
std::function< bool(void)>	makePred (int &i)
	TEST (Times, success)
	TEST (Times, failure)
	TEST (Times, interrupt)

Function Documentation

std::function<bool(void)> makePred ( int &  i )

inline

Definition at line 53 of file TimesTest.cpp.

References i.

                                                {
  return [&]() {
    bool res = i < 3;
    ++i;
    return res;
  };
}

std::function<Future<Unit>void)> makeThunk ( std::queue< std::shared_ptr< Promise< Unit >>> &  ps, int &  interrupt, std::mutex &  ps_mutex  )

inline

Definition at line 37 of file TimesTest.cpp.

Referenced by TEST().

                        {
  return [&]() mutable {
    auto p = std::make_shared<Promise<Unit>>();
    p->setInterruptHandler(
        [&](exception_wrapper const& /* e */) { ++interrupt; });
    ps_mutex.lock();
    ps.push(p);
    ps_mutex.unlock();

    return p->getFuture();
  };
}

void popAndFulfillPromise ( std::queue< std::shared_ptr< Promise< Unit >>> &  ps, std::mutex &  ps_mutex  )

inline

Definition at line 27 of file TimesTest.cpp.

Referenced by TEST().

                        {
  ps_mutex.lock();
  auto p = ps.front();
  ps.pop();
  ps_mutex.unlock();
  p->setValue();
}

TEST	(	Times	,
		success
	)

Definition at line 61 of file TimesTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, f, makeThunk(), mutex, popAndFulfillPromise(), and folly::times().

                     {
  std::queue<std::shared_ptr<Promise<Unit>>> ps;
  std::mutex ps_mutex;
  int interrupt = 0;
  bool complete = false;
  bool failure = false;

  auto thunk = makeThunk(ps, interrupt, ps_mutex);
  auto f = folly::times(3, thunk)
               .thenValue([&](auto&&) mutable { complete = true; })
               .onError([&](FutureException& /* e */) { failure = true; });

  popAndFulfillPromise(ps, ps_mutex);
  EXPECT_FALSE(complete);
  EXPECT_FALSE(failure);

  popAndFulfillPromise(ps, ps_mutex);
  EXPECT_FALSE(complete);
  EXPECT_FALSE(failure);

  popAndFulfillPromise(ps, ps_mutex);
  EXPECT_TRUE(f.isReady());
  EXPECT_TRUE(complete);
  EXPECT_FALSE(failure);
}

TEST	(	Times	,
		failure
	)

Definition at line 87 of file TimesTest.cpp.

References eggs, EXPECT_FALSE, EXPECT_TRUE, f, makeThunk(), mutex, popAndFulfillPromise(), and folly::times().

                     {
  std::queue<std::shared_ptr<Promise<Unit>>> ps;
  std::mutex ps_mutex;
  int interrupt = 0;
  bool complete = false;
  bool failure = false;

  auto thunk = makeThunk(ps, interrupt, ps_mutex);
  auto f = folly::times(3, thunk)
               .thenValue([&](auto&&) mutable { complete = true; })
               .onError([&](FutureException& /* e */) { failure = true; });

  popAndFulfillPromise(ps, ps_mutex);
  EXPECT_FALSE(complete);
  EXPECT_FALSE(failure);

  ps_mutex.lock();
  auto p2 = ps.front();
  ps.pop();
  ps_mutex.unlock();
  FutureException eggs("eggs");
  p2->setException(eggs);

  EXPECT_TRUE(f.isReady());
  EXPECT_FALSE(complete);
  EXPECT_TRUE(failure);
}

TEST	(	Times	,
		interrupt
	)

Definition at line 115 of file TimesTest.cpp.

References eggs, EXPECT_EQ, f, i, makeThunk(), mutex, popAndFulfillPromise(), and folly::times().

                       {
  std::queue<std::shared_ptr<Promise<Unit>>> ps;
  std::mutex ps_mutex;
  int interrupt = 0;
  bool complete = false;
  bool failure = false;

  auto thunk = makeThunk(ps, interrupt, ps_mutex);
  auto f = folly::times(3, thunk)
               .thenValue([&](auto&&) mutable { complete = true; })
               .onError([&](FutureException& /* e */) { failure = true; });

  EXPECT_EQ(0, interrupt);

  FutureException eggs("eggs");
  f.raise(eggs);

  for (int i = 1; i <= 3; ++i) {
    EXPECT_EQ(1, interrupt);
    popAndFulfillPromise(ps, ps_mutex);
  }
}