HTTPUpstreamTest< C > Class Template Reference

Inheritance diagram for HTTPUpstreamTest< C >:

Public Member Functions
	HTTPUpstreamTest (std::vector< int64_t > flowControl={-1,-1,-1})
void	resumeWrites ()
virtual void	onWriteChain (folly::AsyncTransportWrapper::WriteCallback *callback, std::shared_ptr< IOBuf > iob, WriteFlags)
void	handleWrite (folly::AsyncTransportWrapper::WriteCallback *callback)
void	SetUp () override
void	commonSetUp (unique_ptr< HTTPCodec > codec)
unique_ptr< typename C::Codec >	makeServerCodec ()
void	enableExHeader (typename C::Codec *serverCodec)
void	parseOutput (HTTPCodec &serverCodec)
void	readAndLoop (const std::string &input)
void	readAndLoop (IOBuf *buf)
void	readAndLoop (const uint8_t *input, size_t length)
void	testBasicRequest ()
void	testBasicRequestHttp10 (bool keepalive)
void	onCreate (const HTTPSessionBase &) override
void	onDestroy (const HTTPSessionBase &) override
void	onSettingsOutgoingStreamsFull (const HTTPSessionBase &) override
void	onSettingsOutgoingStreamsNotFull (const HTTPSessionBase &) override
void	TearDown () override
std::unique_ptr< StrictMock< MockHTTPHandler > >	openTransaction (bool expectStartPaused=false)
std::unique_ptr< NiceMock< MockHTTPHandler > >	openNiceTransaction (bool expectStartPaused=false)
void	testSimpleUpgrade (const std::string &upgradeReqHeader, const std::string &upgradeRespHeader, CodecProtocol respCodecVersion)
MockByteEventTracker *	setMockByteEventTracker ()
Public Member Functions inherited from testing::Test
virtual	~Test ()
virtual	~Test ()
virtual	~Test ()
Public Member Functions inherited from proxygen::HTTPSessionBase::InfoCallback
virtual	~InfoCallback ()
virtual void	onFullHandshakeCompletion (const HTTPSessionBase &)
virtual void	onIngressError (const HTTPSessionBase &, ProxygenError)
virtual void	onIngressEOF ()
virtual void	onRead (const HTTPSessionBase &, size_t)
virtual void	onWrite (const HTTPSessionBase &, size_t)
virtual void	onRequestBegin (const HTTPSessionBase &)
virtual void	onRequestEnd (const HTTPSessionBase &, uint32_t)
virtual void	onActivateConnection (const HTTPSessionBase &)
virtual void	onDeactivateConnection (const HTTPSessionBase &)
virtual void	onIngressMessage (const HTTPSessionBase &, const HTTPMessage &)
virtual void	onIngressLimitExceeded (const HTTPSessionBase &)
virtual void	onIngressPaused (const HTTPSessionBase &)
virtual void	onTransactionDetached (const HTTPSessionBase &)
virtual void	onPingReplySent (int64_t)
virtual void	onPingReplyReceived ()
virtual void	onFlowControlWindowClosed (const HTTPSessionBase &)
virtual void	onEgressBuffered (const HTTPSessionBase &)
virtual void	onEgressBufferCleared (const HTTPSessionBase &)
virtual void	onSettings (const HTTPSessionBase &, const SettingsList &)
virtual void	onSettingsAck (const HTTPSessionBase &)

