PipelineTest.cpp File Reference

#include <wangle/channel/Handler.h>
#include <wangle/channel/Pipeline.h>
#include <wangle/channel/StaticPipeline.h>
#include <wangle/channel/AsyncSocketHandler.h>
#include <wangle/channel/OutputBufferingHandler.h>
#include <wangle/channel/test/MockHandler.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <boost/thread/barrier.hpp>

Go to the source code of this file.

Classes
class	IntHandler2
class	ConcreteHandler< Rin, Rout, Win, Wout >

Typedefs
typedef StrictMock< MockHandlerAdapter< int, int > >	IntHandler
typedef HandlerAdapter< std::string, std::string >	StringHandler
typedef ConcreteHandler< int, std::string >	IntToStringHandler
typedef ConcreteHandler< std::string, int >	StringToIntHandler

Functions
	ACTION (FireRead)
	ACTION (FireReadEOF)
	ACTION (FireReadException)
	ACTION (FireWrite)
	ACTION (FireClose)
	TEST (PipelineTest, RealHandlersCompile)
	TEST (PipelineTest, FireActions)
	TEST (PipelineTest, ReachEndOfPipeline)
	TEST (PipelineTest, TurnAround)
	TEST (PipelineTest, DynamicFireActions)
	TEST (PipelineTest, DynamicAttachDetachOrder)
	TEST (PipelineTest, GetContext)
	TEST (PipelineTest, HandlerInMultiplePipelines)
	TEST (PipelineTest, HandlerInPipelineTwice)
	TEST (PipelineTest, NoDetachOnOwner)
	TEST (Pipeline, MissingInboundOrOutbound)
	TEST (Pipeline, DynamicConstruction)
	TEST (Pipeline, RemovePointer)
	TEST (Pipeline, RemoveFront)
	TEST (Pipeline, RemoveBack)
	TEST (Pipeline, RemoveType)
	TEST (Pipeline, Concurrent)
	TEST (PipelineTest, NumHandler)
	TEST (PipelineTest, HandlerReuse)

Typedef Documentation

typedef StrictMock<MockHandlerAdapter<int, int> > IntHandler

Definition at line 31 of file PipelineTest.cpp.

typedef ConcreteHandler<int, std::string> IntToStringHandler

Definition at line 274 of file PipelineTest.cpp.

typedef HandlerAdapter<std::string, std::string> StringHandler

Definition at line 273 of file PipelineTest.cpp.

typedef ConcreteHandler<std::string, int> StringToIntHandler

Definition at line 275 of file PipelineTest.cpp.

Function Documentation

ACTION

(

FireRead

)

Definition at line 34 of file PipelineTest.cpp.

                 {
  arg0->fireRead(arg1);
}

ACTION

(

FireReadEOF

)

Definition at line 38 of file PipelineTest.cpp.

                    {
  arg0->fireReadEOF();
}

ACTION

(

FireReadException

)

Definition at line 42 of file PipelineTest.cpp.

                          {
  arg0->fireReadException(arg1);
}

ACTION

(

FireWrite

)

Definition at line 46 of file PipelineTest.cpp.

                  {
  arg0->fireWrite(arg1);
}

ACTION

(

FireClose

)

Definition at line 50 of file PipelineTest.cpp.

                  {
  arg0->fireClose();
}

TEST	(	PipelineTest	,
		RealHandlersCompile
	)

Definition at line 55 of file PipelineTest.cpp.

References EXPECT_TRUE, folly::AsyncSocket::newSocket(), and folly::netops::socket().

                                        {
  EventBase eb;
  auto socket = AsyncSocket::newSocket(&eb);
  // static
  {
    auto pipeline = StaticPipeline<IOBufQueue&, std::unique_ptr<IOBuf>,
      AsyncSocketHandler,
      OutputBufferingHandler>::create(
        AsyncSocketHandler(socket),
        OutputBufferingHandler());
    EXPECT_TRUE(pipeline->getHandler<AsyncSocketHandler>());
    EXPECT_TRUE(pipeline->getHandler<OutputBufferingHandler>());
  }
  // dynamic
  {
    auto pipeline = Pipeline<IOBufQueue&, std::unique_ptr<IOBuf>>::create();
    (*pipeline)
      .addBack(AsyncSocketHandler(socket))
      .addBack(OutputBufferingHandler())
      .finalize();
    EXPECT_TRUE(pipeline->getHandler<AsyncSocketHandler>());
    EXPECT_TRUE(pipeline->getHandler<OutputBufferingHandler>());
  }
}

