EventHandlerTest.cpp File Reference

#include <bitset>
#include <future>
#include <thread>
#include <folly/MPMCQueue.h>
#include <folly/ScopeGuard.h>
#include <folly/io/async/EventBase.h>
#include <folly/io/async/EventHandler.h>
#include <folly/portability/GMock.h>
#include <folly/portability/GTest.h>
#include <folly/portability/Sockets.h>
#include <sys/eventfd.h>

Go to the source code of this file.

Classes
class	EventHandlerMock
class	EventHandlerTest

Functions
void	runInThreadsAndWait (size_t nthreads, function< void(size_t)> cb)
void	runInThreadsAndWait (vector< function< void()>> cbs)
	TEST_F (EventHandlerTest, simple)
	TEST_F (EventHandlerTest, many_concurrent_producers)
	TEST_F (EventHandlerTest, many_concurrent_consumers)

Function Documentation

void runInThreadsAndWait	(	size_t	nthreads,
		function< void(size_t)>	cb
	)

Definition at line 34 of file EventHandlerTest.cpp.

References i, nthreads, and threads.

Referenced by runInThreadsAndWait(), and TEST_F().

                                                                     {
  vector<thread> threads(nthreads);
  for (size_t i = 0; i < nthreads; ++i) {
    threads[i] = thread(cb, i);
  }
  for (size_t i = 0; i < nthreads; ++i) {
    threads[i].join();
  }
}

void runInThreadsAndWait

(

vector< function< void()>>

cbs

)

Definition at line 44 of file EventHandlerTest.cpp.

References k, and runInThreadsAndWait().

                                                       {
  runInThreadsAndWait(cbs.size(), [&](size_t k) { cbs[k](); });
}

TEST_F	(	EventHandlerTest	,
		simple
	)

Definition at line 85 of file EventHandlerTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, testing::Invoke(), folly::EventBase::loop(), folly::EventHandler::registerHandler(), uint16_t, and folly::EventHandler::unregisterHandler().

Referenced by TEST_F().

                                 {
  const size_t writes = 4;
  size_t readsRemaining = writes;

  EventBase eb;
  EventHandlerMock eh(&eb, efd);
  eh.registerHandler(EventHandler::READ | EventHandler::PERSIST);
  EXPECT_CALL(eh, _handlerReady(_))
      .Times(writes)
      .WillRepeatedly(Invoke([&](uint16_t /* events */) {
        efd_read();
        if (--readsRemaining == 0) {
          eh.unregisterHandler();
        }
      }));
  efd_write(writes);
  eb.loop();

  EXPECT_EQ(0, readsRemaining);
}

TEST_F	(	EventHandlerTest	,
		many_concurrent_producers
	)

Definition at line 106 of file EventHandlerTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, i, testing::Invoke(), folly::EventBase::loop(), folly::EventHandler::registerHandler(), runInThreadsAndWait(), uint16_t, and folly::EventHandler::unregisterHandler().

                                                    {
  const size_t writes = 200;
  const size_t nproducers = 20;
  size_t readsRemaining = writes;

  runInThreadsAndWait({
      [&] {
        EventBase eb;
        EventHandlerMock eh(&eb, efd);
        eh.registerHandler(EventHandler::READ | EventHandler::PERSIST);
        EXPECT_CALL(eh, _handlerReady(_))
            .Times(writes)
            .WillRepeatedly(Invoke([&](uint16_t /* events */) {
              efd_read();
              if (--readsRemaining == 0) {
                eh.unregisterHandler();
              }
            }));
        eb.loop();
      },
      [&] {
        runInThreadsAndWait(nproducers, [&](size_t /* k */) {
          for (size_t i = 0; i < writes / nproducers; ++i) {
            this_thread::sleep_for(std::chrono::milliseconds(1));
            efd_write(1);
          }
        });
      },
  });

  EXPECT_EQ(0, readsRemaining);
}

TEST_F	(	EventHandlerTest	,
		many_concurrent_consumers
	)

Definition at line 139 of file EventHandlerTest.cpp.

References testing::_, folly::netops::accept(), ASSERT_TRUE, folly::netops::bind(), buffer(), folly::netops::close(), folly::netops::connect(), EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, folly::netops::getsockname(), i, folly::INFO, testing::Invoke(), folly::netops::listen(), folly::EventBase::loop(), folly::pushmi::__adl::noexcept(), fizz::detail::read(), folly::netops::recv(), folly::EventHandler::registerHandler(), runInThreadsAndWait(), SCOPE_EXIT, folly::netops::send(), folly::netops::socket(), string, TEST_F(), uint16_t, folly::EventHandler::unregisterHandler(), and val.

                                                    {
  const size_t writes = 200;
  const size_t nproducers = 8;
  const size_t nconsumers = 20;
  atomic<size_t> writesRemaining(writes);
  atomic<size_t> readsRemaining(writes);

  MPMCQueue<nullptr_t> queue(writes / 10);

  runInThreadsAndWait({
      [&] {
        runInThreadsAndWait(nconsumers, [&](size_t /* k */) {
          size_t thReadsRemaining = writes / nconsumers;
          EventBase eb;
          EventHandlerMock eh(&eb, efd);
          eh.registerHandler(EventHandler::READ | EventHandler::PERSIST);
          EXPECT_CALL(eh, _handlerReady(_))
              .WillRepeatedly(Invoke([&](uint16_t /* events */) {
                nullptr_t val;
                if (!queue.readIfNotEmpty(val)) {
                  return;
                }
                efd_read();
                --readsRemaining;
                if (--thReadsRemaining == 0) {
                  eh.unregisterHandler();
                }
              }));
          eb.loop();
        });
      },
      [&] {
        runInThreadsAndWait(nproducers, [&](size_t /* k */) {
          for (size_t i = 0; i < writes / nproducers; ++i) {
            this_thread::sleep_for(std::chrono::milliseconds(1));
            queue.blockingWrite(nullptr);
            efd_write(1);
            --writesRemaining;
          }
        });
      },
  });

  EXPECT_EQ(0, writesRemaining);
  EXPECT_EQ(0, readsRemaining);
}