Protected Attributes
bool	sessionCreated_ {false}
bool	sessionDestroyed_ {false}
bool	transactionsFull_ {false}
bool	transportGood_ {true}
EventBase	eventBase_
EventBase *	eventBasePtr_ {&eventBase_}
MockAsyncTransport *	transport_
folly::AsyncTransportWrapper::ReadCallback *	readCallback_ {nullptr}
folly::AsyncTransport::ReplaySafetyCallback *	replaySafetyCallback_ {nullptr}
folly::HHWheelTimer::UniquePtr	transactionTimeouts_
std::vector< int64_t >	flowControl_
wangle::TransportInfo	mockTransportInfo_
SocketAddress	localAddr_ {"127.0.0.1", 80}
SocketAddress	peerAddr_ {"127.0.0.1", 12345}
HTTPUpstreamSession *	httpSession_ {nullptr}
IOBufQueue	writes_ {IOBufQueue::cacheChainLength()}
std::vector< folly::AsyncTransportWrapper::WriteCallback * >	cbs_
bool	failWrites_ {false}
bool	pauseWrites_ {false}
bool	writeInLoop_ {false}

Additional Inherited Members
Public Types inherited from testing::Test
typedef internal::SetUpTestCaseFunc	SetUpTestCaseFunc
typedef internal::TearDownTestCaseFunc	TearDownTestCaseFunc
typedef internal::SetUpTestCaseFunc	SetUpTestCaseFunc
typedef internal::TearDownTestCaseFunc	TearDownTestCaseFunc
typedef internal::SetUpTestCaseFunc	SetUpTestCaseFunc
typedef internal::TearDownTestCaseFunc	TearDownTestCaseFunc
Static Public Member Functions inherited from testing::Test
static void	SetUpTestCase ()
static void	TearDownTestCase ()
static bool	HasFatalFailure ()
static bool	HasNonfatalFailure ()
static bool	HasFailure ()
static void	RecordProperty (const std::string &key, const std::string &value)
static void	RecordProperty (const std::string &key, int value)
static void	SetUpTestCase ()
static void	TearDownTestCase ()
static bool	HasFatalFailure ()
static bool	HasNonfatalFailure ()
static bool	HasFailure ()
static void	RecordProperty (const std::string &key, const std::string &value)
static void	RecordProperty (const std::string &key, int value)
static void	SetUpTestCase ()
static void	TearDownTestCase ()
static bool	HasFatalFailure ()
static bool	HasNonfatalFailure ()
static bool	HasFailure ()
static void	RecordProperty (const std::string &key, const std::string &value)
static void	RecordProperty (const std::string &key, int value)
Protected Member Functions inherited from testing::Test
	Test ()
	Test ()
	Test ()

Detailed Description

template<class C>
class HTTPUpstreamTest< C >

Definition at line 136 of file HTTPUpstreamSessionTest.cpp.

Constructor & Destructor Documentation

template<class C>

HTTPUpstreamTest< C >::HTTPUpstreamTest ( std::vector< int64_t >  flowControl = {-1, -1, -1} )

inlineexplicit

Definition at line 139 of file HTTPUpstreamSessionTest.cpp.

                                                             {-1, -1, -1})
      : eventBase_(),
        transport_(new NiceMock<MockAsyncTransport>()),
        transactionTimeouts_(folly::HHWheelTimer::newTimer(
            &eventBase_,
            std::chrono::milliseconds(
                folly::HHWheelTimer::DEFAULT_TICK_INTERVAL),
            TimeoutManager::InternalEnum::INTERNAL,
            std::chrono::milliseconds(500))),
        flowControl_(flowControl) {}

Member Function Documentation

template<class C>

void HTTPUpstreamTest< C >::commonSetUp ( unique_ptr< HTTPCodec >  codec )

inline