TEST	(	PipelineTest	,
		FireActions
	)

Definition at line 81 of file PipelineTest.cpp.

References testing::_, EXPECT_CALL, and EXPECT_NO_THROW.

                                {
  IntHandler handler1;
  IntHandler2 handler2;

  {
    InSequence sequence;
    EXPECT_CALL(handler2, attachPipeline(_));
    EXPECT_CALL(handler1, attachPipeline(_));
  }

  auto pipeline = StaticPipeline<int, int, IntHandler, IntHandler2>::create(
      &handler1, &handler2);

  EXPECT_CALL(handler1, read_(_, _)).WillOnce(FireRead());
  EXPECT_CALL(handler2, read_(_, _)).Times(1);
  pipeline->read(1);

  EXPECT_CALL(handler1, readEOF(_)).WillOnce(FireReadEOF());
  EXPECT_CALL(handler2, readEOF(_)).Times(1);
  pipeline->readEOF();

  EXPECT_CALL(handler1, readException(_, _)).WillOnce(FireReadException());
  EXPECT_CALL(handler2, readException(_, _)).Times(1);
  pipeline->readException(make_exception_wrapper<std::runtime_error>("blah"));

  EXPECT_CALL(handler2, write_(_, _)).WillOnce(FireWrite());
  EXPECT_CALL(handler1, write_(_, _)).Times(1);
  EXPECT_NO_THROW(pipeline->write(1).value());

  EXPECT_CALL(handler2, close_(_)).WillOnce(FireClose());
  EXPECT_CALL(handler1, close_(_)).Times(1);
  EXPECT_NO_THROW(pipeline->close().value());

  {
    InSequence sequence;
    EXPECT_CALL(handler1, detachPipeline(_));
    EXPECT_CALL(handler2, detachPipeline(_));
  }
}

TEST	(	PipelineTest	,
		ReachEndOfPipeline
	)

Definition at line 123 of file PipelineTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_NO_THROW, and handler().

                                       {
  IntHandler handler;
  EXPECT_CALL(handler, attachPipeline(_));
  auto pipeline = StaticPipeline<int, int, IntHandler>::create(&handler);

  EXPECT_CALL(handler, read_(_, _)).WillOnce(FireRead());
  pipeline->read(1);

  EXPECT_CALL(handler, readEOF(_)).WillOnce(FireReadEOF());
  pipeline->readEOF();

  EXPECT_CALL(handler, readException(_, _)).WillOnce(FireReadException());
  pipeline->readException(make_exception_wrapper<std::runtime_error>("blah"));

  EXPECT_CALL(handler, write_(_, _)).WillOnce(FireWrite());
  EXPECT_NO_THROW(pipeline->write(1).value());

  EXPECT_CALL(handler, close_(_)).WillOnce(FireClose());
  EXPECT_NO_THROW(pipeline->close().value());

  EXPECT_CALL(handler, detachPipeline(_));
}

TEST	(	PipelineTest	,
		TurnAround
	)

Definition at line 147 of file PipelineTest.cpp.

References testing::_, and EXPECT_CALL.

                               {
  IntHandler handler1;
  IntHandler2 handler2;

  {
    InSequence sequence;
    EXPECT_CALL(handler2, attachPipeline(_));
    EXPECT_CALL(handler1, attachPipeline(_));
  }

  auto pipeline = StaticPipeline<int, int, IntHandler, IntHandler2>::create(
      &handler1, &handler2);

  EXPECT_CALL(handler1, read_(_, _)).WillOnce(FireRead());
  EXPECT_CALL(handler2, read_(_, _)).WillOnce(FireWrite());
  EXPECT_CALL(handler1, write_(_, _)).Times(1);
  pipeline->read(1);

  {
    InSequence sequence;
    EXPECT_CALL(handler1, detachPipeline(_));
    EXPECT_CALL(handler2, detachPipeline(_));
  }
}

