AsyncUDPSocketTest.cpp File Reference

#include <thread>
#include <folly/Conv.h>
#include <folly/SocketAddress.h>
#include <folly/String.h>
#include <folly/io/IOBuf.h>
#include <folly/io/async/AsyncTimeout.h>
#include <folly/io/async/AsyncUDPServerSocket.h>
#include <folly/io/async/AsyncUDPSocket.h>
#include <folly/io/async/EventBase.h>
#include <folly/portability/GMock.h>
#include <folly/portability/GTest.h>
#include <folly/portability/Sockets.h>

Go to the source code of this file.

Classes
class	UDPAcceptor
class	UDPServer
class	UDPClient
class	ConnectedWriteUDPClient
class	AsyncSocketIntegrationTest
class	TestAsyncUDPSocket
class	MockErrMessageCallback
class	MockUDPReadCallback
class	AsyncUDPSocketTest

Functions
	TEST_F (AsyncSocketIntegrationTest, PingPong)
	TEST_F (AsyncSocketIntegrationTest, ConnectedPingPong)
	TEST_F (AsyncSocketIntegrationTest, ConnectedPingPongServerWrongAddress)
	TEST_F (AsyncSocketIntegrationTest, ConnectedPingPongClientWrongAddress)
	TEST_F (AsyncSocketIntegrationTest, PingPongUseConnectedSendMsg)
	TEST_F (AsyncSocketIntegrationTest, PingPongUseConnectedSendMsgServerWrongAddr)
	TEST_F (AsyncSocketIntegrationTest, PingPongPauseResumeListening)
	TEST_F (AsyncUDPSocketTest, TestConnect)
	TEST_F (AsyncUDPSocketTest, TestErrToNonExistentServer)
	TEST_F (AsyncUDPSocketTest, TestUnsetErrCallback)
	TEST_F (AsyncUDPSocketTest, CloseInErrorCallback)
	TEST_F (AsyncUDPSocketTest, TestNonExistentServerNoErrCb)
	TEST_F (AsyncUDPSocketTest, TestBound)
	TEST_F (AsyncUDPSocketTest, TestAttachAfterDetachEvbWithReadCallback)
	TEST_F (AsyncUDPSocketTest, TestAttachAfterDetachEvbNoReadCallback)
	TEST_F (AsyncUDPSocketTest, TestDetachAttach)

Function Documentation

TEST_F	(	AsyncSocketIntegrationTest	,
		PingPong
	)

Definition at line 394 of file AsyncUDPSocketTest.cpp.

References ASSERT_GT, and folly::none.

                                             {
  startServer();
  auto pingClient = performPingPongTest(folly::none, false);
  // This should succeed.
  ASSERT_GT(pingClient->pongRecvd(), 0);
}

TEST_F	(	AsyncSocketIntegrationTest	,
		ConnectedPingPong
	)

Definition at line 401 of file AsyncUDPSocketTest.cpp.

References ASSERT_GT.

                                                      {
  server->setChangePortForWrites(false);
  startServer();
  auto pingClient = performPingPongTest(server->address(), false);
  // This should succeed
  ASSERT_GT(pingClient->pongRecvd(), 0);
}

TEST_F	(	AsyncSocketIntegrationTest	,
		ConnectedPingPongServerWrongAddress
	)

Definition at line 409 of file AsyncUDPSocketTest.cpp.

References ASSERT_EQ.

                                                                        {
  server->setChangePortForWrites(true);
  startServer();
  auto pingClient = performPingPongTest(server->address(), false);
  // This should fail.
  ASSERT_EQ(pingClient->pongRecvd(), 0);
}

TEST_F	(	AsyncSocketIntegrationTest	,
		ConnectedPingPongClientWrongAddress
	)

Definition at line 417 of file AsyncUDPSocketTest.cpp.