Definition at line 191 of file HTTPUpstreamSessionTest.cpp.

                                                {
    HTTPSession::setDefaultReadBufferLimit(65536);
    HTTPSession::setDefaultWriteBufferLimit(65536);
    EXPECT_CALL(*transport_, writeChain(_, _, _))
      .WillRepeatedly(Invoke(this, &HTTPUpstreamTest<C>::onWriteChain));
    EXPECT_CALL(*transport_, setReadCB(_))
      .WillRepeatedly(SaveArg<0>(&readCallback_));
    EXPECT_CALL(*transport_, getReadCB())
      .WillRepeatedly(Return(readCallback_));
    EXPECT_CALL(*transport_, getEventBase())
      .WillRepeatedly(ReturnPointee(&eventBasePtr_));
    EXPECT_CALL(*transport_, good())
      .WillRepeatedly(ReturnPointee(&transportGood_));
    EXPECT_CALL(*transport_, closeNow())
      .WillRepeatedly(Assign(&transportGood_, false));
    EXPECT_CALL(*transport_, isReplaySafe())
      .WillOnce(Return(false));
    EXPECT_CALL(*transport_, setReplaySafetyCallback(_))
      .WillRepeatedly(SaveArg<0>(&replaySafetyCallback_));
    EXPECT_CALL(*transport_, attachEventBase(_))
      .WillRepeatedly(SaveArg<0>(&eventBasePtr_));

    for (auto& param: flowControl_) {
      if (param < 0) {
        param = codec->getDefaultWindowSize();
      }
    }
    httpSession_ = new HTTPUpstreamSession(
      transactionTimeouts_.get(),
      std::move(AsyncTransportWrapper::UniquePtr(transport_)),
      localAddr_, peerAddr_,
      std::move(codec),
      mockTransportInfo_, this);
    httpSession_->setFlowControl(flowControl_[0], flowControl_[1],
                                 flowControl_[2]);
    httpSession_->setMaxConcurrentOutgoingStreams(10);
    httpSession_->setEgressSettings({{SettingsId::ENABLE_EX_HEADERS, 1}});
    httpSession_->startNow();
    eventBase_.loop();
    ASSERT_EQ(this->sessionDestroyed_, false);
  }

template<class C>

void HTTPUpstreamTest< C >::enableExHeader ( typename C::Codec *  serverCodec )

inline

Definition at line 237 of file HTTPUpstreamSessionTest.cpp.

                                                   {
    if (!serverCodec || serverCodec->getProtocol() != CodecProtocol::HTTP_2) {
      return;
    }

    auto clientCodec = makeClientCodec<HTTP2Codec>(2);
    folly::IOBufQueue c2s{IOBufQueue::cacheChainLength()};
    clientCodec->getEgressSettings()->setSetting(
      SettingsId::ENABLE_EX_HEADERS, 1);
    clientCodec->generateConnectionPreface(c2s);
    clientCodec->generateSettings(c2s);

    // set ENABLE_EX_HEADERS to 1 in egressSettings
    serverCodec->getEgressSettings()->setSetting(
      SettingsId::ENABLE_EX_HEADERS, 1);
    // set ENABLE_EX_HEADERS to 1 in ingressSettings
    auto setup = c2s.move();
    serverCodec->onIngress(*setup);
  }

template<class C>

void HTTPUpstreamTest< C >::handleWrite ( folly::AsyncTransportWrapper::WriteCallback *  callback )

inline

Definition at line 172 of file HTTPUpstreamSessionTest.cpp.

                                                                      {
    if (failWrites_) {
      AsyncSocketException ex(AsyncSocketException::UNKNOWN, "");
      callback->writeErr(0, ex);
    } else {
      if (writeInLoop_) {
        eventBase_.runInLoop([&] {
            callback->writeSuccess();
          });
      } else {
        callback->writeSuccess();
      }
    }
  }

template<class C>

unique_ptr<typename C::Codec> HTTPUpstreamTest< C >::makeServerCodec ( )

inline

Definition at line 233 of file HTTPUpstreamSessionTest.cpp.

                                                {
    return ::makeServerCodec<typename C::Codec>(C::version);
  }

template<class C>

void HTTPUpstreamTest< C >::onCreate ( const HTTPSessionBase &  )

inlineoverridevirtual

Reimplemented from proxygen::HTTPSessionBase::InfoCallback.

Definition at line 297 of file HTTPUpstreamSessionTest.cpp.

{ sessionCreated_ = true; }

template<class C>