TEST	(	PipelineTest	,
		DynamicFireActions
	)

Definition at line 172 of file PipelineTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_NO_THROW, and EXPECT_TRUE.

                                       {
  IntHandler handler1, handler2, handler3;
  EXPECT_CALL(handler2, attachPipeline(_));
  auto pipeline = StaticPipeline<int, int, IntHandler>::create(&handler2);


  {
    InSequence sequence;
    EXPECT_CALL(handler3, attachPipeline(_));
    EXPECT_CALL(handler1, attachPipeline(_));
  }

  (*pipeline)
    .addFront(&handler1)
    .addBack(&handler3)
    .finalize();

  EXPECT_TRUE(pipeline->getHandler<IntHandler>(0));
  EXPECT_TRUE(pipeline->getHandler<IntHandler>(1));
  EXPECT_TRUE(pipeline->getHandler<IntHandler>(2));

  EXPECT_CALL(handler1, read_(_, _)).WillOnce(FireRead());
  EXPECT_CALL(handler2, read_(_, _)).WillOnce(FireRead());
  EXPECT_CALL(handler3, read_(_, _)).Times(1);
  pipeline->read(1);

  EXPECT_CALL(handler3, write_(_, _)).WillOnce(FireWrite());
  EXPECT_CALL(handler2, write_(_, _)).WillOnce(FireWrite());
  EXPECT_CALL(handler1, write_(_, _)).Times(1);
  EXPECT_NO_THROW(pipeline->write(1).value());

  {
    InSequence sequence;
    EXPECT_CALL(handler1, detachPipeline(_));
    EXPECT_CALL(handler2, detachPipeline(_));
    EXPECT_CALL(handler3, detachPipeline(_));
  }
}

TEST	(	PipelineTest	,
		DynamicAttachDetachOrder
	)

Definition at line 211 of file PipelineTest.cpp.

References testing::_, and EXPECT_CALL.

                                             {
  IntHandler handler1, handler2;
  auto pipeline = Pipeline<int, int>::create();
  {
    InSequence sequence;
    EXPECT_CALL(handler2, attachPipeline(_));
    EXPECT_CALL(handler1, attachPipeline(_));
  }
  (*pipeline)
    .addBack(&handler1)
    .addBack(&handler2)
    .finalize();
  {
    InSequence sequence;
    EXPECT_CALL(handler1, detachPipeline(_));
    EXPECT_CALL(handler2, detachPipeline(_));
  }
}

TEST	(	PipelineTest	,
		GetContext
	)

Definition at line 230 of file PipelineTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_TRUE, and handler().

                               {
  IntHandler handler;
  EXPECT_CALL(handler, attachPipeline(_));
  auto pipeline = StaticPipeline<int, int, IntHandler>::create(&handler);
  EXPECT_TRUE(handler.getContext());
  EXPECT_CALL(handler, detachPipeline(_));
}

TEST	(	PipelineTest	,
		HandlerInMultiplePipelines
	)

Definition at line 238 of file PipelineTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_FALSE, and handler().

                                               {
  IntHandler handler;
  EXPECT_CALL(handler, attachPipeline(_)).Times(2);
  auto pipeline1 = StaticPipeline<int, int, IntHandler>::create(&handler);
  auto pipeline2 = StaticPipeline<int, int, IntHandler>::create(&handler);
  EXPECT_FALSE(handler.getContext());
  EXPECT_CALL(handler, detachPipeline(_)).Times(2);
}

TEST	(	PipelineTest	,
		HandlerInPipelineTwice
	)

Definition at line 247 of file PipelineTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_FALSE, and handler().

                                           {
  auto handler = std::make_shared<IntHandler>();
  EXPECT_CALL(*handler, attachPipeline(_)).Times(2);
  auto pipeline = Pipeline<int, int>::create();
  pipeline->addBack(handler);
  pipeline->addBack(handler);
  pipeline->finalize();
  EXPECT_FALSE(handler->getContext());
  EXPECT_CALL(*handler, detachPipeline(_)).Times(2);
}