References ASSERT_EQ.

                                                                        {
  server->setChangePortForWrites(false);
  startServer();
  folly::SocketAddress connectAddr(
      server->address().getIPAddress(), server->address().getPort() + 1);
  auto pingClient = performPingPongTest(connectAddr, false);
  // This should fail.
  ASSERT_EQ(pingClient->pongRecvd(), 0);
}

TEST_F	(	AsyncSocketIntegrationTest	,
		PingPongUseConnectedSendMsg
	)

Definition at line 427 of file AsyncUDPSocketTest.cpp.

References ASSERT_GT.

                                                                {
  server->setChangePortForWrites(false);
  startServer();
  auto pingClient = performPingPongTest(server->address(), true);
  // This should succeed.
  ASSERT_GT(pingClient->pongRecvd(), 0);
}

TEST_F	(	AsyncSocketIntegrationTest	,
		PingPongUseConnectedSendMsgServerWrongAddr
	)

Definition at line 435 of file AsyncUDPSocketTest.cpp.

References ASSERT_EQ.

                                                                               {
  server->setChangePortForWrites(true);
  startServer();
  auto pingClient = performPingPongTest(server->address(), true);
  // This should fail.
  ASSERT_EQ(pingClient->pongRecvd(), 0);
}

TEST_F	(	AsyncSocketIntegrationTest	,
		PingPongPauseResumeListening
	)

Definition at line 443 of file AsyncUDPSocketTest.cpp.

References ASSERT_EQ, ASSERT_GT, and folly::none.

                                                                 {
  startServer();

  // Exchange should not happen when paused.
  server->pauseAccepting();
  auto pausedClient = performPingPongTest(folly::none, false);
  ASSERT_EQ(pausedClient->pongRecvd(), 0);

  // Exchange does occur after resuming.
  server->resumeAccepting();
  auto pingClient = performPingPongTest(folly::none, false);
  ASSERT_GT(pingClient->pongRecvd(), 0);
}

TEST_F	(	AsyncUDPSocketTest	,
		TestConnect
	)

Definition at line 527 of file AsyncUDPSocketTest.cpp.

References EXPECT_EQ, and socket_.

                                        {
  EXPECT_EQ(socket_->connect(addr_), 0);
}

TEST_F	(	AsyncUDPSocketTest	,
		TestErrToNonExistentServer
	)

Definition at line 531 of file AsyncUDPSocketTest.cpp.

References testing::_, addr, folly::IOBuf::copyBuffer(), evb_, EXPECT_CALL, EXPECT_TRUE, testing::Invoke(), folly::EventBase::loopForever(), socket_, and folly::EventBase::terminateLoopSoon().

                                                       {
  socket_->resumeRead(&readCb);
  socket_->setErrMessageCallback(&err);
  folly::SocketAddress addr("127.0.0.1", 10000);
  bool errRecvd = false;
#ifdef FOLLY_HAVE_MSG_ERRQUEUE
  EXPECT_CALL(err, errMessage_(_))
      .WillOnce(Invoke([this, &errRecvd](auto& cmsg) {
        if ((cmsg.cmsg_level == SOL_IP && cmsg.cmsg_type == IP_RECVERR) ||
            (cmsg.cmsg_level == SOL_IPV6 && cmsg.cmsg_type == IPV6_RECVERR)) {
          const struct sock_extended_err* serr =
              reinterpret_cast<const struct sock_extended_err*>(
                  CMSG_DATA(&cmsg));
          errRecvd =
              (serr->ee_origin == SO_EE_ORIGIN_ICMP || SO_EE_ORIGIN_ICMP6);
          LOG(ERROR) << "errno " << errnoStr(serr->ee_errno);
        }
        evb_.terminateLoopSoon();
      }));
#endif // FOLLY_HAVE_MSG_ERRQUEUE
  socket_->write(addr, folly::IOBuf::copyBuffer("hey"));
  evb_.loopForever();
  EXPECT_TRUE(errRecvd);
}

