WhileDoTest.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 (WhileDo, success)
	TEST (WhileDo, failure)
	TEST (WhileDo, interrupt)

Function Documentation

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

inline

Definition at line 53 of file WhileDoTest.cpp.

References i.

Referenced by TEST().

                                                {
  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 WhileDoTest.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 WhileDoTest.cpp.

Referenced by TEST().

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

TEST	(	WhileDo	,
		success
	)

Definition at line 61 of file WhileDoTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, f, i, makePred(), makeThunk(), mutex, popAndFulfillPromise(), and folly::whileDo().

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

  auto pred = makePred(i);
  auto thunk = makeThunk(ps, interrupt, ps_mutex);
  auto f = folly::whileDo(pred, 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	(	WhileDo	,
		failure
	)

Definition at line 89 of file WhileDoTest.cpp.

References eggs, EXPECT_FALSE, EXPECT_TRUE, f, i, makePred(), makeThunk(), mutex, popAndFulfillPromise(), and folly::whileDo().

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

  auto pred = makePred(i);
  auto thunk = makeThunk(ps, interrupt, ps_mutex);
  auto f = folly::whileDo(pred, 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	(	WhileDo	,
		interrupt
	)

Definition at line 119 of file WhileDoTest.cpp.

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

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

  int i = 0;
  auto pred = makePred(i);
  auto thunk = makeThunk(ps, interrupt, ps_mutex);
  auto f = folly::whileDo(pred, thunk)
               .thenValue([&](auto&&) mutable { complete = true; })
               .onError([&](FutureException& /* e */) { failure = true; });

  EXPECT_EQ(0, interrupt);

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

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