TEST	(	PipelineTest	,
		NoDetachOnOwner
	)

Definition at line 258 of file PipelineTest.cpp.

References testing::_, EXPECT_CALL, and handler().

                                    {
  IntHandler handler;
  EXPECT_CALL(handler, attachPipeline(_));
  auto pipeline = StaticPipeline<int, int, IntHandler>::create(&handler);
  pipeline->setOwner(&handler);
}

TEST	(	Pipeline	,
		MissingInboundOrOutbound
	)

Definition at line 277 of file PipelineTest.cpp.

References EXPECT_THROW.

                                         {
  auto pipeline = Pipeline<int, int>::create();
  (*pipeline)
    .addBack(HandlerAdapter<std::string, std::string>{})
    .finalize();
  EXPECT_THROW(pipeline->read(0), std::invalid_argument);
  EXPECT_THROW(pipeline->readEOF(), std::invalid_argument);
  EXPECT_THROW(
      pipeline->readException(exception_wrapper(std::runtime_error("blah"))),
      std::invalid_argument);
  EXPECT_THROW(pipeline->write(0), std::invalid_argument);
  EXPECT_THROW(pipeline->close(), std::invalid_argument);
}

TEST	(	Pipeline	,
		DynamicConstruction
	)

Definition at line 291 of file PipelineTest.cpp.

References EXPECT_NO_THROW.

                                    {
  {
    auto pipeline = Pipeline<std::string, std::string>::create();
    pipeline->addBack(StringHandler());
    pipeline->addBack(StringHandler());

    // Exercise both addFront and addBack. Final pipeline is
    // StI <-> ItS <-> StS <-> StS <-> StI <-> ItS
    EXPECT_NO_THROW(
      (*pipeline)
        .addFront(IntToStringHandler{})
        .addFront(StringToIntHandler{})
        .addBack(StringToIntHandler{})
        .addBack(IntToStringHandler{})
        .finalize());
  }
}

TEST	(	Pipeline	,
		RemovePointer
	)

Definition at line 309 of file PipelineTest.cpp.

References testing::_, and EXPECT_CALL.

                              {
  IntHandler handler1, handler2;
  EXPECT_CALL(handler1, attachPipeline(_));
  EXPECT_CALL(handler2, attachPipeline(_));
  auto pipeline = Pipeline<int, int>::create();
  (*pipeline)
    .addBack(&handler1)
    .addBack(&handler2)
    .finalize();

  EXPECT_CALL(handler1, detachPipeline(_));
  (*pipeline)
    .remove(&handler1)
    .finalize();

  EXPECT_CALL(handler2, read_(_, _));
  pipeline->read(1);

  EXPECT_CALL(handler2, detachPipeline(_));
}

TEST	(	Pipeline	,
		RemoveFront
	)

Definition at line 330 of file PipelineTest.cpp.

References testing::_, and EXPECT_CALL.

                            {
  IntHandler handler1, handler2;
  EXPECT_CALL(handler1, attachPipeline(_));
  EXPECT_CALL(handler2, attachPipeline(_));
  auto pipeline = Pipeline<int, int>::create();
  (*pipeline)
    .addBack(&handler1)
    .addBack(&handler2)
    .finalize();

  EXPECT_CALL(handler1, detachPipeline(_));
  (*pipeline)
    .removeFront()
    .finalize();

  EXPECT_CALL(handler2, read_(_, _));
  pipeline->read(1);

  EXPECT_CALL(handler2, detachPipeline(_));
}

TEST	(	Pipeline	,
		RemoveBack
	)

Definition at line 351 of file PipelineTest.cpp.

References testing::_, and EXPECT_CALL.

                           {
  IntHandler handler1, handler2;
  EXPECT_CALL(handler1, attachPipeline(_));
  EXPECT_CALL(handler2, attachPipeline(_));
  auto pipeline = Pipeline<int, int>::create();
  (*pipeline)
    .addBack(&handler1)
    .addBack(&handler2)
    .finalize();

  EXPECT_CALL(handler2, detachPipeline(_));
  (*pipeline)
    .removeBack()
    .finalize();

  EXPECT_CALL(handler1, read_(_, _));
  pipeline->read(1);

  EXPECT_CALL(handler1, detachPipeline(_));
}