TEST_F	(	AsyncUDPSocketTest	,
		TestUnsetErrCallback
	)

Definition at line 556 of file AsyncUDPSocketTest.cpp.

References testing::_, addr, folly::IOBuf::copyBuffer(), evb_, EXPECT_CALL, folly::EventBase::loopForever(), folly::HHWheelTimer::scheduleTimeoutFn(), socket_, folly::EventBase::terminateLoopSoon(), and folly::EventBase::timer().

                                                 {
  socket_->resumeRead(&readCb);
  socket_->setErrMessageCallback(&err);
  socket_->setErrMessageCallback(nullptr);
  folly::SocketAddress addr("127.0.0.1", 10000);
  EXPECT_CALL(err, errMessage_(_)).Times(0);
  socket_->write(addr, folly::IOBuf::copyBuffer("hey"));
  evb_.timer().scheduleTimeoutFn(
      [&] { evb_.terminateLoopSoon(); }, std::chrono::milliseconds(30));
  evb_.loopForever();
}

TEST_F	(	AsyncUDPSocketTest	,
		CloseInErrorCallback
	)

Definition at line 568 of file AsyncUDPSocketTest.cpp.

References testing::_, addr, folly::IOBuf::copyBuffer(), evb_, EXPECT_CALL, EXPECT_TRUE, testing::Invoke(), folly::EventBase::loopForever(), socket_, and folly::EventBase::terminateLoopSoon().

                                                 {
  socket_->resumeRead(&readCb);
  socket_->setErrMessageCallback(&err);
  folly::SocketAddress addr("127.0.0.1", 10000);
  bool errRecvd = false;
  EXPECT_CALL(err, errMessage_(_)).WillOnce(Invoke([this, &errRecvd](auto&) {
    errRecvd = true;
    socket_->close();
    evb_.terminateLoopSoon();
  }));
  socket_->write(addr, folly::IOBuf::copyBuffer("hey"));
  socket_->write(addr, folly::IOBuf::copyBuffer("hey"));
  evb_.loopForever();
  EXPECT_TRUE(errRecvd);
}

TEST_F	(	AsyncUDPSocketTest	,
		TestNonExistentServerNoErrCb
	)

Definition at line 584 of file AsyncUDPSocketTest.cpp.

References testing::_, addr, folly::IOBuf::copyBuffer(), evb_, EXPECT_CALL, EXPECT_FALSE, testing::Invoke(), folly::EventBase::loopForever(), ON_CALL, folly::IOBufQueue::preallocate(), fizz::detail::readBuf(), folly::HHWheelTimer::scheduleTimeoutFn(), socket_, folly::EventBase::terminateLoopSoon(), and folly::EventBase::timer().

                                                         {
  socket_->resumeRead(&readCb);
  folly::SocketAddress addr("127.0.0.1", 10000);
  bool errRecvd = false;
  folly::IOBufQueue readBuf;
  EXPECT_CALL(readCb, getReadBuffer_(_, _))
      .WillRepeatedly(Invoke([&readBuf](void** buf, size_t* len) {
        auto readSpace = readBuf.preallocate(2000, 10000);
        *buf = readSpace.first;
        *len = readSpace.second;
      }));
  ON_CALL(readCb, onReadError_(_)).WillByDefault(Invoke([&errRecvd](auto& ex) {
    LOG(ERROR) << ex.what();
    errRecvd = true;
  }));
  socket_->write(addr, folly::IOBuf::copyBuffer("hey"));
  evb_.timer().scheduleTimeoutFn(
      [&] { evb_.terminateLoopSoon(); }, std::chrono::milliseconds(30));
  evb_.loopForever();
  EXPECT_FALSE(errRecvd);
}

TEST_F	(	AsyncUDPSocketTest	,
		TestBound
	)

Definition at line 606 of file AsyncUDPSocketTest.cpp.