void HTTPUpstreamTest< C >::onDestroy ( const HTTPSessionBase &  )

inlineoverridevirtual

Reimplemented from proxygen::HTTPSessionBase::InfoCallback.

Definition at line 298 of file HTTPUpstreamSessionTest.cpp.

{ sessionDestroyed_ = true; }

template<class C>

void HTTPUpstreamTest< C >::onSettingsOutgoingStreamsFull ( const HTTPSessionBase &  )

inlineoverridevirtual

Reimplemented from proxygen::HTTPSessionBase::InfoCallback.

Definition at line 299 of file HTTPUpstreamSessionTest.cpp.

                                                                      {
    transactionsFull_ = true;
  }

template<class C>

void HTTPUpstreamTest< C >::onSettingsOutgoingStreamsNotFull ( const HTTPSessionBase &  )

inlineoverridevirtual

Reimplemented from proxygen::HTTPSessionBase::InfoCallback.

Definition at line 302 of file HTTPUpstreamSessionTest.cpp.

                                                                         {
    transactionsFull_ = false;
  }

template<class C>

virtual void HTTPUpstreamTest< C >::onWriteChain ( folly::AsyncTransportWrapper::WriteCallback *  callback, std::shared_ptr< IOBuf >  iob, WriteFlags    )

inlinevirtual

Definition at line 158 of file HTTPUpstreamSessionTest.cpp.

                  {
    if (pauseWrites_) {
      cbs_.push_back(callback);
      return;  // let write requests timeout
    }
    auto mybuf = iob->clone();
    mybuf->unshare();
    writes_.append(std::move(mybuf));
    handleWrite(callback);
  }

template<class C>

std::unique_ptr<NiceMock<MockHTTPHandler> > HTTPUpstreamTest< C >::openNiceTransaction ( bool  expectStartPaused = false )

inline

Definition at line 326 of file HTTPUpstreamSessionTest.cpp.

                                    {
    // Returns a mock handler with txn_ field set in it
    auto handler = std::make_unique<NiceMock<MockHTTPHandler>>();
    handler->expectTransaction();
    if (expectStartPaused) {
      handler->expectEgressPaused();
    }
    auto txn = httpSession_->newTransaction(handler.get());
    EXPECT_EQ(txn, handler->txn_);
    return handler;
  }

template<class C>

std::unique_ptr<StrictMock<MockHTTPHandler> > HTTPUpstreamTest< C >::openTransaction ( bool  expectStartPaused = false )

inline

Definition at line 313 of file HTTPUpstreamSessionTest.cpp.

                                    {
    // Returns a mock handler with txn_ field set in it
    auto handler = std::make_unique<StrictMock<MockHTTPHandler>>();
    handler->expectTransaction();
    if (expectStartPaused) {
      handler->expectEgressPaused();
    }
    auto txn = httpSession_->newTransaction(handler.get());
    EXPECT_EQ(txn, handler->txn_);
    return handler;
  }

template<class C>

void HTTPUpstreamTest< C >::parseOutput ( HTTPCodec &  serverCodec )

inline

Definition at line 257 of file HTTPUpstreamSessionTest.cpp.

                                           {
    uint32_t consumed = std::numeric_limits<uint32_t>::max();
    while (!writes_.empty() && consumed > 0) {
      consumed = serverCodec.onIngress(*writes_.front());
      writes_.split(consumed);
    }
    EXPECT_TRUE(writes_.empty());
  }

template<class C>

void HTTPUpstreamTest< C >::readAndLoop ( const std::string &  input )

inline

Definition at line 266 of file HTTPUpstreamSessionTest.cpp.

                                           {
    readAndLoop((const uint8_t *)input.data(), input.length());
  }

template<class C>

void HTTPUpstreamTest< C >::readAndLoop ( IOBuf *  buf )

inline