TEST	(	Pipeline	,
		RemoveType
	)

Definition at line 372 of file PipelineTest.cpp.

References testing::_, and EXPECT_CALL.

                           {
  IntHandler handler1;
  IntHandler2 handler2;
  EXPECT_CALL(handler1, attachPipeline(_));
  EXPECT_CALL(handler2, attachPipeline(_));
  auto pipeline = Pipeline<int, int>::create();
  (*pipeline)
    .addBack(&handler1)
    .addBack(&handler2)
    .finalize();

  EXPECT_CALL(handler1, detachPipeline(_));
  (*pipeline)
    .remove<IntHandler>()
    .finalize();

  EXPECT_CALL(handler2, read_(_, _));
  pipeline->read(1);

  EXPECT_CALL(handler2, detachPipeline(_));
}

TEST	(	Pipeline	,
		Concurrent
	)

Definition at line 397 of file PipelineTest.cpp.

References b, i, and folly::pushmi::detail::t.

                           {
  NiceMock<MockHandlerAdapter<int, int>> handler1, handler2;
  auto pipeline = Pipeline<int, int>::create();
  (*pipeline)
    .addBack(&handler1)
    .addBack(&handler2)
    .finalize();
  boost::barrier b{2};
  auto spam = [&]{
    for  (int i = 0; i < 100000; i++) {
      b.wait();
      pipeline->read(i);
    }
  };
  std::thread t(spam);
  spam();
  t.join();
}

TEST	(	PipelineTest	,
		NumHandler
	)

Definition at line 416 of file PipelineTest.cpp.

References EXPECT_EQ.

                               {
  NiceMock<MockHandlerAdapter<int, int>> handler1, handler2;
  auto pipeline = Pipeline<int, int>::create();
  EXPECT_EQ(0, pipeline->numHandlers());

  pipeline->addBack(&handler1);
  EXPECT_EQ(1, pipeline->numHandlers());

  pipeline->addBack(&handler2);
  EXPECT_EQ(2, pipeline->numHandlers());

  pipeline->finalize();
  EXPECT_EQ(2, pipeline->numHandlers());

  pipeline->remove(&handler1);
  EXPECT_EQ(1, pipeline->numHandlers());

  pipeline->remove(&handler2);
  EXPECT_EQ(0, pipeline->numHandlers());
}

TEST	(	PipelineTest	,
		HandlerReuse
	)

Definition at line 438 of file PipelineTest.cpp.

References ASSERT_EQ, and EXPECT_NE.

                                 {
  NiceMock<MockHandlerAdapter<int, int>> handler1, handler2, handler3;
  auto pipeline1 = Pipeline<int, int>::create();

  // pipeline1 contains the first two handlers
  (*pipeline1)
    .addBack(&handler1)
    .addBack(&handler2)
    .finalize();
  pipeline1->read(42);
  EXPECT_NE(nullptr, handler2.getContext());

  // Close and detach the back handler (#2)
  pipeline1->close();
  pipeline1->removeBack();
  ASSERT_EQ(nullptr, handler2.getContext());

  auto pipeline2 = Pipeline<int, int>::create();
  (*pipeline2)
    .addBack(&handler2)
    .addBack(&handler3)
    .finalize();
  pipeline2->read(24);
  EXPECT_NE(nullptr, handler2.getContext());

  // detach both
  pipeline2->remove(&handler2);
  pipeline2->remove(&handler3);
  ASSERT_EQ(nullptr, handler2.getContext());
  ASSERT_EQ(nullptr, handler3.getContext());

  auto pipeline3 = Pipeline<int, int>::create();
  (*pipeline3)
    .addBack(&handler2)
    .addBack(&handler3)
    .finalize();
  pipeline3->read(1);
  EXPECT_NE(nullptr, handler2.getContext());
}