References folly::AsyncUDPSocket::bind(), evb_, EXPECT_FALSE, EXPECT_TRUE, folly::AsyncUDPSocket::isBound(), and folly::netops::socket().

                                      {
  AsyncUDPSocket socket(&evb_);
  EXPECT_FALSE(socket.isBound());
  folly::SocketAddress address("0.0.0.0", 0);
  socket.bind(address);
  EXPECT_TRUE(socket.isBound());
}

TEST_F	(	AsyncUDPSocketTest	,
		TestAttachAfterDetachEvbWithReadCallback
	)

Definition at line 614 of file AsyncUDPSocketTest.cpp.

References evb_, EXPECT_FALSE, EXPECT_TRUE, and socket_.

                                                                     {
  socket_->resumeRead(&readCb);
  EXPECT_TRUE(socket_->isHandlerRegistered());
  socket_->detachEventBase();
  EXPECT_FALSE(socket_->isHandlerRegistered());
  socket_->attachEventBase(&evb_);
  EXPECT_TRUE(socket_->isHandlerRegistered());
}

TEST_F	(	AsyncUDPSocketTest	,
		TestAttachAfterDetachEvbNoReadCallback
	)

Definition at line 623 of file AsyncUDPSocketTest.cpp.

References evb_, EXPECT_FALSE, and socket_.

                                                                   {
  EXPECT_FALSE(socket_->isHandlerRegistered());
  socket_->detachEventBase();
  EXPECT_FALSE(socket_->isHandlerRegistered());
  socket_->attachEventBase(&evb_);
  EXPECT_FALSE(socket_->isHandlerRegistered());
}

TEST_F	(	AsyncUDPSocketTest	,
		TestDetachAttach
	)

Definition at line 631 of file AsyncUDPSocketTest.cpp.

References testing::_, folly::IOBuf::copyBuffer(), data, evb_, EXPECT_CALL, EXPECT_EQ, testing::Invoke(), folly::EventBase::loopForever(), folly::EventBase::loopOnce(), now(), folly::EventBase::runInEventBaseThread(), folly::EventBase::runInEventBaseThreadAndWait(), socket_, folly::pushmi::detail::t, and folly::EventBase::terminateLoopSoon().

                                             {
  folly::EventBase evb2;
  auto writeSocket = std::make_shared<folly::AsyncUDPSocket>(&evb_);
  folly::SocketAddress address("127.0.0.1", 0);
  writeSocket->bind(address);
  std::array<uint8_t, 1024> data;
  std::atomic<int> packetsRecvd{0};
  EXPECT_CALL(readCb, getReadBuffer_(_, _))
      .WillRepeatedly(Invoke([&](void** buf, size_t* len) {
        *buf = data.data();
        *len = 1024;
      }));
  EXPECT_CALL(readCb, onDataAvailable_(_, _, _))
      .WillRepeatedly(Invoke(
          [&](const folly::SocketAddress&, size_t, bool) { packetsRecvd++; }));
  socket_->resumeRead(&readCb);
  writeSocket->write(socket_->address(), folly::IOBuf::copyBuffer("hello"));
  while (packetsRecvd != 1) {
    evb_.loopOnce();
  }
  EXPECT_EQ(packetsRecvd, 1);

  socket_->detachEventBase();
  std::thread t([&] { evb2.loopForever(); });
  evb2.runInEventBaseThreadAndWait([&] { socket_->attachEventBase(&evb2); });
  writeSocket->write(socket_->address(), folly::IOBuf::copyBuffer("hello"));
  auto now = std::chrono::steady_clock::now();
  while (packetsRecvd != 2 ||
         std::chrono::steady_clock::now() <
             now + std::chrono::milliseconds(10)) {
    std::this_thread::sleep_for(std::chrono::milliseconds(1));
  }
  evb2.runInEventBaseThread([&] {
    socket_ = nullptr;
    evb2.terminateLoopSoon();
  });
  t.join();
  EXPECT_EQ(packetsRecvd, 2);
}