Definition at line 270 of file HTTPUpstreamSessionTest.cpp.

                               {
    buf->coalesce();
    readAndLoop(buf->data(), buf->length());
  }

template<class C>

void HTTPUpstreamTest< C >::readAndLoop ( const uint8_t *  input, size_t  length  )

inline

Definition at line 275 of file HTTPUpstreamSessionTest.cpp.

                                                        {
    CHECK_NOTNULL(readCallback_);
    void* buf;
    size_t bufSize;
    while (length > 0) {
      readCallback_->getReadBuffer(&buf, &bufSize);
      // This is somewhat specific to our implementation, but currently we
      // always return at least some space from getReadBuffer
      CHECK_GT(bufSize, 0);
      bufSize = std::min(bufSize, length);
      memcpy(buf, input, bufSize);
      readCallback_->readDataAvailable(bufSize);
      eventBasePtr_->loop();
      length -= bufSize;
      input += bufSize;
    }
  }

template<class C>

void HTTPUpstreamTest< C >::resumeWrites ( )

inline

Definition at line 150 of file HTTPUpstreamSessionTest.cpp.

                      {
    pauseWrites_ = false;
    for (auto cb: cbs_) {
      handleWrite(cb);
    }
    cbs_.clear();
  }

template<class C>

MockByteEventTracker* HTTPUpstreamTest< C >::setMockByteEventTracker ( )

inline

Definition at line 343 of file HTTPUpstreamSessionTest.cpp.

                                                  {
    auto byteEventTracker = new MockByteEventTracker(nullptr);
    httpSession_->setByteEventTracker(
      std::unique_ptr<ByteEventTracker>(byteEventTracker));
    EXPECT_CALL(*byteEventTracker, preSend(_, _, _))
      .WillRepeatedly(Return(0));
    EXPECT_CALL(*byteEventTracker, drainByteEvents())
      .WillRepeatedly(Return(0));
    EXPECT_CALL(*byteEventTracker, processByteEvents(_, _))
      .WillRepeatedly(Invoke([]
                            (std::shared_ptr<ByteEventTracker> self,
                             uint64_t bytesWritten) {
                              return self->ByteEventTracker::processByteEvents(
                                self,
                                bytesWritten);
                            }));

    return byteEventTracker;
  }

template<class C>

void HTTPUpstreamTest< C >::SetUp ( )

inlineoverridevirtual

Reimplemented from testing::Test.

Definition at line 187 of file HTTPUpstreamSessionTest.cpp.

                        {
    commonSetUp(makeClientCodec<typename C::Codec>(C::version));
  }

template<class C>

void HTTPUpstreamTest< C >::TearDown ( )

inlineoverridevirtual

Reimplemented from testing::Test.

Definition at line 306 of file HTTPUpstreamSessionTest.cpp.

                           {
    AsyncSocketException ex(AsyncSocketException::UNKNOWN, "");
    for (auto& cb : cbs_) {
      cb->writeErr(0, ex);
    }
  }

template<class CodecPair >

void HTTPUpstreamTest< CodecPair >::testBasicRequest

(

)

Definition at line 1028 of file HTTPUpstreamSessionTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, and handler().

                                                   {
  InSequence enforceOrder;

  auto handler = openTransaction();
  handler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_TRUE(msg->getIsChunked());
      EXPECT_FALSE(msg->getIsUpgraded());
      EXPECT_EQ(200, msg->getStatusCode());
    });
  handler->expectEOM();
  handler->expectDetachTransaction();

  handler->sendRequest();
  readAndLoop("HTTP/1.1 200 OK\r\n"
              "Transfer-Encoding: chunked\r\n\r\n"
              "0\r\n\r\n");

  CHECK(httpSession_->supportsMoreTransactions());
  CHECK_EQ(httpSession_->getNumOutgoingStreams(), 0);
}

template<class CodecPair >

void HTTPUpstreamTest< CodecPair >::testBasicRequestHttp10

(

bool

keepalive

)

Definition at line 1099 of file HTTPUpstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, proxygen::getGetRequest(), proxygen::HTTPMessage::getHeaders(), handler(), proxygen::HTTP_HEADER_CONNECTION, proxygen::HTTPHeaders::set(), and proxygen::HTTPMessage::setHTTPVersion().

                                                                       {
  HTTPMessage req = getGetRequest();
  req.setHTTPVersion(1, 0);
  if (keepalive) {
    req.getHeaders().set(HTTP_HEADER_CONNECTION, "Keep-Alive");
  }

  InSequence enforceOrder;

  auto handler = openTransaction();
  handler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_EQ(200, msg->getStatusCode());
      EXPECT_EQ(keepalive ? "keep-alive" : "close",
                msg->getHeaders().getSingleOrEmpty(HTTP_HEADER_CONNECTION));
    });
  EXPECT_CALL(*handler, onBody(_));
  handler->expectEOM();
  handler->expectDetachTransaction();

  handler->sendRequest();
  if (keepalive) {
    readAndLoop("HTTP/1.0 200 OK\r\n"
                "Connection: keep-alive\r\n"
                "Content-length: 7\r\n\r\n"
                "content");
  } else {
    readAndLoop("HTTP/1.0 200 OK\r\n"
                "Connection: close\r\n"
                "Content-length: 7\r\n\r\n"
                "content");
  }
}

template<class CodecPair >

void HTTPUpstreamTest< CodecPair >::testSimpleUpgrade	(	const std::string &	upgradeReqHeader,
		const std::string &	upgradeRespHeader,
		CodecProtocol	respCodecVersion
	)

Definition at line 1422 of file HTTPUpstreamSessionTest.cpp.

References ASSERT_NE, codec, dummy(), EXPECT_CALL, EXPECT_EQ, proxygen::HTTP2Codec::getHeaderIndexingStrategy(), proxygen::getUpgradeRequest(), handler(), and testing::Return().

                                  {
  InSequence dummy;
  auto handler = openTransaction();
  NiceMock<MockUpstreamController> controller;

  httpSession_->setController(&controller);
  EXPECT_CALL(controller, onSessionCodecChange(httpSession_));

  EXPECT_EQ(httpSession_->getMaxConcurrentOutgoingStreams(), 1);

  HeaderIndexingStrategy testH2IndexingStrat;
  if (respCodecVersion == CodecProtocol::HTTP_2) {
    EXPECT_CALL(controller, getHeaderIndexingStrategy())
      .WillOnce(
        Return(&testH2IndexingStrat)
    );
  }

  handler->expectHeaders([] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_EQ(200, msg->getStatusCode());
    });
  handler->expectBody();
  handler->expectEOM();
  handler->expectDetachTransaction();

  auto txn = handler->txn_;
  HTTPMessage req = getUpgradeRequest(upgradeReqHeader);
  txn->sendHeaders(req);
  txn->sendEOM();
  eventBase_.loopOnce(); // force HTTP/1.1 writes
  writes_.move(); // clear them out
  readAndLoop(folly::to<string>("HTTP/1.1 101 Switching Protocols\r\n"
                                "Upgrade: ", upgradeRespHeader, "\r\n"
                                "\r\n"));

  if (respCodecVersion == CodecProtocol::HTTP_2) {
    const HTTP2Codec* codec = dynamic_cast<const HTTP2Codec*>(
      &txn->getTransport().getCodec());
    ASSERT_NE(codec, nullptr);
    EXPECT_EQ(codec->getHeaderIndexingStrategy(), &testH2IndexingStrat);
  }

  readAndLoop(getResponseBuf(respCodecVersion, txn->getID(), 200, 100).get());

  EXPECT_EQ(httpSession_->getMaxConcurrentOutgoingStreams(), 10);
  httpSession_->destroy();
}

Member Data Documentation

template<class C>

std::vector<folly::AsyncTransportWrapper::WriteCallback*> HTTPUpstreamTest< C >::cbs_

protected

Definition at line 382 of file HTTPUpstreamSessionTest.cpp.

template<class C>

EventBase HTTPUpstreamTest< C >::eventBase_

protected

Definition at line 370 of file HTTPUpstreamSessionTest.cpp.

template<class C>

EventBase* HTTPUpstreamTest< C >::eventBasePtr_ {&eventBase_}

protected

Definition at line 371 of file HTTPUpstreamSessionTest.cpp.

template<class C>

bool HTTPUpstreamTest< C >::failWrites_ {false}

protected

Definition at line 383 of file HTTPUpstreamSessionTest.cpp.

template<class C>

std::vector<int64_t> HTTPUpstreamTest< C >::flowControl_

protected

Definition at line 376 of file HTTPUpstreamSessionTest.cpp.

template<class C>

HTTPUpstreamSession* HTTPUpstreamTest< C >::httpSession_ {nullptr}

protected

Definition at line 380 of file HTTPUpstreamSessionTest.cpp.

template<class C>

SocketAddress HTTPUpstreamTest< C >::localAddr_ {"127.0.0.1", 80}

protected

Definition at line 378 of file HTTPUpstreamSessionTest.cpp.

template<class C>

wangle::TransportInfo HTTPUpstreamTest< C >::mockTransportInfo_

protected

Definition at line 377 of file HTTPUpstreamSessionTest.cpp.

template<class C>

bool HTTPUpstreamTest< C >::pauseWrites_ {false}

protected

Definition at line 384 of file HTTPUpstreamSessionTest.cpp.

template<class C>

SocketAddress HTTPUpstreamTest< C >::peerAddr_ {"127.0.0.1", 12345}

protected

Definition at line 379 of file HTTPUpstreamSessionTest.cpp.

template<class C>

folly::AsyncTransportWrapper::ReadCallback* HTTPUpstreamTest< C >::readCallback_ {nullptr}

protected

Definition at line 373 of file HTTPUpstreamSessionTest.cpp.

template<class C>

folly::AsyncTransport::ReplaySafetyCallback* HTTPUpstreamTest< C >::replaySafetyCallback_ {nullptr}

protected

Definition at line 374 of file HTTPUpstreamSessionTest.cpp.

template<class C>

bool HTTPUpstreamTest< C >::sessionCreated_ {false}

protected

Definition at line 364 of file HTTPUpstreamSessionTest.cpp.

template<class C>

bool HTTPUpstreamTest< C >::sessionDestroyed_ {false}

protected

Definition at line 365 of file HTTPUpstreamSessionTest.cpp.

template<class C>

bool HTTPUpstreamTest< C >::transactionsFull_ {false}

protected

Definition at line 367 of file HTTPUpstreamSessionTest.cpp.

template<class C>

folly::HHWheelTimer::UniquePtr HTTPUpstreamTest< C >::transactionTimeouts_

protected

Definition at line 375 of file HTTPUpstreamSessionTest.cpp.

template<class C>

MockAsyncTransport* HTTPUpstreamTest< C >::transport_

protected

Definition at line 372 of file HTTPUpstreamSessionTest.cpp.

template<class C>

bool HTTPUpstreamTest< C >::transportGood_ {true}

protected

Definition at line 368 of file HTTPUpstreamSessionTest.cpp.

template<class C>

bool HTTPUpstreamTest< C >::writeInLoop_ {false}

protected

Definition at line 385 of file HTTPUpstreamSessionTest.cpp.

template<class C>

IOBufQueue HTTPUpstreamTest< C >::writes_ {IOBufQueue::cacheChainLength()}

protected

Definition at line 381 of file HTTPUpstreamSessionTest.cpp.

---

The documentation for this class was generated from the following file:

• proxygen/lib/http/session/test/HTTPUpstreamSessionTest.cpp