SPDYCodecTest.cpp File Reference

#include <folly/portability/GTest.h>
#include <proxygen/lib/http/HTTPHeaderSize.h>
#include <proxygen/lib/http/HTTPMessage.h>
#include <proxygen/lib/http/codec/SPDYCodec.h>
#include <proxygen/lib/http/codec/SPDYConstants.h>
#include <proxygen/lib/http/codec/SPDYVersionSettings.h>
#include <proxygen/lib/http/codec/test/HTTPParallelCodecTest.h>
#include <proxygen/lib/http/codec/test/TestUtils.h>
#include <proxygen/lib/http/codec/compress/Logging.h>
#include <random>

Go to the source code of this file.

Classes
class	SPDYCodecTestF

Macros
#define	copyForMe(F, C, V)
#define	permuteTest(f)

Functions
size_t	parseSPDY (SPDYCodec *codec, const uint8_t *inputData, uint32_t length, int32_t atOnce, FakeHTTPCodecCallback &callbacks)
	TEST (SPDYCodecTest, SPDYVersionSettingsCommonHeaderNameCheck)
	TEST (SPDYCodecTest, JunkSPDY)
	TEST (SPDYCodecTest, LongPing)
	TEST (SPDYCodecTest, BadType)
	TEST (SPDYCodecTest, SynStreamBoundaries)
	TEST (SPDYCodecTest, SetSettings)
	TEST (SPDYCodecTest, FrameTooLarge)
	TEST (SPDYCodecTest, FrameUncompressedTooLarge)
	TEST (SPDYCodecTest, UnsupportedVersion)
	TEST (SPDYCodecTest, UnsupportedFrameType)
template<typename Codec >
unique_ptr< folly::IOBuf >	getSynStream (Codec &egressCodec, uint32_t streamID, const HTTPMessage &msg, uint32_t assocStreamId=SPDYCodec::NoStream, bool eom=false, HTTPHeaderSize *size=nullptr)
template<typename Codec >
unique_ptr< folly::IOBuf >	getSynStream (Codec &egressCodec, uint32_t streamID)
template<typename Codec , typename F , typename V >
void	callFunction (F f, V version)
unique_ptr< folly::IOBuf >	getVersionedSpdyFrame (const uint8_t *bytes, size_t len, uint8_t version)
template<typename Codec1 , typename Codec2 >
void	maxTransactionHelper (Codec1 &ingressCodec, Codec2 &egressCodec, uint32_t parallel)
template<typename Codec1 , typename Codec2 >
void	doDefaultMaxTransactionTest (Codec1 &ingressCodec, Codec2 &egressCodec)
template<typename Codec1 , typename Codec2 >
void	doNonDefaultMaxTransactionTest (Codec1 &ingressCodec, Codec2 &egressCodec)
	TEST (SPDYCodecTest, DefaultMaxTransactions)
	TEST (SPDYCodecTest, NonDefaultMaxTransactions)
template<typename Codec1 , typename Codec2 >
void	doEmptyHeaderValueTest (Codec1 &ingressCodec, Codec2 &egressCodec)
	TEST (SPDYCodecTest, EmptyHeaderValue)
	TEST (SPDYCodecTest, SynStreamWrongVersion)
template<typename Codec1 , typename Codec2 >
void	doShortSynReplyTest (Codec1 &, Codec2 &egressCodec)
	TEST (SPDYCodecTest, ShortSynReply)
	TEST (SPDYCodecTest, SupportsSessionFlowControl)
	TEST (SPDYCodecTest, HeaderWithManyValues)
	TEST (SPDYCodecTest, MultiplePaths)
	TEST (SPDYCodecTest, LargeFrameEncoding)
	TEST (SPDYCodecTest, InvalidSettings)
	TEST (SPDYCodecTest, HeaderWithFin)
	TEST (SPDYCodecTest, ServerPush)
	TEST (SPDYCodecTest, ServerPushWithStatus)
	TEST (SPDYCodecTest, ServerPushHostMissing)
	TEST (SPDYCodecTest, ServerPushInvalidId)
	TEST (SPDYCodecTest, ServerPushInvalidFlags)
	TEST (SPDYCodecTest, ServerPushWithoutAssoc)
	TEST (SPDYCodecTest, StatusReason)
	TEST (SPDYCodecTest, UpstreamPing)
	TEST (SPDYCodecTest, DownstreamPing)
	TEST (SPDYCodecTest, DateHeader)
	TEST (SPDYCodecTest, HeaderDoS)
	TEST (SPDYCodecTest, DoubleGoawayServer)
	TEST (SPDYCodecTest, DoubleGoawayClient)
	TEST (SPDYCodecTest, SingleGoawayClient)
	TEST (SPDYCodecTest, OddHeaderListTest)
	TEST (SPDYCodecTest, SendRstParsingFrame)
	TEST (SPDYCodecTest, BadNumNameValues)
	TEST (SPDYCodecTest, ShortSettings)
	TEST (SPDYCodecTest, SegmentedHeaderBlock)
	TEST (SPDYCodecTest, ColonHeaders)
	TEST (SPDYCodecTest, StreamIdOverflow)
	TEST (SPDYCodecTest, BadNVBlock)
	TEST_F (SPDYCodecTestF, GoawayHandling)

Variables
uint8_t	shortSynStream []
uint8_t	longPing []
uint8_t	badType []
uint8_t	synStream []
uint8_t	spdy3UnknownCtlFrame []
uint8_t	shortSynReply []
uint8_t	multiple_path_headers []
uint8_t	pushStreamWithHostMissing []
uint8_t	pushStreamWithOddId []
uint8_t	pushStreamWithoutUnidirectional []
uint8_t	pushStreamWithoutAssoc []
uint8_t	multiValuedHeaderAttack []
uint8_t	invalidHeaderPlusEmptyBlock []
uint8_t	invalidNumNameValuesBlock []
const uint8_t	kShortSettings []
const uint8_t	kColonHeaders []
const uint8_t	kBufBadNVBlock []

Macro Definition Documentation

#define copyForMe	(		F,
			C,
			V
	)

Value:

callFunction<C>(F<C, C>,                 \
                                           SPDYVersion::V)

Definition at line 380 of file SPDYCodecTest.cpp.

#define permuteTest

(

f

)

Value:

copyForMe(f, SPDYCodec, SPDY3);              \
                       copyForMe(f, SPDYCodec, SPDY3_1);

Definition at line 383 of file SPDYCodecTest.cpp.

Referenced by TEST().

Function Documentation

template<typename Codec , typename F , typename V >

void callFunction	(	F	f,
		V	version
	)

Definition at line 374 of file SPDYCodecTest.cpp.

References f.

                                  {
  Codec ingressCodec(TransportDirection::DOWNSTREAM, version);
  Codec egressCodec(TransportDirection::UPSTREAM, version);
  f(ingressCodec, egressCodec);
}

template<typename Codec1 , typename Codec2 >

void doDefaultMaxTransactionTest	(	Codec1 &	ingressCodec,
		Codec2 &	egressCodec
	)

Definition at line 419 of file SPDYCodecTest.cpp.

References maxTransactionHelper().

Referenced by TEST().

                                                                            {
  maxTransactionHelper(ingressCodec, egressCodec, 50);
}

template<typename Codec1 , typename Codec2 >

void doEmptyHeaderValueTest	(	Codec1 &	ingressCodec,
		Codec2 &	egressCodec
	)

Definition at line 437 of file SPDYCodecTest.cpp.

References ASSERT_NE, wangle::HTTPHeaderSize::compressed, EXPECT_EQ, EXPECT_TRUE, proxygen::HTTPMessage::getHeaders(), getSynStream(), proxygen::HTTP_HEADER_HOST, proxygen::HTTP_HEADER_PRAGMA, i, proxygen::FakeHTTPCodecCallback::msg, proxygen::FakeHTTPCodecCallback::sessionErrors, proxygen::HTTPHeaders::set(), proxygen::HTTPMessage::setMethod(), proxygen::HTTPMessage::setURL(), folly::size(), proxygen::FakeHTTPCodecCallback::streamErrors, string, uint8_t, wangle::HTTPHeaderSize::uncompressed, and version.

Referenced by TEST().

                                                                       {
  uint8_t version = ingressCodec.getVersion();
  bool emptyAllowed = version != 2;
  FakeHTTPCodecCallback callbacks;
  ingressCodec.setCallback(&callbacks);
  HTTPMessage toSend;
  toSend.setMethod("GET");
  toSend.setURL("http://www.foo.com");
  auto& headers = toSend.getHeaders();
  headers.set(HTTP_HEADER_HOST, "www.foo.com");
  headers.set(HTTP_HEADER_PRAGMA, "");
  headers.set("X-Test1", "yup");
  HTTPHeaderSize size;
  std::string pragmaValue;
  HTTPCodec::StreamID id(1);

  for (auto i = 0; i < 3; i++) {
    auto toParse = getSynStream(egressCodec, id + 2 * i,
                                toSend, 0, false, &size);
    ingressCodec.onIngress(*toParse);

    EXPECT_EQ(callbacks.sessionErrors, 0);
    EXPECT_EQ(callbacks.streamErrors, 0);
    ASSERT_NE(callbacks.msg.get(), nullptr);
    const auto& parsed = callbacks.msg->getHeaders();
    EXPECT_EQ(parsed.exists("Pragma"), emptyAllowed);
    EXPECT_EQ(parsed.exists("pragma"), emptyAllowed);
    EXPECT_EQ(parsed.getSingleOrEmpty("Pragma"), pragmaValue);
    EXPECT_EQ(parsed.getSingleOrEmpty("X-Test1"), "yup");
    // All codecs add the accept-encoding header
    EXPECT_EQ(parsed.exists("accept-encoding"), true);
    // SPDY/2 subtracts the Host header, but it should infer it from the
    // host:port portion of the requested url and present it in the headers
    EXPECT_EQ(parsed.exists("host"), true);
    EXPECT_EQ(callbacks.msg->getURL(), "http://www.foo.com");
    EXPECT_EQ(parsed.size(), emptyAllowed ? 4 : 3);
    EXPECT_TRUE(size.uncompressed > 0);
    EXPECT_TRUE(size.compressed > 0);

    if (i == 0) {
      headers.add("Pragma", "");
    }
    if (i == 1) {
      pragmaValue = "foo";
      headers.add("Pragma", pragmaValue);
      emptyAllowed = true; // SPDY/2 better have it now too
    }
  }
}

template<typename Codec1 , typename Codec2 >

void doNonDefaultMaxTransactionTest	(	Codec1 &	ingressCodec,
		Codec2 &	egressCodec
	)

Definition at line 424 of file SPDYCodecTest.cpp.

References maxTransactionHelper().

Referenced by TEST().

                                                                               {
  maxTransactionHelper(ingressCodec, egressCodec, 100);
}

template<typename Codec1 , typename Codec2 >

void doShortSynReplyTest	(	Codec1 &	,
		Codec2 &	egressCodec
	)

Definition at line 521 of file SPDYCodecTest.cpp.

References EXPECT_EQ, getVersionedSpdyFrame(), proxygen::FakeHTTPCodecCallback::sessionErrors, shortSynReply, and proxygen::FakeHTTPCodecCallback::streamErrors.

Referenced by TEST().

                                                         {
  FakeHTTPCodecCallback callbacks;
  egressCodec.setCallback(&callbacks);
  auto frame = getVersionedSpdyFrame(shortSynReply, sizeof(shortSynReply),
                                     egressCodec.getVersion());
  egressCodec.onIngress(*frame);
  EXPECT_EQ(callbacks.sessionErrors, 1);
  EXPECT_EQ(callbacks.streamErrors, 0);
}

template<typename Codec >

unique_ptr<folly::IOBuf> getSynStream	(	Codec &	egressCodec,
		uint32_t	streamID,
		const HTTPMessage &	msg,
		uint32_t	assocStreamId = SPDYCodec::NoStream,
		bool	eom = false,
		HTTPHeaderSize *	size = nullptr
	)

Definition at line 345 of file SPDYCodecTest.cpp.

References folly::IOBufQueue::cacheChainLength(), folly::IOBufQueue::move(), gmock_output_test::output, and folly::size().

Referenced by doEmptyHeaderValueTest(), getSynStream(), maxTransactionHelper(), and TEST().

                                    {
  folly::IOBufQueue output(folly::IOBufQueue::cacheChainLength());
  if (assocStreamId == SPDYCodec::NoStream) {
    egressCodec.generateHeader(output, streamID, msg, eom, size);
  } else {
    egressCodec.generatePushPromise(output, streamID, msg, assocStreamId, eom,
                                    size);
  }
  return output.move();
}

template<typename Codec >

unique_ptr<folly::IOBuf> getSynStream	(	Codec &	egressCodec,
		uint32_t	streamID
	)

Definition at line 363 of file SPDYCodecTest.cpp.

References proxygen::HTTPMessage::getHeaders(), getSynStream(), proxygen::HTTPHeaders::set(), proxygen::HTTPMessage::setMethod(), and proxygen::HTTPMessage::setURL().

                                                         {
  HTTPMessage msg;
  msg.setMethod("GET");
  msg.getHeaders().set("HOST", "www.foo.com");
  msg.setURL("https://www.foo.com");
  return getSynStream(egressCodec, streamID, msg);
}

unique_ptr<folly::IOBuf> getVersionedSpdyFrame	(	const uint8_t *	bytes,
		size_t	len,
		uint8_t	version
	)

Returns a SPDY frame with the specified version

Definition at line 389 of file SPDYCodecTest.cpp.

References folly::IOBuf::copyBuffer(), folly::data(), uint8_t, and version.

Referenced by doShortSynReplyTest(), and TEST().

                                                                {
  auto frame = folly::IOBuf::copyBuffer(bytes, len);
  uint8_t* data = frame->writableData();
  data[1] = version; /* Set the version */
  return frame;
}

template<typename Codec1 , typename Codec2 >

void maxTransactionHelper	(	Codec1 &	ingressCodec,
		Codec2 &	egressCodec,
		uint32_t	parallel
	)

Definition at line 399 of file SPDYCodecTest.cpp.

References EXPECT_EQ, getSynStream(), i, proxygen::FakeHTTPCodecCallback::sessionErrors, proxygen::FakeHTTPCodecCallback::streamErrors, and uint16_t.

Referenced by doDefaultMaxTransactionTest(), and doNonDefaultMaxTransactionTest().

                                             {
  uint16_t expectedFailures = 0;
  uint16_t synCount = 101;
  ingressCodec.getEgressSettings()->setSetting(
    SettingsId::MAX_CONCURRENT_STREAMS, parallel);
  FakeHTTPCodecCallback callbacks;
  ingressCodec.setCallback(&callbacks);
  for (uint16_t i = 0; i < synCount; ++i) {
    if (i >= parallel) {
      ++expectedFailures;
    }
    auto toParse = getSynStream(egressCodec, 2*i + 1);
    ingressCodec.onIngress(*toParse);
    EXPECT_EQ(callbacks.sessionErrors, 0);
    EXPECT_EQ(callbacks.streamErrors, expectedFailures);
  }
}

size_t parseSPDY	(	SPDYCodec *	codec,
		const uint8_t *	inputData,
		uint32_t	length,
		int32_t	atOnce,
		FakeHTTPCodecCallback &	callbacks
	)

Definition at line 26 of file SPDYCodecTest.cpp.

References proxygen::FakeHTTPCodecCallback::getStopFn(), parse(), and proxygen::HTTPParallelCodec::setCallback().

Referenced by TEST().

                                                                   {
  codec->setCallback(&callbacks);
  return parse(codec, inputData, length, atOnce, callbacks.getStopFn());
}

TEST	(	SPDYCodecTest	,
		SPDYVersionSettingsCommonHeaderNameCheck
	)

Definition at line 38 of file SPDYCodecTest.cpp.

References EXPECT_EQ, proxygen::HTTP_HEADER_COLON_METHOD, proxygen::HTTP_HEADER_COLON_PATH, proxygen::HTTP_HEADER_COLON_SCHEME, proxygen::HTTP_HEADER_COLON_STATUS, proxygen::HTTP_HEADER_OTHER, proxygen::spdy::kNameHostv3, proxygen::spdy::kNameMethodv3, proxygen::spdy::kNamePathv3, proxygen::spdy::kNameSchemev3, proxygen::spdy::kNameStatusv3, and proxygen::spdy::kNameVersionv3.

                                                              {
  // The purpose of this test is to ensure that should the below header names
  // become part of the common set, it fails indicating that the SPDYCodec
  // needs updating in those places that create compress/Header objects using
  // the failed name.
  EXPECT_EQ(HTTPCommonHeaders::hash(spdy::kNameVersionv3), HTTP_HEADER_OTHER);
  EXPECT_EQ(HTTPCommonHeaders::hash(spdy::kNameHostv3), HTTP_HEADER_OTHER);
  // The follow verifies assumptions that should never change regarding the
  // mapping of specific SPDY3 constants to common headers.  Should they fail,
  // the SPDYCodec would require updating in the places in which they are used
  // in creating compress/Header objects.
  EXPECT_EQ(HTTPCommonHeaders::hash(
    spdy::kNameStatusv3), HTTP_HEADER_COLON_STATUS);
  EXPECT_EQ(HTTPCommonHeaders::hash(
    spdy::kNameMethodv3), HTTP_HEADER_COLON_METHOD);
  EXPECT_EQ(HTTPCommonHeaders::hash(
    spdy::kNameSchemev3), HTTP_HEADER_COLON_SCHEME);
  EXPECT_EQ(HTTPCommonHeaders::hash(
    spdy::kNamePathv3), HTTP_HEADER_COLON_PATH);
}

TEST	(	SPDYCodecTest	,
		JunkSPDY
	)

Definition at line 59 of file SPDYCodecTest.cpp.

References codec, EXPECT_EQ, parseSPDY(), proxygen::FakeHTTPCodecCallback::sessionErrors, shortSynStream, and proxygen::FakeHTTPCodecCallback::streamErrors.

                              {
  SPDYCodec codec(TransportDirection::DOWNSTREAM, SPDYVersion::SPDY3);
  FakeHTTPCodecCallback callbacks;
  size_t unconsumed =
    parseSPDY(&codec, shortSynStream, sizeof(shortSynStream), -1, callbacks);
  EXPECT_EQ(unconsumed, 0);
  EXPECT_EQ(callbacks.sessionErrors, 1);
  EXPECT_EQ(callbacks.streamErrors, 0);
}

TEST	(	SPDYCodecTest	,
		LongPing
	)

Definition at line 76 of file SPDYCodecTest.cpp.

References codec, EXPECT_EQ, longPing, parseSPDY(), proxygen::FakeHTTPCodecCallback::sessionErrors, and proxygen::FakeHTTPCodecCallback::streamErrors.

                              {
  SPDYCodec codec(TransportDirection::DOWNSTREAM, SPDYVersion::SPDY3);
  FakeHTTPCodecCallback callbacks;
  size_t unconsumed =
    parseSPDY(&codec, longPing, sizeof(longPing), -1, callbacks);
  EXPECT_EQ(unconsumed, 0);
  EXPECT_EQ(callbacks.sessionErrors, 1);
  EXPECT_EQ(callbacks.streamErrors, 0);
}

TEST	(	SPDYCodecTest	,
		BadType
	)

Definition at line 93 of file SPDYCodecTest.cpp.

References badType, codec, EXPECT_EQ, parseSPDY(), proxygen::FakeHTTPCodecCallback::sessionErrors, and proxygen::FakeHTTPCodecCallback::streamErrors.

                             {
  // If an endpoint receives a control frame for a type it does not recognize,
  // it must ignore the frame.
  SPDYCodec codec(TransportDirection::DOWNSTREAM, SPDYVersion::SPDY3);
  FakeHTTPCodecCallback callbacks;
  size_t unconsumed =
    parseSPDY(&codec, badType, sizeof(badType), -1, callbacks);
  EXPECT_EQ(unconsumed, 0);
  EXPECT_EQ(callbacks.sessionErrors, 0);
  EXPECT_EQ(callbacks.streamErrors, 0);
}

TEST	(	SPDYCodecTest	,
		SynStreamBoundaries
	)

Definition at line 245 of file SPDYCodecTest.cpp.

References codec, EXPECT_EQ, proxygen::FakeHTTPCodecCallback::headersComplete, i, proxygen::FakeHTTPCodecCallback::messageBegin, proxygen::FakeHTTPCodecCallback::messageComplete, parseSPDY(), proxygen::FakeHTTPCodecCallback::sessionErrors, proxygen::FakeHTTPCodecCallback::streamErrors, and synStream.

                                         {
  for (int i = -1; i < int(sizeof(synStream)); i++) {
    SPDYCodec codec(TransportDirection::DOWNSTREAM, SPDYVersion::SPDY3_1);
    FakeHTTPCodecCallback callbacks;
    size_t unconsumed =
      parseSPDY(&codec, synStream, sizeof(synStream), i, callbacks);
    EXPECT_EQ(unconsumed, 0);
    EXPECT_EQ(callbacks.messageBegin, 1);
    EXPECT_EQ(callbacks.headersComplete, 1);
    EXPECT_EQ(callbacks.messageComplete, 1);
    EXPECT_EQ(callbacks.streamErrors, 0);
    EXPECT_EQ(callbacks.sessionErrors, 0);
  }
}

TEST	(	SPDYCodecTest	,
		SetSettings
	)

Definition at line 260 of file SPDYCodecTest.cpp.

References codec, EXPECT_EQ, proxygen::SPDYCodec::getEgressSettings(), proxygen::HTTPSettings::getNumSettings(), proxygen::HTTPSettings::getSetting(), proxygen::http2::kInitialWindow, proxygen::spdy::kMaxConcurrentStreams, proxygen::HTTPSettings::setSetting(), settings, proxygen::HTTPSettings::unsetSetting(), and proxygen::HTTPSetting::value.

                                 {
  SPDYCodec codec(TransportDirection::DOWNSTREAM, SPDYVersion::SPDY3);
  HTTPSettings* settings = codec.getEgressSettings();
  // There are 2 settings by default.  Turn on another setting
  settings->setSetting(SettingsId::_SPDY_DOWNLOAD_BANDWIDTH, 10);
  // This should no-op since this setting should be off by default
  settings->unsetSetting(SettingsId::_SPDY_ROUND_TRIP_TIME);
  EXPECT_EQ(settings->getSetting(SettingsId::_SPDY_ROUND_TRIP_TIME), nullptr);
  EXPECT_EQ(settings->getSetting(SettingsId::_SPDY_CURRENT_CWND), nullptr);
  EXPECT_EQ(settings->getSetting(SettingsId::MAX_CONCURRENT_STREAMS)->value,
            spdy::kMaxConcurrentStreams);
  EXPECT_EQ(settings->getSetting(SettingsId::INITIAL_WINDOW_SIZE)->value,
            spdy::kInitialWindow);
  EXPECT_EQ(
    settings->getSetting(SettingsId::_SPDY_DOWNLOAD_BANDWIDTH)->value, 10);
  // Turn off one of the defaults
  settings->unsetSetting(SettingsId::MAX_CONCURRENT_STREAMS);
  // Change the value of an existing default setting
  settings->setSetting(SettingsId::INITIAL_WINDOW_SIZE, 123);
  EXPECT_EQ(settings->getSetting(SettingsId::MAX_CONCURRENT_STREAMS),
            nullptr);
  EXPECT_EQ(settings->getSetting(SettingsId::INITIAL_WINDOW_SIZE)->value,
            123);
  EXPECT_EQ(settings->getNumSettings(), 2);
  // Change the value of a unset setting
  settings->setSetting(SettingsId::MAX_CONCURRENT_STREAMS, 400);
  EXPECT_EQ(settings->getSetting(SettingsId::MAX_CONCURRENT_STREAMS)->value,
            400);
  EXPECT_EQ(settings->getNumSettings(), 3);
}

TEST	(	SPDYCodecTest	,
		FrameTooLarge
	)

Definition at line 291 of file SPDYCodecTest.cpp.

References codec, EXPECT_EQ, parseSPDY(), proxygen::FakeHTTPCodecCallback::sessionErrors, proxygen::SPDYCodec::setMaxFrameLength(), proxygen::FakeHTTPCodecCallback::streamErrors, and synStream.

                                   {
  SPDYCodec codec(TransportDirection::DOWNSTREAM, SPDYVersion::SPDY3_1);
  codec.setMaxFrameLength(500);
  FakeHTTPCodecCallback callbacks;
  size_t unconsumed = parseSPDY(&codec, synStream, sizeof(synStream), -1,
                                callbacks);
  EXPECT_EQ(unconsumed, 0);
  EXPECT_EQ(callbacks.sessionErrors, 1);
  EXPECT_EQ(callbacks.streamErrors, 1);
}

TEST	(	SPDYCodecTest	,
		FrameUncompressedTooLarge
	)

Definition at line 302 of file SPDYCodecTest.cpp.

References codec, EXPECT_EQ, parseSPDY(), proxygen::FakeHTTPCodecCallback::sessionErrors, proxygen::SPDYCodec::setMaxUncompressedHeaders(), proxygen::FakeHTTPCodecCallback::streamErrors, and synStream.

                                               {
  SPDYCodec codec(TransportDirection::DOWNSTREAM, SPDYVersion::SPDY3_1);
  codec.setMaxUncompressedHeaders(600);
  FakeHTTPCodecCallback callbacks;
  size_t unconsumed = parseSPDY(&codec, synStream, sizeof(synStream), -1,
                                callbacks);
  EXPECT_EQ(unconsumed, 0);
  EXPECT_EQ(callbacks.sessionErrors, 1);
  EXPECT_EQ(callbacks.streamErrors, 1);
}

TEST	(	SPDYCodecTest	,
		UnsupportedVersion
	)

Definition at line 319 of file SPDYCodecTest.cpp.

References codec, EXPECT_EQ, proxygen::FakeHTTPCodecCallback::lastParseError, parseSPDY(), proxygen::spdy::RST_PROTOCOL_ERROR, proxygen::spdy::rstToErrorCode(), proxygen::FakeHTTPCodecCallback::sessionErrors, shortSynStream, and proxygen::FakeHTTPCodecCallback::streamErrors.

                                        {
  // Send a spdy/2 frame on a spdy/3 codec
  SPDYCodec codec(TransportDirection::DOWNSTREAM, SPDYVersion::SPDY3);
  FakeHTTPCodecCallback callbacks;
  size_t unconsumed = parseSPDY(&codec, shortSynStream,
                                sizeof(shortSynStream), -1, callbacks);
  EXPECT_EQ(unconsumed, 0);
  // Expect a GOAWAY with PROTOCOL_ERROR (because of unsupported version)
  EXPECT_EQ(callbacks.sessionErrors, 1);
  EXPECT_EQ(callbacks.streamErrors, 0);
  EXPECT_EQ(callbacks.lastParseError->getCodecStatusCode(),
            spdy::rstToErrorCode(spdy::RST_PROTOCOL_ERROR));
}

TEST	(	SPDYCodecTest	,
		UnsupportedFrameType
	)

Definition at line 333 of file SPDYCodecTest.cpp.

References codec, EXPECT_EQ, parseSPDY(), proxygen::FakeHTTPCodecCallback::sessionErrors, spdy3UnknownCtlFrame, and proxygen::FakeHTTPCodecCallback::streamErrors.

                                          {
  SPDYCodec codec(TransportDirection::DOWNSTREAM, SPDYVersion::SPDY3);
  FakeHTTPCodecCallback callbacks;
  size_t unconsumed = parseSPDY(&codec, spdy3UnknownCtlFrame,
                                sizeof(spdy3UnknownCtlFrame), -1, callbacks);
  EXPECT_EQ(unconsumed, 0);
  EXPECT_EQ(callbacks.sessionErrors, 0);
  EXPECT_EQ(callbacks.streamErrors, 0);
  // Spec says unknown control frames must be ignored
}

TEST	(	SPDYCodecTest	,
		DefaultMaxTransactions
	)

Definition at line 428 of file SPDYCodecTest.cpp.

References doDefaultMaxTransactionTest(), and permuteTest.

                                            {
  permuteTest(doDefaultMaxTransactionTest);
}

TEST	(	SPDYCodecTest	,
		NonDefaultMaxTransactions
	)

Definition at line 432 of file SPDYCodecTest.cpp.

References doNonDefaultMaxTransactionTest(), and permuteTest.

                                               {
  permuteTest(doNonDefaultMaxTransactionTest);
}

TEST	(	SPDYCodecTest	,
		EmptyHeaderValue
	)

Definition at line 487 of file SPDYCodecTest.cpp.

References doEmptyHeaderValueTest(), and permuteTest.

                                      {
  permuteTest(doEmptyHeaderValueTest);
}

TEST	(	SPDYCodecTest	,
		SynStreamWrongVersion
	)

Tests a syn stream request containing the wrong version. This frame is generated by using the v3 synStream firefox frame specified above and changing the version field to 2. The dictionary used for the zlib compression will be different and the session will be rejected.

Definition at line 497 of file SPDYCodecTest.cpp.

References codec, EXPECT_EQ, getVersionedSpdyFrame(), proxygen::FakeHTTPCodecCallback::lastParseError, parseSPDY(), proxygen::spdy::RST_PROTOCOL_ERROR, proxygen::spdy::rstToErrorCode(), proxygen::FakeHTTPCodecCallback::sessionErrors, proxygen::FakeHTTPCodecCallback::streamErrors, and synStream.

                                           {
  SPDYCodec codec(TransportDirection::DOWNSTREAM, SPDYVersion::SPDY3);
  FakeHTTPCodecCallback callbacks;
  auto frame = getVersionedSpdyFrame(synStream, sizeof(synStream), 2);
  size_t unconsumed = parseSPDY(&codec, frame->data(), frame->length(), -1,
                                callbacks);
  EXPECT_EQ(unconsumed, 0);
  // Since the session compression state is inconsistent we need to send a
  // session error. Expect a GOAWAY with PROTOCOL_ERROR.
  EXPECT_EQ(callbacks.sessionErrors, 1);
  EXPECT_EQ(callbacks.streamErrors, 0);
  EXPECT_EQ(callbacks.lastParseError->getCodecStatusCode(),
            spdy::rstToErrorCode(spdy::RST_PROTOCOL_ERROR));
}

TEST	(	SPDYCodecTest	,
		ShortSynReply
	)

Definition at line 531 of file SPDYCodecTest.cpp.

References doShortSynReplyTest(), and permuteTest.

                                   {
  permuteTest(doShortSynReplyTest);
}

TEST	(	SPDYCodecTest	,
		SupportsSessionFlowControl
	)

Definition at line 535 of file SPDYCodecTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, and proxygen::SPDYCodec::supportsSessionFlowControl().

                                                {
  SPDYCodec spdy3(TransportDirection::UPSTREAM,
                  SPDYVersion::SPDY3);
  SPDYCodec spdy3_1(TransportDirection::UPSTREAM,
                    SPDYVersion::SPDY3_1);
  EXPECT_FALSE(spdy3.supportsSessionFlowControl());
  EXPECT_TRUE(spdy3_1.supportsSessionFlowControl());
}

TEST	(	SPDYCodecTest	,
		HeaderWithManyValues
	)

Definition at line 545 of file SPDYCodecTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, proxygen::HTTPMessage::getHeaders(), getSynStream(), proxygen::FakeHTTPCodecCallback::headersComplete, i, proxygen::FakeHTTPCodecCallback::messageBegin, proxygen::FakeHTTPCodecCallback::messageComplete, proxygen::FakeHTTPCodecCallback::msg, proxygen::SPDYCodec::onIngress(), proxygen::FakeHTTPCodecCallback::sessionErrors, proxygen::HTTPHeaders::set(), proxygen::HTTPParallelCodec::setCallback(), proxygen::HTTPMessage::setMethod(), proxygen::HTTPMessage::setURL(), proxygen::FakeHTTPCodecCallback::streamErrors, and string.

                                          {
  const std::string kMultiValued = "X-Multi-Valued";
  const unsigned kNumValues = 1000;

  FakeHTTPCodecCallback callbacks;
  SPDYCodec egressCodec(TransportDirection::UPSTREAM,
                        SPDYVersion::SPDY3);
  SPDYCodec ingressCodec(TransportDirection::DOWNSTREAM,
                         SPDYVersion::SPDY3);
  ingressCodec.setCallback(&callbacks);

  HTTPMessage req;
  req.setMethod("GET");
  req.getHeaders().set("HOST", "www.foo.com");
  req.setURL("https://www.foo.com");
  for (unsigned i = 0; i < kNumValues; ++i) {
    req.getHeaders().add(kMultiValued, folly::to<string>("Value", i));
  }
  auto syn = getSynStream(egressCodec, 1, req);
  ingressCodec.onIngress(*syn);
  EXPECT_EQ(callbacks.messageBegin, 1);
  EXPECT_EQ(callbacks.headersComplete, 1);
  EXPECT_EQ(callbacks.messageComplete, 0);
  EXPECT_EQ(callbacks.streamErrors, 0);
  EXPECT_EQ(callbacks.sessionErrors, 0);
  CHECK_NOTNULL(callbacks.msg.get());
  EXPECT_EQ(callbacks.msg->getHeaders().getNumberOfValues(kMultiValued),
            kNumValues);
}

TEST	(	SPDYCodecTest	,
		MultiplePaths
	)

Definition at line 604 of file SPDYCodecTest.cpp.

References EXPECT_EQ, proxygen::SPDYCodec::getVersion(), getVersionedSpdyFrame(), multiple_path_headers, proxygen::SPDYCodec::onIngress(), proxygen::FakeHTTPCodecCallback::sessionErrors, proxygen::HTTPParallelCodec::setCallback(), and proxygen::FakeHTTPCodecCallback::streamErrors.

                                   {
  FakeHTTPCodecCallback callbacks;
  SPDYCodec ingressCodec(TransportDirection::DOWNSTREAM, SPDYVersion::SPDY3);
  auto frame = getVersionedSpdyFrame(multiple_path_headers,
     sizeof(multiple_path_headers), ingressCodec.getVersion());
  ingressCodec.setCallback(&callbacks);
  ingressCodec.onIngress(*frame);
  EXPECT_EQ(callbacks.streamErrors, 1);
  EXPECT_EQ(callbacks.sessionErrors, 0);
}

TEST	(	SPDYCodecTest	,
		LargeFrameEncoding
	)

Definition at line 615 of file SPDYCodecTest.cpp.

References codec, proxygen::getGetRequest(), getSynStream(), i, proxygen::SPDYCodec::setMaxUncompressedHeaders(), and string.

                                        {
  const std::string kMultiValued = "X-Multi-Valued";
  const unsigned kNumValues = 1000;

  SPDYCodec codec(TransportDirection::UPSTREAM, SPDYVersion::SPDY3);
  // This will simulate the condition where we have a very small
  // compresed headers size compared to the number of headers we
  // have.
  codec.setMaxUncompressedHeaders(0);
  auto req = getGetRequest();
  for (unsigned i = 0; i < kNumValues; ++i) {
    req.getHeaders().add(kMultiValued, folly::to<string>("Value", i));
  }
  auto syn = getSynStream(codec, 1, req);
}

TEST	(	SPDYCodecTest	,
		InvalidSettings
	)

Definition at line 632 of file SPDYCodecTest.cpp.

References folly::IOBufQueue::cacheChainLength(), EXPECT_EQ, proxygen::SPDYCodec::generateSettings(), proxygen::SPDYCodec::getEgressSettings(), proxygen::FakeHTTPCodecCallback::headersComplete, max, proxygen::FakeHTTPCodecCallback::messageBegin, proxygen::FakeHTTPCodecCallback::messageComplete, folly::IOBufQueue::move(), proxygen::SPDYCodec::onIngress(), gmock_output_test::output, proxygen::FakeHTTPCodecCallback::sessionErrors, proxygen::HTTPParallelCodec::setCallback(), proxygen::HTTPSettings::setSetting(), proxygen::FakeHTTPCodecCallback::streamErrors, and uint32_t.

                                     {
  FakeHTTPCodecCallback callbacks;

  SPDYCodec egressCodec(TransportDirection::UPSTREAM,
                        SPDYVersion::SPDY3);
  SPDYCodec ingressCodec(TransportDirection::DOWNSTREAM,
                         SPDYVersion::SPDY3);
  ingressCodec.setCallback(&callbacks);

  folly::IOBufQueue output(folly::IOBufQueue::cacheChainLength());
  egressCodec.getEgressSettings()->setSetting(
    SettingsId::INITIAL_WINDOW_SIZE,
    (uint32_t)std::numeric_limits<int32_t>::max() + 1);
  egressCodec.generateSettings(output);
  auto ingress = output.move();
  ingressCodec.onIngress(*ingress);
  EXPECT_EQ(callbacks.messageBegin, 0);
  EXPECT_EQ(callbacks.headersComplete, 0);
  EXPECT_EQ(callbacks.messageComplete, 0);
  EXPECT_EQ(callbacks.streamErrors, 0);
  EXPECT_EQ(callbacks.sessionErrors, 1);
}

TEST	(	SPDYCodecTest	,
		HeaderWithFin
	)

Definition at line 655 of file SPDYCodecTest.cpp.

References proxygen::FakeHTTPCodecCallback::assocStreamId, EXPECT_EQ, proxygen::HTTPMessage::getHeaders(), getSynStream(), proxygen::FakeHTTPCodecCallback::headersComplete, proxygen::FakeHTTPCodecCallback::messageBegin, proxygen::FakeHTTPCodecCallback::messageComplete, proxygen::SPDYCodec::onIngress(), proxygen::FakeHTTPCodecCallback::sessionErrors, proxygen::HTTPHeaders::set(), proxygen::HTTPParallelCodec::setCallback(), proxygen::HTTPMessage::setMethod(), proxygen::HTTPMessage::setURL(), and proxygen::FakeHTTPCodecCallback::streamErrors.

                                   {
  FakeHTTPCodecCallback callbacks;
  SPDYCodec egressCodec(TransportDirection::UPSTREAM,
                        SPDYVersion::SPDY3);
  SPDYCodec ingressCodec(TransportDirection::DOWNSTREAM,
                         SPDYVersion::SPDY3);
  ingressCodec.setCallback(&callbacks);

  HTTPMessage req;
  req.setMethod("GET");
  req.getHeaders().set("HOST", "www.foo.com");
  req.setURL("https://www.foo.com/");
  auto syn = getSynStream(egressCodec, 1, req, 0, true /* eom */);
  ingressCodec.onIngress(*syn);
  EXPECT_EQ(callbacks.messageBegin, 1);
  EXPECT_EQ(callbacks.headersComplete, 1);
  EXPECT_EQ(callbacks.messageComplete, 1);
  EXPECT_EQ(callbacks.streamErrors, 0);
  EXPECT_EQ(callbacks.sessionErrors, 0);
  EXPECT_EQ(callbacks.assocStreamId, 0);
}

TEST	(	SPDYCodecTest	,
		ServerPush
	)

Definition at line 677 of file SPDYCodecTest.cpp.

References proxygen::FakeHTTPCodecCallback::assocStreamId, EXPECT_EQ, proxygen::HTTPMessage::getHeaders(), getSynStream(), proxygen::FakeHTTPCodecCallback::headersComplete, proxygen::FakeHTTPCodecCallback::messageBegin, proxygen::FakeHTTPCodecCallback::messageComplete, proxygen::SPDYCodec::onIngress(), proxygen::FakeHTTPCodecCallback::sessionErrors, proxygen::HTTPHeaders::set(), proxygen::HTTPParallelCodec::setCallback(), proxygen::HTTPMessage::setURL(), and proxygen::FakeHTTPCodecCallback::streamErrors.

                                {
  FakeHTTPCodecCallback callbacks;
  SPDYCodec egressCodec(TransportDirection::DOWNSTREAM,
                        SPDYVersion::SPDY3);
  SPDYCodec ingressCodec(TransportDirection::UPSTREAM,
                         SPDYVersion::SPDY3);
  ingressCodec.setCallback(&callbacks);

  HTTPMessage push;
  push.getHeaders().set("HOST", "www.foo.com");
  push.setURL("https://www.foo.com/");
  auto syn = getSynStream(egressCodec, 2, push, 1);
  ingressCodec.onIngress(*syn);
  EXPECT_EQ(callbacks.messageBegin, 1);
  EXPECT_EQ(callbacks.headersComplete, 1);
  EXPECT_EQ(callbacks.messageComplete, 0);
  EXPECT_EQ(callbacks.streamErrors, 0);
  EXPECT_EQ(callbacks.sessionErrors, 0);
  EXPECT_EQ(callbacks.assocStreamId, 1);
}

TEST	(	SPDYCodecTest	,
		ServerPushWithStatus
	)

Definition at line 698 of file SPDYCodecTest.cpp.

References proxygen::FakeHTTPCodecCallback::assocStreamId, EXPECT_EQ, proxygen::HTTPMessage::getHeaders(), getSynStream(), proxygen::FakeHTTPCodecCallback::headersComplete, proxygen::FakeHTTPCodecCallback::messageBegin, proxygen::FakeHTTPCodecCallback::messageComplete, proxygen::FakeHTTPCodecCallback::msg, proxygen::SPDYCodec::onIngress(), proxygen::FakeHTTPCodecCallback::sessionErrors, proxygen::HTTPHeaders::set(), proxygen::HTTPParallelCodec::setCallback(), proxygen::HTTPMessage::setPushStatusCode(), proxygen::HTTPMessage::setURL(), and proxygen::FakeHTTPCodecCallback::streamErrors.

                                          {
  FakeHTTPCodecCallback callbacks;
  SPDYCodec egressCodec(TransportDirection::DOWNSTREAM,
                        SPDYVersion::SPDY3);
  SPDYCodec ingressCodec(TransportDirection::UPSTREAM,
                         SPDYVersion::SPDY3);
  ingressCodec.setCallback(&callbacks);

  HTTPMessage push;
  push.getHeaders().set("HOST", "www.foo.com");
  push.setURL("https://www.foo.com/");
  push.setPushStatusCode(200);
  auto syn = getSynStream(egressCodec, 2, push, 1);
  ingressCodec.onIngress(*syn);
  EXPECT_EQ(callbacks.messageBegin, 1);
  EXPECT_EQ(callbacks.headersComplete, 1);
  EXPECT_EQ(callbacks.messageComplete, 0);
  EXPECT_EQ(callbacks.streamErrors, 0);
  EXPECT_EQ(callbacks.sessionErrors, 0);
  EXPECT_EQ(callbacks.assocStreamId, 1);
  EXPECT_EQ(callbacks.msg->getPushStatusCode(), 200);
}

TEST	(	SPDYCodecTest	,
		ServerPushHostMissing
	)

Definition at line 744 of file SPDYCodecTest.cpp.

References proxygen::FakeHTTPCodecCallback::assocStreamId, folly::IOBuf::copyBuffer(), EXPECT_EQ, proxygen::FakeHTTPCodecCallback::headersComplete, proxygen::FakeHTTPCodecCallback::messageBegin, proxygen::FakeHTTPCodecCallback::messageComplete, proxygen::SPDYCodec::onIngress(), pushStreamWithHostMissing, proxygen::FakeHTTPCodecCallback::sessionErrors, proxygen::HTTPParallelCodec::setCallback(), and proxygen::FakeHTTPCodecCallback::streamErrors.

                                           {
  FakeHTTPCodecCallback callbacks;
  SPDYCodec ingressCodec(TransportDirection::UPSTREAM,
                         SPDYVersion::SPDY3);
  ingressCodec.setCallback(&callbacks);

  auto syn = folly::IOBuf::copyBuffer(pushStreamWithHostMissing,
                                      sizeof(pushStreamWithHostMissing));
  ingressCodec.onIngress(*syn);
  EXPECT_EQ(callbacks.messageBegin, 0);
  EXPECT_EQ(callbacks.headersComplete, 0);
  EXPECT_EQ(callbacks.messageComplete, 0);
  EXPECT_EQ(callbacks.streamErrors, 1);
  EXPECT_EQ(callbacks.sessionErrors, 0);
  EXPECT_EQ(callbacks.assocStreamId, 0);
}

TEST	(	SPDYCodecTest	,
		ServerPushInvalidId
	)

Definition at line 787 of file SPDYCodecTest.cpp.

References proxygen::FakeHTTPCodecCallback::assocStreamId, folly::IOBuf::copyBuffer(), EXPECT_EQ, proxygen::FakeHTTPCodecCallback::headersComplete, proxygen::FakeHTTPCodecCallback::messageBegin, proxygen::FakeHTTPCodecCallback::messageComplete, proxygen::SPDYCodec::onIngress(), pushStreamWithOddId, proxygen::FakeHTTPCodecCallback::sessionErrors, proxygen::HTTPParallelCodec::setCallback(), and proxygen::FakeHTTPCodecCallback::streamErrors.

                                         {
  FakeHTTPCodecCallback callbacks;
  SPDYCodec ingressCodec(TransportDirection::UPSTREAM,
                         SPDYVersion::SPDY3);
  ingressCodec.setCallback(&callbacks);

  auto syn = folly::IOBuf::copyBuffer(pushStreamWithOddId,
                                      sizeof(pushStreamWithOddId));
  ingressCodec.onIngress(*syn);
  EXPECT_EQ(callbacks.messageBegin, 0);
  EXPECT_EQ(callbacks.headersComplete, 0);
  EXPECT_EQ(callbacks.messageComplete, 0);
  EXPECT_EQ(callbacks.streamErrors, 0);
  EXPECT_EQ(callbacks.sessionErrors, 1);
  EXPECT_EQ(callbacks.assocStreamId, 0);
}

TEST	(	SPDYCodecTest	,
		ServerPushInvalidFlags
	)

Definition at line 830 of file SPDYCodecTest.cpp.

References proxygen::FakeHTTPCodecCallback::assocStreamId, folly::IOBuf::copyBuffer(), EXPECT_EQ, proxygen::FakeHTTPCodecCallback::headersComplete, proxygen::FakeHTTPCodecCallback::messageBegin, proxygen::FakeHTTPCodecCallback::messageComplete, proxygen::SPDYCodec::onIngress(), pushStreamWithoutUnidirectional, proxygen::FakeHTTPCodecCallback::sessionErrors, proxygen::HTTPParallelCodec::setCallback(), and proxygen::FakeHTTPCodecCallback::streamErrors.

                                            {
  FakeHTTPCodecCallback callbacks;
  SPDYCodec ingressCodec(TransportDirection::UPSTREAM,
                         SPDYVersion::SPDY3);
  ingressCodec.setCallback(&callbacks);

  auto syn = folly::IOBuf::copyBuffer(pushStreamWithoutUnidirectional,
                                      sizeof(pushStreamWithoutUnidirectional));
  ingressCodec.onIngress(*syn);
  EXPECT_EQ(callbacks.messageBegin, 0);
  EXPECT_EQ(callbacks.headersComplete, 0);
  EXPECT_EQ(callbacks.messageComplete, 0);
  EXPECT_EQ(callbacks.streamErrors, 1);
  EXPECT_EQ(callbacks.sessionErrors, 0);
  EXPECT_EQ(callbacks.assocStreamId, 0);
}

TEST	(	SPDYCodecTest	,
		ServerPushWithoutAssoc
	)

Definition at line 873 of file SPDYCodecTest.cpp.

References proxygen::FakeHTTPCodecCallback::assocStreamId, folly::IOBuf::copyBuffer(), EXPECT_EQ, proxygen::FakeHTTPCodecCallback::headersComplete, proxygen::FakeHTTPCodecCallback::messageBegin, proxygen::FakeHTTPCodecCallback::messageComplete, proxygen::SPDYCodec::onIngress(), pushStreamWithoutAssoc, proxygen::FakeHTTPCodecCallback::sessionErrors, proxygen::HTTPParallelCodec::setCallback(), and proxygen::FakeHTTPCodecCallback::streamErrors.

                                            {
  FakeHTTPCodecCallback callbacks;
  SPDYCodec ingressCodec(TransportDirection::UPSTREAM,
                         SPDYVersion::SPDY3);
  ingressCodec.setCallback(&callbacks);

  auto syn = folly::IOBuf::copyBuffer(pushStreamWithoutAssoc,
                                      sizeof(pushStreamWithoutAssoc));
  ingressCodec.onIngress(*syn);
  EXPECT_EQ(callbacks.messageBegin, 0);
  EXPECT_EQ(callbacks.headersComplete, 0);
  EXPECT_EQ(callbacks.messageComplete, 0);
  EXPECT_EQ(callbacks.streamErrors, 0);
  EXPECT_EQ(callbacks.sessionErrors, 1);
  EXPECT_EQ(callbacks.assocStreamId, 0);
}

TEST	(	SPDYCodecTest	,
		StatusReason
	)

Definition at line 890 of file SPDYCodecTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, getSynStream(), proxygen::FakeHTTPCodecCallback::headersComplete, proxygen::FakeHTTPCodecCallback::lastParseError, proxygen::FakeHTTPCodecCallback::messageBegin, proxygen::FakeHTTPCodecCallback::messageComplete, proxygen::FakeHTTPCodecCallback::msg, proxygen::SPDYCodec::onIngress(), proxygen::FakeHTTPCodecCallback::reset(), proxygen::spdy::RST_PROTOCOL_ERROR, proxygen::spdy::rstToErrorCode(), proxygen::FakeHTTPCodecCallback::sessionErrors, proxygen::HTTPParallelCodec::setCallback(), proxygen::HTTPMessage::setStatusCode(), proxygen::HTTPMessage::setStatusMessage(), and proxygen::FakeHTTPCodecCallback::streamErrors.

                                  {
  FakeHTTPCodecCallback callbacks;
  SPDYCodec egressCodec(TransportDirection::DOWNSTREAM,
                        SPDYVersion::SPDY3);
  SPDYCodec ingressCodec(TransportDirection::UPSTREAM,
                         SPDYVersion::SPDY3);
  ingressCodec.setCallback(&callbacks);

  HTTPMessage resp;
  resp.setStatusCode(200);
  auto syn = getSynStream(egressCodec, 1, resp, 0);
  ingressCodec.onIngress(*syn);
  EXPECT_EQ(callbacks.messageBegin, 1);
  EXPECT_EQ(callbacks.headersComplete, 1);
  EXPECT_EQ(callbacks.messageComplete, 0);
  EXPECT_EQ(callbacks.streamErrors, 0);
  EXPECT_EQ(callbacks.sessionErrors, 0);
  EXPECT_EQ(callbacks.msg->getStatusCode(), 200);
  EXPECT_EQ(callbacks.msg->getStatusMessage(), "");
  callbacks.reset();

  resp.setStatusCode(200);
  resp.setStatusMessage("Awesome");
  syn = getSynStream(egressCodec, 1, resp, 0);
  ingressCodec.onIngress(*syn);
  EXPECT_EQ(callbacks.messageBegin, 1);
  EXPECT_EQ(callbacks.headersComplete, 1);
  EXPECT_EQ(callbacks.messageComplete, 0);
  EXPECT_EQ(callbacks.streamErrors, 0);
  EXPECT_EQ(callbacks.sessionErrors, 0);
  EXPECT_EQ(callbacks.msg->getStatusCode(), 200);
  EXPECT_EQ(callbacks.msg->getStatusMessage(), "Awesome");
  callbacks.reset();

  // Out of range
  resp.setStatusCode(2000);
  resp.setStatusMessage("10x OK");
  syn = getSynStream(egressCodec, 1, resp, 0);
  ingressCodec.onIngress(*syn);
  EXPECT_EQ(callbacks.messageBegin, 0);
  EXPECT_EQ(callbacks.headersComplete, 0);
  EXPECT_EQ(callbacks.messageComplete, 0);
  EXPECT_EQ(callbacks.streamErrors, 1);
  EXPECT_EQ(callbacks.sessionErrors, 0);
  EXPECT_TRUE(callbacks.lastParseError->hasCodecStatusCode());
  EXPECT_EQ(callbacks.lastParseError->getCodecStatusCode(),
            spdy::rstToErrorCode(spdy::RST_PROTOCOL_ERROR));
  callbacks.reset();

  resp.setStatusCode(64);
  resp.setStatusMessage("Ought to be enough for anybody");
  syn = getSynStream(egressCodec, 1, resp, 0);
  ingressCodec.onIngress(*syn);
  EXPECT_EQ(callbacks.messageBegin, 0);
  EXPECT_EQ(callbacks.headersComplete, 0);
  EXPECT_EQ(callbacks.messageComplete, 0);
  EXPECT_EQ(callbacks.streamErrors, 1);
  EXPECT_EQ(callbacks.sessionErrors, 0);
  EXPECT_TRUE(callbacks.lastParseError->hasCodecStatusCode());
  EXPECT_EQ(callbacks.lastParseError->getCodecStatusCode(),
            spdy::rstToErrorCode(spdy::RST_PROTOCOL_ERROR));
  callbacks.reset();
}

TEST	(	SPDYCodecTest	,
		UpstreamPing
	)

Definition at line 954 of file SPDYCodecTest.cpp.

References ASSERT_EQ, ASSERT_GT, folly::IOBufQueue::cacheChainLength(), proxygen::SPDYCodec::generatePingReply(), proxygen::SPDYCodec::generatePingRequest(), i, folly::IOBufQueue::move(), proxygen::SPDYCodec::onIngress(), proxygen::FakeHTTPCodecCallback::recvPingReply, proxygen::FakeHTTPCodecCallback::recvPingRequest, and proxygen::HTTPParallelCodec::setCallback().

                                  {
  folly::IOBufQueue buf(folly::IOBufQueue::cacheChainLength());
  FakeHTTPCodecCallback callbacks;
  SPDYCodec egressCodec(TransportDirection::UPSTREAM,
                        SPDYVersion::SPDY3);
  SPDYCodec ingressCodec(TransportDirection::DOWNSTREAM,
                         SPDYVersion::SPDY3);
  ingressCodec.setCallback(&callbacks);

  // Send a reply with no corresponding ping request
  egressCodec.generatePingReply(buf, 2);
  auto pingReply = buf.move();
  ingressCodec.onIngress(*pingReply);
  ASSERT_EQ(callbacks.recvPingReply, 0); // should be ignored

  auto lastRequest = callbacks.recvPingRequest;
  for (unsigned i = 0; i < 10; ++i) {
    egressCodec.generatePingRequest(buf);
    auto pingReq = buf.move();
    ingressCodec.onIngress(*pingReq);
    ASSERT_GT(callbacks.recvPingRequest, lastRequest);
    ASSERT_EQ(callbacks.recvPingRequest % 2, 1);
    lastRequest = callbacks.recvPingRequest;
  }
}

TEST	(	SPDYCodecTest	,
		DownstreamPing
	)

Definition at line 980 of file SPDYCodecTest.cpp.

References ASSERT_EQ, ASSERT_GT, folly::IOBufQueue::cacheChainLength(), proxygen::SPDYCodec::generatePingReply(), proxygen::SPDYCodec::generatePingRequest(), i, folly::IOBufQueue::move(), proxygen::SPDYCodec::onIngress(), proxygen::FakeHTTPCodecCallback::recvPingReply, proxygen::FakeHTTPCodecCallback::recvPingRequest, and proxygen::HTTPParallelCodec::setCallback().

                                    {
  folly::IOBufQueue buf(folly::IOBufQueue::cacheChainLength());
  FakeHTTPCodecCallback callbacks;
  SPDYCodec egressCodec(TransportDirection::DOWNSTREAM,
                        SPDYVersion::SPDY3);
  SPDYCodec ingressCodec(TransportDirection::UPSTREAM,
                         SPDYVersion::SPDY3);
  ingressCodec.setCallback(&callbacks);

  // Send a reply with no corresponding ping request
  egressCodec.generatePingReply(buf, 1);
  auto pingReply = buf.move();
  ingressCodec.onIngress(*pingReply);
  ASSERT_EQ(callbacks.recvPingReply, 0); // should be ignored

  auto lastRequest = callbacks.recvPingRequest;
  for (unsigned i = 0; i < 10; ++i) {
    egressCodec.generatePingRequest(buf);
    auto pingReq = buf.move();
    ingressCodec.onIngress(*pingReq);
    ASSERT_GT(callbacks.recvPingRequest, lastRequest);
    ASSERT_EQ(callbacks.recvPingRequest % 2, 0);
    lastRequest = callbacks.recvPingRequest;
  }
}

TEST	(	SPDYCodecTest	,
		DateHeader
	)

Definition at line 1006 of file SPDYCodecTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, getSynStream(), proxygen::FakeHTTPCodecCallback::headersComplete, proxygen::HTTP_HEADER_DATE, proxygen::FakeHTTPCodecCallback::messageBegin, proxygen::FakeHTTPCodecCallback::messageComplete, proxygen::FakeHTTPCodecCallback::msg, proxygen::SPDYCodec::onIngress(), proxygen::FakeHTTPCodecCallback::sessionErrors, proxygen::HTTPParallelCodec::setCallback(), proxygen::HTTPMessage::setStatusCode(), and proxygen::FakeHTTPCodecCallback::streamErrors.

                                {
  FakeHTTPCodecCallback callbacks;
  SPDYCodec egressCodec(TransportDirection::DOWNSTREAM,
                        SPDYVersion::SPDY3);
  SPDYCodec ingressCodec(TransportDirection::UPSTREAM,
                         SPDYVersion::SPDY3);
  ingressCodec.setCallback(&callbacks);

  HTTPMessage resp;
  resp.setStatusCode(200);
  auto syn = getSynStream(egressCodec, 1, resp, 0);
  ingressCodec.onIngress(*syn);
  EXPECT_EQ(callbacks.messageBegin, 1);
  EXPECT_EQ(callbacks.headersComplete, 1);
  EXPECT_EQ(callbacks.messageComplete, 0);
  EXPECT_EQ(callbacks.streamErrors, 0);
  EXPECT_EQ(callbacks.sessionErrors, 0);
  EXPECT_TRUE(callbacks.msg->getHeaders().exists(HTTP_HEADER_DATE));
}

TEST	(	SPDYCodecTest	,
		HeaderDoS
	)

Definition at line 1100 of file SPDYCodecTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_EQ, proxygen::FakeHTTPCodecCallback::headersComplete, proxygen::FakeHTTPCodecCallback::messageBegin, proxygen::FakeHTTPCodecCallback::messageComplete, multiValuedHeaderAttack, proxygen::SPDYCodec::onIngress(), proxygen::FakeHTTPCodecCallback::sessionErrors, proxygen::HTTPParallelCodec::setCallback(), and proxygen::FakeHTTPCodecCallback::streamErrors.

                               {
  FakeHTTPCodecCallback callbacks;
  SPDYCodec ingressCodec(TransportDirection::UPSTREAM,
                         SPDYVersion::SPDY3);
  ingressCodec.setCallback(&callbacks);

  auto attack = folly::IOBuf::copyBuffer(multiValuedHeaderAttack,
                                         sizeof(multiValuedHeaderAttack));

  ingressCodec.onIngress(*attack);
  EXPECT_EQ(callbacks.messageBegin, 0);
  EXPECT_EQ(callbacks.headersComplete, 0);
  EXPECT_EQ(callbacks.messageComplete, 0);
  EXPECT_EQ(callbacks.streamErrors, 1);
  EXPECT_EQ(callbacks.sessionErrors, 1);
}

TEST	(	SPDYCodecTest	,
		DoubleGoawayServer
	)

Definition at line 1119 of file SPDYCodecTest.cpp.

References folly::IOBufQueue::cacheChainLength(), proxygen::HTTPParallelCodec::enableDoubleGoawayDrain(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, f, proxygen::SPDYCodec::generateGoaway(), proxygen::FakeHTTPCodecCallback::goaways, proxygen::HTTPParallelCodec::isReusable(), proxygen::HTTPParallelCodec::isWaitingToDrain(), max, folly::IOBufQueue::move(), proxygen::SPDYCodec::onIngress(), gmock_output_test::output, and proxygen::HTTPParallelCodec::setCallback().

                                        {
  FakeHTTPCodecCallback callbacks;
  SPDYCodec egressCodec(TransportDirection::DOWNSTREAM,
                        SPDYVersion::SPDY3);
  SPDYCodec ingressCodec(TransportDirection::UPSTREAM,
                         SPDYVersion::SPDY3);

  egressCodec.enableDoubleGoawayDrain();
  ingressCodec.setCallback(&callbacks);
  egressCodec.setCallback(&callbacks);

  unsigned ack = std::numeric_limits<int32_t>::max();
  auto f = [&] () {
    folly::IOBufQueue output(folly::IOBufQueue::cacheChainLength());
    egressCodec.generateGoaway(output, ack, ErrorCode::NO_ERROR);
    auto ingress = output.move();
    ingressCodec.onIngress(*ingress);
    ack -= 2;
  };

  EXPECT_TRUE(egressCodec.isReusable());
  EXPECT_FALSE(egressCodec.isWaitingToDrain());
  EXPECT_TRUE(ingressCodec.isReusable());
  f();
  // server spdy codec remains reusable after the first goaway
  EXPECT_TRUE(egressCodec.isReusable());
  EXPECT_TRUE(egressCodec.isWaitingToDrain());
  f();
  EXPECT_FALSE(egressCodec.isReusable());
  EXPECT_FALSE(egressCodec.isWaitingToDrain());

  EXPECT_EQ(2, callbacks.goaways);
}

TEST	(	SPDYCodecTest	,
		DoubleGoawayClient
	)

Definition at line 1153 of file SPDYCodecTest.cpp.

References folly::IOBufQueue::cacheChainLength(), proxygen::HTTPParallelCodec::enableDoubleGoawayDrain(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, f, proxygen::SPDYCodec::generateGoaway(), proxygen::FakeHTTPCodecCallback::goaways, proxygen::HTTPParallelCodec::isReusable(), proxygen::HTTPParallelCodec::isWaitingToDrain(), max, folly::IOBufQueue::move(), proxygen::SPDYCodec::onIngress(), gmock_output_test::output, and proxygen::HTTPParallelCodec::setCallback().

                                        {
  FakeHTTPCodecCallback callbacks;
  SPDYCodec egressCodec(TransportDirection::UPSTREAM,
                        SPDYVersion::SPDY3);
  SPDYCodec ingressCodec(TransportDirection::DOWNSTREAM,
                         SPDYVersion::SPDY3);

  egressCodec.enableDoubleGoawayDrain();
  ingressCodec.setCallback(&callbacks);
  egressCodec.setCallback(&callbacks);

  unsigned ack = std::numeric_limits<int32_t>::max();
  auto f = [&] () {
    folly::IOBufQueue output(folly::IOBufQueue::cacheChainLength());
    egressCodec.generateGoaway(output, ack, ErrorCode::NO_ERROR);
    auto ingress = output.move();
    ingressCodec.onIngress(*ingress);
    ack -= 2;
  };

  EXPECT_TRUE(egressCodec.isReusable());
  EXPECT_FALSE(egressCodec.isWaitingToDrain());
  f();
  // client spdy codec not reusable after the first goaway
  EXPECT_FALSE(egressCodec.isReusable());
  EXPECT_TRUE(egressCodec.isWaitingToDrain());
  EXPECT_FALSE(ingressCodec.isReusable());
  f();
  EXPECT_FALSE(egressCodec.isReusable());
  EXPECT_FALSE(egressCodec.isWaitingToDrain());
  EXPECT_FALSE(ingressCodec.isReusable());

  EXPECT_EQ(2, callbacks.goaways);
}

TEST	(	SPDYCodecTest	,
		SingleGoawayClient
	)

Definition at line 1189 of file SPDYCodecTest.cpp.

References folly::IOBufQueue::cacheChainLength(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, f, proxygen::SPDYCodec::generateGoaway(), proxygen::FakeHTTPCodecCallback::goaways, proxygen::HTTPParallelCodec::isReusable(), proxygen::HTTPParallelCodec::isWaitingToDrain(), folly::IOBufQueue::move(), proxygen::SPDYCodec::onIngress(), gmock_output_test::output, and proxygen::HTTPParallelCodec::setCallback().

                                        {
  FakeHTTPCodecCallback callbacks;
  SPDYCodec egressCodec(TransportDirection::UPSTREAM,
                        SPDYVersion::SPDY3);
  SPDYCodec ingressCodec(TransportDirection::DOWNSTREAM,
                         SPDYVersion::SPDY3);

  ingressCodec.setCallback(&callbacks);
  egressCodec.setCallback(&callbacks);

  unsigned ack = 0;
  auto f = [&] () {
    folly::IOBufQueue output(folly::IOBufQueue::cacheChainLength());
    egressCodec.generateGoaway(output, ack, ErrorCode::NO_ERROR);
    auto ingress = output.move();
    ingressCodec.onIngress(*ingress);
    ack -= 2;
  };

  EXPECT_TRUE(egressCodec.isReusable());
  EXPECT_TRUE(egressCodec.isWaitingToDrain());
  f();
  // client spdy codec not reusable after the first goaway
  EXPECT_FALSE(egressCodec.isReusable());
  EXPECT_FALSE(egressCodec.isWaitingToDrain());
  EXPECT_FALSE(ingressCodec.isReusable());

  EXPECT_EQ(1, callbacks.goaways);
}

TEST	(	SPDYCodecTest	,
		OddHeaderListTest
	)

Definition at line 1235 of file SPDYCodecTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_EQ, proxygen::FakeHTTPCodecCallback::headersComplete, invalidHeaderPlusEmptyBlock, proxygen::FakeHTTPCodecCallback::messageBegin, proxygen::SPDYCodec::onIngress(), proxygen::HTTPParallelCodec::setCallback(), and proxygen::FakeHTTPCodecCallback::streamErrors.

                                       {
  FakeHTTPCodecCallback callbacks;
  SPDYCodec ingressCodec(TransportDirection::DOWNSTREAM,
                         SPDYVersion::SPDY3);
  ingressCodec.setCallback(&callbacks);

  auto attack = folly::IOBuf::copyBuffer(invalidHeaderPlusEmptyBlock,
                                         sizeof(invalidHeaderPlusEmptyBlock));

  ingressCodec.onIngress(*attack);
  EXPECT_EQ(callbacks.messageBegin, 1);
  EXPECT_EQ(callbacks.headersComplete, 1);
  EXPECT_EQ(callbacks.streamErrors, 1);
}

TEST	(	SPDYCodecTest	,
		SendRstParsingFrame
	)

Definition at line 1252 of file SPDYCodecTest.cpp.

References testing::_, folly::IOBufQueue::append(), folly::IOBufQueue::cacheChainLength(), EXPECT_CALL, proxygen::SPDYCodec::generateEOM(), proxygen::SPDYCodec::generateRstStream(), getSynStream(), testing::InvokeWithoutArgs(), folly::IOBufQueue::move(), folly::gen::move, proxygen::SPDYCodec::onIngress(), and proxygen::HTTPParallelCodec::setCallback().

                                         {
  NiceMock<MockHTTPCodecCallback> callbacks;
  SPDYCodec egressCodec(TransportDirection::UPSTREAM,
                        SPDYVersion::SPDY3_1);
  SPDYCodec ingressCodec(TransportDirection::DOWNSTREAM,
                         SPDYVersion::SPDY3_1);
  folly::IOBufQueue egressCodecQueue(folly::IOBufQueue::cacheChainLength());
  folly::IOBufQueue ingressCodecQueue(folly::IOBufQueue::cacheChainLength());

  InSequence enforceOrder;

  EXPECT_CALL(callbacks, onHeadersComplete(3, _))
    .WillOnce(InvokeWithoutArgs([&] {
          ingressCodec.generateRstStream(ingressCodecQueue,
                                         1, ErrorCode::CANCEL);
        }));
  EXPECT_CALL(callbacks, onMessageComplete(3, false));

  ingressCodec.setCallback(&callbacks);
  auto syn = getSynStream(egressCodec, 3);
  egressCodecQueue.append(std::move(syn));
  egressCodec.generateEOM(egressCodecQueue, 3);
  auto ingress = egressCodecQueue.move();
  ingress->coalesce();
  ingressCodec.onIngress(*ingress);
}

TEST	(	SPDYCodecTest	,
		BadNumNameValues
	)

Definition at line 1303 of file SPDYCodecTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_EQ, proxygen::FakeHTTPCodecCallback::headersComplete, invalidNumNameValuesBlock, proxygen::FakeHTTPCodecCallback::messageBegin, proxygen::SPDYCodec::onIngress(), proxygen::FakeHTTPCodecCallback::sessionErrors, proxygen::HTTPParallelCodec::setCallback(), and proxygen::FakeHTTPCodecCallback::streamErrors.

                                      {
  FakeHTTPCodecCallback callbacks;
  SPDYCodec ingressCodec(TransportDirection::DOWNSTREAM,
                         SPDYVersion::SPDY3_1);
  ingressCodec.setCallback(&callbacks);

  auto attack = folly::IOBuf::copyBuffer(invalidNumNameValuesBlock,
                                         sizeof(invalidNumNameValuesBlock));

  ingressCodec.onIngress(*attack);
  EXPECT_EQ(callbacks.messageBegin, 0);
  EXPECT_EQ(callbacks.headersComplete, 0);
  EXPECT_EQ(callbacks.streamErrors, 0);
  EXPECT_EQ(callbacks.sessionErrors, 1);
}

TEST	(	SPDYCodecTest	,
		ShortSettings
	)

Definition at line 1323 of file SPDYCodecTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_EQ, proxygen::FakeHTTPCodecCallback::headersComplete, kShortSettings, proxygen::FakeHTTPCodecCallback::messageBegin, proxygen::SPDYCodec::onIngress(), proxygen::FakeHTTPCodecCallback::sessionErrors, proxygen::HTTPParallelCodec::setCallback(), and proxygen::FakeHTTPCodecCallback::streamErrors.

                                   {
  FakeHTTPCodecCallback callbacks;
  SPDYCodec ingressCodec(TransportDirection::DOWNSTREAM,
                         SPDYVersion::SPDY3_1);
  ingressCodec.setCallback(&callbacks);

  auto attack = folly::IOBuf::copyBuffer(kShortSettings,
                                         sizeof(kShortSettings));

  ingressCodec.onIngress(*attack);
  EXPECT_EQ(callbacks.messageBegin, 0);
  EXPECT_EQ(callbacks.headersComplete, 0);
  EXPECT_EQ(callbacks.streamErrors, 0);
  EXPECT_EQ(callbacks.sessionErrors, 1);
}

TEST	(	SPDYCodecTest	,
		SegmentedHeaderBlock
	)

Definition at line 1339 of file SPDYCodecTest.cpp.

References ch, EXPECT_EQ, proxygen::HTTPMessage::getHeaders(), getSynStream(), proxygen::FakeHTTPCodecCallback::headersComplete, huge, i, proxygen::FakeHTTPCodecCallback::msg, proxygen::SPDYCodec::onIngress(), proxygen::FakeHTTPCodecCallback::reset(), proxygen::FakeHTTPCodecCallback::sessionErrors, proxygen::HTTPHeaders::set(), proxygen::HTTPParallelCodec::setCallback(), proxygen::HTTPMessage::setMethod(), proxygen::HTTPMessage::setStatusCode(), proxygen::HTTPMessage::setURL(), folly::size(), proxygen::FakeHTTPCodecCallback::streamErrors, and uint32_t.

                                          {
  SPDYCodec egressCodec(TransportDirection::UPSTREAM,
                        SPDYVersion::SPDY3_1);
  SPDYCodec ingressCodec(TransportDirection::DOWNSTREAM,
                         SPDYVersion::SPDY3_1);
  // generate huge string to use as a header value
  string huge;
  uint32_t size = 20000;
  char ch = 'a';
  for (uint32_t i = 0; i < size; i++) {
    huge.push_back(ch);
    if (ch == 'z') {
      ch = 'a';
    } else {
      ch++;
    }
  }
  HTTPMessage req;
  req.setMethod("GET");
  req.setURL("http://www.facebook.com");
  auto& reqHeaders = req.getHeaders();
  reqHeaders.set("HOST", "www.facebook.com");
  // setting this huge header value will cause allocation of a separate IOBuf
  reqHeaders.set("X-FB-Huge", huge);
  auto buf = getSynStream(egressCodec, 1, req);
  FakeHTTPCodecCallback callbacks;
  ingressCodec.setCallback(&callbacks);
  ingressCodec.onIngress(*buf);
  EXPECT_EQ(callbacks.streamErrors, 0);
  EXPECT_EQ(callbacks.sessionErrors, 0);
  EXPECT_EQ(callbacks.headersComplete, 1);
  EXPECT_EQ(callbacks.msg->getHeaders().getSingleOrEmpty("x-fb-huge").size(),
            size);

  // do it for responses
  HTTPMessage resp;
  resp.setStatusCode(200);
  resp.setStatusMessage("OK");
  auto& respHeaders = resp.getHeaders();
  respHeaders.set("X-FB-Huge", huge);
  auto buf2 = getSynStream(ingressCodec, 1, resp);
  callbacks.reset();
  egressCodec.setCallback(&callbacks);
  egressCodec.onIngress(*buf2);
  EXPECT_EQ(callbacks.streamErrors, 0);
  EXPECT_EQ(callbacks.sessionErrors, 0);
  EXPECT_EQ(callbacks.headersComplete, 1);
  EXPECT_EQ(callbacks.msg->getHeaders().getSingleOrEmpty("x-fb-huge").size(),
            size);
}

TEST	(	SPDYCodecTest	,
		ColonHeaders
	)

Definition at line 1397 of file SPDYCodecTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_EQ, proxygen::FakeHTTPCodecCallback::headersComplete, kColonHeaders, proxygen::SPDYCodec::onIngress(), proxygen::FakeHTTPCodecCallback::sessionErrors, proxygen::HTTPParallelCodec::setCallback(), and proxygen::FakeHTTPCodecCallback::streamErrors.

                                  {
  FakeHTTPCodecCallback callbacks;
  SPDYCodec ingressCodec(TransportDirection::DOWNSTREAM,
                         SPDYVersion::SPDY3_1);
  ingressCodec.setCallback(&callbacks);

  auto testBuf = folly::IOBuf::copyBuffer(kColonHeaders,
                                         sizeof(kColonHeaders));

  ingressCodec.onIngress(*testBuf);
  EXPECT_EQ(callbacks.headersComplete, 0);
  EXPECT_EQ(callbacks.streamErrors, 1);
  EXPECT_EQ(callbacks.sessionErrors, 0);
}

TEST	(	SPDYCodecTest	,
		StreamIdOverflow
	)

Definition at line 1412 of file SPDYCodecTest.cpp.

References codec, proxygen::HTTPParallelCodec::createStream(), EXPECT_EQ, proxygen::HTTPParallelCodec::isReusable(), max, and proxygen::HTTPParallelCodec::setNextEgressStreamId().

                                      {
  SPDYCodec codec(TransportDirection::UPSTREAM,
                  SPDYVersion::SPDY3_1);

  HTTPCodec::StreamID streamId;
  codec.setNextEgressStreamId(std::numeric_limits<int32_t>::max() - 10);
  while (codec.isReusable()) {
    streamId = codec.createStream();
  }
  EXPECT_EQ(streamId, std::numeric_limits<int32_t>::max() - 2);
}

TEST	(	SPDYCodecTest	,
		BadNVBlock
	)

Test case where nv item length is greater than total frame length

Definition at line 1435 of file SPDYCodecTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_EQ, proxygen::FakeHTTPCodecCallback::headersComplete, kBufBadNVBlock, proxygen::SPDYCodec::onIngress(), proxygen::FakeHTTPCodecCallback::sessionErrors, proxygen::HTTPParallelCodec::setCallback(), and proxygen::FakeHTTPCodecCallback::streamErrors.

                                {
  FakeHTTPCodecCallback callbacks;
  SPDYCodec ingressCodec(TransportDirection::DOWNSTREAM,
                         SPDYVersion::SPDY3_1);

  auto testBuf = IOBuf::copyBuffer(kBufBadNVBlock, sizeof(kBufBadNVBlock));
  ingressCodec.setCallback(&callbacks);
  ingressCodec.onIngress(*testBuf);
  EXPECT_EQ(callbacks.headersComplete, 0);
  EXPECT_EQ(callbacks.streamErrors, 0);
  EXPECT_EQ(callbacks.sessionErrors, 1);
}

TEST_F	(	SPDYCodecTestF	,
		GoawayHandling
	)

Definition at line 1460 of file SPDYCodecTest.cpp.

References proxygen::HTTPHeaders::add(), folly::IOBufQueue::cacheChainLength(), wangle::HTTPHeaderSize::compressed, dummy(), EXPECT_EQ, EXPECT_GT, proxygen::getGetRequest(), proxygen::HTTPMessage::getHeaders(), makeBuf(), parse(), proxygen::HTTPMessage::setPushStatusCode(), proxygen::HTTPMessage::setStatusCode(), folly::size(), and wangle::HTTPHeaderSize::uncompressed.

                                       {
  // send request
  HTTPMessage req = getGetRequest();
  HTTPHeaderSize size;
  size.uncompressed = size.compressed = 0;
  upstreamCodec_.generateHeader(output_, 1, req, true, &size);
  EXPECT_GT(size.uncompressed, 0);
  parse();
  callbacks_.expectMessage(true, 2, "/");
  callbacks_.reset();

  SetUpUpstreamTest();
  // drain after this message
  downstreamCodec_.generateGoaway(output_, 1, ErrorCode::NO_ERROR);
  parseUpstream();
  // upstream cannot generate id > 1
  upstreamCodec_.generateHeader(output_, 3, req, false, &size);
  EXPECT_EQ(size.uncompressed, 0);
  upstreamCodec_.generateWindowUpdate(output_, 3, 100);
  upstreamCodec_.generateBody(output_, 3, makeBuf(10), HTTPCodec::NoPadding,
                              false);
  upstreamCodec_.generatePriority(output_, 3,
                                  HTTPMessage::HTTPPriority(0, true, 1));
  upstreamCodec_.generateEOM(output_, 3);
  upstreamCodec_.generateRstStream(output_, 3, ErrorCode::CANCEL);
  EXPECT_EQ(output_.chainLength(), 0);

  // send a push promise that will be rejected by downstream
  req.setPushStatusCode(200);
  req.getHeaders().add("foomonkey", "george");
  downstreamCodec_.generatePushPromise(output_, 2, req, 1, false, &size);
  EXPECT_GT(size.uncompressed, 0);
  // window update for push doesn't make any sense, but whatever
  downstreamCodec_.generateWindowUpdate(output_, 2, 100);
  downstreamCodec_.generateBody(output_, 2, makeBuf(10), HTTPCodec::NoPadding,
                                false);

  // tell the upstream no pushing, and parse the first batch
  IOBufQueue dummy{IOBufQueue::cacheChainLength()};
  upstreamCodec_.generateGoaway(dummy, 0, ErrorCode::NO_ERROR);
  parseUpstream();

  downstreamCodec_.generatePriority(output_, 2,
                                    HTTPMessage::HTTPPriority(0, true, 1));
  downstreamCodec_.generateEOM(output_, 2);
  downstreamCodec_.generateRstStream(output_, 2, ErrorCode::CANCEL);

  // send a response that will be accepted, headers should be ok
  HTTPMessage resp;
  resp.setStatusCode(200);
  downstreamCodec_.generateHeader(output_, 1, resp, true, &size);
  EXPECT_GT(size.uncompressed, 0);

  // parse the remainder
  parseUpstream();
  callbacks_.expectMessage(true, 1, 200);
}

Variable Documentation

uint8_t badType[]

Initial value:

=
{ 0x80, 0x03, 0x00, 0x0A,
  0x00, 0x00, 0x00, 0x05,
  0x00, 0x00, 0x00, 0x00,
  0x00
}

Definition at line 86 of file SPDYCodecTest.cpp.

Referenced by TEST().

uint8_t invalidHeaderPlusEmptyBlock[]

Initial value:

=
{ 0x80, 0x03, 0x00, 0x02, 0xc4, 0x00, 0x00, 0x14,
  0xf7, 0x76, 0x2d, 0x37, 0x78, 0x9c, 0x93, 0x60,
  0x00, 0x03, 0x75, 0x06, 0xbd, 0x76, 0x21, 0xb2,
  0xd0, 0xd9, 0x54, 0x91, 0x80, 0x03, 0x00, 0x01,
  0x4e, 0x00, 0x00, 0x0a, 0xbe, 0x14, 0x31, 0x55,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00
}

Definition at line 1222 of file SPDYCodecTest.cpp.

Referenced by TEST().

uint8_t invalidNumNameValuesBlock[]

Initial value:

= {
  0x80, 0x03, 0x00, 0x01, 0x00, 0x00, 0x00, 0x91,
  0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
  0x00, 0x00, 0x38, 0x30, 0xe3, 0xc6, 0xa7, 0xc2,
  0x00, 0x77, 0x00, 0x88, 0xff, 0x00, 0x00, 0x00,
  0x05, 0x00, 0x00, 0x00, 0x05, 0x3a, 0x68, 0x6f,
  0x73, 0x74, 0x00, 0x00, 0x00, 0x0b, 0x77, 0x77,
  0x77, 0x2e, 0x66, 0x6f, 0x6f, 0x2e, 0x63, 0x6f,
  0x6d, 0x00, 0x00, 0x00, 0x77, 0x3a, 0x6d, 0x65,
  0x74, 0x68, 0x6f, 0x64, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x05, 0x3a, 0x70, 0x61, 0x74,
  0x68, 0x00, 0x13, 0x00, 0x14, 0x68, 0x74, 0x74,
  0x39, 0x73, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77,
  0x2e, 0x66, 0x6f, 0x6f, 0x2e, 0x63, 0x6f, 0x6d,
  0x2f, 0x00, 0x00, 0x00, 0x07, 0x3a, 0x73, 0x63,
  0x68, 0x65, 0x6d, 0x65, 0x00, 0x00, 0x00, 0x04,
  0x68, 0x74, 0x74, 0x70, 0x00, 0x00, 0x00, 0x08,
  0x3a, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
  0x00, 0x00, 0x00, 0x08, 0x48, 0x54, 0x54, 0x50,
  0x2f, 0x31, 0x2e, 0x31, 0x00, 0x00, 0x00, 0xff,
  0xff
}

Definition at line 1279 of file SPDYCodecTest.cpp.

Referenced by TEST().

const uint8_t kBufBadNVBlock[]

Initial value:

= {
 0x80, 0x03, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1c,
 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
 0x00, 0x00, 0x78, 0xbb, 0xe3, 0xc6, 0xa7, 0xc2,
 0x02, 0xa6, 0x23, 0xc6, 0xff, 0x40, 0x00, 0x00,
 0x00, 0x00, 0xff, 0xff
}

Definition at line 1424 of file SPDYCodecTest.cpp.

Referenced by TEST().

const uint8_t kColonHeaders[]

Initial value:

= {
  0x80, 0x03, 0x00, 0x01, 0x48, 0x00, 0x00, 0x1a, 0xf6, 0xf6, 0x1a, 0xb5,
  0x00, 0x00, 0x00, 0x00, 0x17, 0x28, 0x28, 0x53, 0x62, 0x60, 0x60, 0x10,
  0x60, 0x60, 0x60, 0x60, 0xb4, 0x1a, 0xbc, 0x84, 0xa4, 0xa4
}

Definition at line 1390 of file SPDYCodecTest.cpp.

Referenced by TEST().

const uint8_t kShortSettings[]

Initial value:

= {
  0x80, 0x03, 0x00, 0x04, 0xee, 0x00, 0x00, 0x01, 0x00, 0x00
}

Definition at line 1319 of file SPDYCodecTest.cpp.

Referenced by TEST().

uint8_t longPing[]

Initial value:

=
{ 0x80, 0x03, 0x00, 0x06,
  0x00, 0x00, 0x00, 0x05,
  0x00, 0x00, 0x00, 0x00,
  0x00
}

Definition at line 69 of file SPDYCodecTest.cpp.

Referenced by TEST().

uint8_t multiple_path_headers[]

Initial value:

=
    {0x80, 0x03, 0x00, 0x01, 0x01, 0x00, 0x01, 0x13, 0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x38, 0x30, 0xe3, 0xc6, 0xa7, 0xc2,
     0x00, 0xf9, 0x00, 0x06, 0xff, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
     0x05, 0x3a, 0x68, 0x6f, 0x73, 0x74, 0x00, 0x00, 0x00, 0x10, 0x77, 0x77,
     0x77, 0x2e, 0x66, 0x61, 0x63, 0x65, 0x62, 0x6f, 0x6f, 0x6b, 0x2e, 0x63,
     0x6f, 0x6d, 0x00, 0x00, 0x00, 0x07, 0x3a, 0x6d, 0x65, 0x74, 0x68, 0x6f,
     0x64, 0x00, 0x00, 0x00, 0x03, 0x47, 0x45, 0x54, 0x00, 0x00, 0x00, 0x05,
     0x3a, 0x70, 0x61, 0x74, 0x68, 0x00, 0x00, 0x00, 0x35, 0x2f, 0x65, 0x6e,
     0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x72, 0x65, 0x71, 0x75, 0x65,
     0x73, 0x74, 0x00, 0x2a, 0x23, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e,
     0x2f, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2f, 0x73, 0x69, 0x74, 0x65, 0x5f,
     0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x2e, 0x70, 0x68,
     0x70, 0x3f, 0x00, 0x00, 0x00, 0x07, 0x3a, 0x73, 0x63, 0x68, 0x65, 0x6d,
     0x65, 0x00, 0x00, 0x00, 0x05, 0x68, 0x74, 0x74, 0x70, 0x73, 0x00, 0x00,
     0x00, 0x08, 0x3a, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x00, 0x00,
     0x00, 0x08, 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x31, 0x00, 0x00,
     0x00, 0x06, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x00, 0x00, 0x00, 0x03,
     0x2a, 0x2f, 0x2a, 0x00, 0x00, 0x00, 0x0f, 0x61, 0x63, 0x63, 0x65, 0x70,
     0x74, 0x2d, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x00, 0x00,
     0x00, 0x0d, 0x67, 0x7a, 0x69, 0x70, 0x2c, 0x20, 0x64, 0x65, 0x66, 0x6c,
     0x61, 0x74, 0x65, 0x00, 0x00, 0x00, 0x0a, 0x75, 0x73, 0x65, 0x72, 0x2d,
     0x61, 0x67, 0x65, 0x6e, 0x74, 0x00, 0x00, 0x00, 0x11, 0x73, 0x70, 0x64,
     0x79, 0x6c, 0x61, 0x79, 0x2f, 0x31, 0x2e, 0x33, 0x2e, 0x33, 0x2d, 0x44,
     0x45, 0x56, 0x00, 0x00, 0x00, 0xff, 0xff, 0x80, 0x03, 0x00, 0x07, 0x00,
     0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}

Definition at line 576 of file SPDYCodecTest.cpp.

Referenced by TEST().

uint8_t multiValuedHeaderAttack[]

Definition at line 1027 of file SPDYCodecTest.cpp.

Referenced by TEST().

uint8_t pushStreamWithHostMissing[]

Initial value:

=
{  0x80, 0x3, 0x0, 0x1, 0x2, 0x0, 0x0, 0x7c,
   0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0x1,
   0x0, 0x0, 0x38, 0x30, 0xe3, 0xc6, 0xa7, 0xc2,
   0x0, 0x62, 0x0, 0x9d, 0xff, 0x0, 0x0, 0x0,
   0x4, 0x0, 0x0, 0x0, 0x5, 0x3a, 0x70, 0x61,
   0x74, 0x68, 0x0, 0x0, 0x0, 0x14, 0x68, 0x74,
   0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x77, 0x77,
   0x77, 0x2e, 0x66, 0x6f, 0x6f, 0x2e, 0x63, 0x6f,
   0x6d, 0x2f, 0x0, 0x0, 0x0, 0x7, 0x3a, 0x73,
   0x63, 0x68, 0x65, 0x6d, 0x65, 0x0, 0x0, 0x0,
   0x4, 0x68, 0x74, 0x74, 0x70, 0x0, 0x0, 0x0,
   0x7, 0x3a, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73,
   0x0, 0x0, 0x0, 0x3, 0x32, 0x30, 0x30, 0x0,
   0x0, 0x0, 0x8, 0x3a, 0x76, 0x65, 0x72, 0x73,
   0x69, 0x6f, 0x6e, 0x0, 0x0, 0x0, 0x8, 0x48,
   0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x31, 0x0,
   0x0, 0x0, 0xff, 0xff
}

A push stream with Host header missing

Definition at line 724 of file SPDYCodecTest.cpp.

Referenced by TEST().

uint8_t pushStreamWithOddId[]

Initial value:

=
{ 0x80, 0x03, 0x00, 0x01, 0x02, 0x00, 0x00, 0x91,
  0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
  0x00, 0x00, 0x38, 0x30, 0xe3, 0xc6, 0xa7, 0xc2,
  0x00, 0x77, 0x00, 0x88, 0xff, 0x00, 0x00, 0x00,
  0x05, 0x00, 0x00, 0x00, 0x05, 0x3a, 0x68, 0x6f,
  0x73, 0x74, 0x00, 0x00, 0x00, 0x0b, 0x77, 0x77,
  0x77, 0x2e, 0x66, 0x6f, 0x6f, 0x2e, 0x63, 0x6f,
  0x6d, 0x00, 0x00, 0x00, 0x07, 0x3a, 0x6d, 0x65,
  0x74, 0x68, 0x6f, 0x64, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x05, 0x3a, 0x70, 0x61, 0x74,
  0x68, 0x00, 0x00, 0x00, 0x14, 0x68, 0x74, 0x74,
  0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77,
  0x2e, 0x66, 0x6f, 0x6f, 0x2e, 0x63, 0x6f, 0x6d,
  0x2f, 0x00, 0x00, 0x00, 0x07, 0x3a, 0x73, 0x63,
  0x68, 0x65, 0x6d, 0x65, 0x00, 0x00, 0x00, 0x04,
  0x68, 0x74, 0x74, 0x70, 0x00, 0x00, 0x00, 0x08,
  0x3a, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
  0x00, 0x00, 0x00, 0x08, 0x48, 0x54, 0x54, 0x50,
  0x2f, 0x31, 0x2e, 0x31, 0x00, 0x00, 0x00, 0xff,
  0xff
}

A push stream with an odd StreamID

Definition at line 764 of file SPDYCodecTest.cpp.

Referenced by TEST().

uint8_t pushStreamWithoutAssoc[]

Initial value:

=
{ 0x80, 0x03, 0x00, 0x01, 0x02, 0x00, 0x00, 0x91,
  0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x38, 0x30, 0xe3, 0xc6, 0xa7, 0xc2,
  0x00, 0x77, 0x00, 0x88, 0xff, 0x00, 0x00, 0x00,
  0x05, 0x00, 0x00, 0x00, 0x05, 0x3a, 0x68, 0x6f,
  0x73, 0x74, 0x00, 0x00, 0x00, 0x0b, 0x77, 0x77,
  0x77, 0x2e, 0x66, 0x6f, 0x6f, 0x2e, 0x63, 0x6f,
  0x6d, 0x00, 0x00, 0x00, 0x07, 0x3a, 0x6d, 0x65,
  0x74, 0x68, 0x6f, 0x64, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x05, 0x3a, 0x70, 0x61, 0x74,
  0x68, 0x00, 0x00, 0x00, 0x14, 0x68, 0x74, 0x74,
  0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77,
  0x2e, 0x66, 0x6f, 0x6f, 0x2e, 0x63, 0x6f, 0x6d,
  0x2f, 0x00, 0x00, 0x00, 0x07, 0x3a, 0x73, 0x63,
  0x68, 0x65, 0x6d, 0x65, 0x00, 0x00, 0x00, 0x04,
  0x68, 0x74, 0x74, 0x70, 0x00, 0x00, 0x00, 0x08,
  0x3a, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
  0x00, 0x00, 0x00, 0x08, 0x48, 0x54, 0x54, 0x50,
  0x2f, 0x31, 0x2e, 0x31, 0x00, 0x00, 0x00, 0xff,
  0xff
}

A push stream with assocStreamID = SPDYCodec::NoStream

Definition at line 850 of file SPDYCodecTest.cpp.

Referenced by TEST().

uint8_t pushStreamWithoutUnidirectional[]

Initial value:

=
{ 0x80, 0x03, 0x00, 0x01, 0x00, 0x00, 0x00, 0x91,
  0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
  0x00, 0x00, 0x38, 0x30, 0xe3, 0xc6, 0xa7, 0xc2,
  0x00, 0x77, 0x00, 0x88, 0xff, 0x00, 0x00, 0x00,
  0x05, 0x00, 0x00, 0x00, 0x05, 0x3a, 0x68, 0x6f,
  0x73, 0x74, 0x00, 0x00, 0x00, 0x0b, 0x77, 0x77,
  0x77, 0x2e, 0x66, 0x6f, 0x6f, 0x2e, 0x63, 0x6f,
  0x6d, 0x00, 0x00, 0x00, 0x07, 0x3a, 0x6d, 0x65,
  0x74, 0x68, 0x6f, 0x64, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x05, 0x3a, 0x70, 0x61, 0x74,
  0x68, 0x00, 0x00, 0x00, 0x14, 0x68, 0x74, 0x74,
  0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77,
  0x2e, 0x66, 0x6f, 0x6f, 0x2e, 0x63, 0x6f, 0x6d,
  0x2f, 0x00, 0x00, 0x00, 0x07, 0x3a, 0x73, 0x63,
  0x68, 0x65, 0x6d, 0x65, 0x00, 0x00, 0x00, 0x04,
  0x68, 0x74, 0x74, 0x70, 0x00, 0x00, 0x00, 0x08,
  0x3a, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
  0x00, 0x00, 0x00, 0x08, 0x48, 0x54, 0x54, 0x50,
  0x2f, 0x31, 0x2e, 0x31, 0x00, 0x00, 0x00, 0xff,
  0xff
}

A push stream without unidirectional flag

Definition at line 807 of file SPDYCodecTest.cpp.

Referenced by TEST().

uint8_t shortSynReply[]

Initial value:

=
{ 0x80, 0x02, 0x00, 0x02, 0x01, 0x00, 0x00, 0x04, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
}

A syn reply frame with invalid length

Definition at line 515 of file SPDYCodecTest.cpp.

Referenced by doShortSynReplyTest().

uint8_t shortSynStream[]

Initial value:

=
{ 0x80, 0x03, 0x00, 0x01,
  0x01, 0x00, 0x00, 0x04,  
  0x61, 0x62, 0x63, 0x64
}

Definition at line 32 of file SPDYCodecTest.cpp.

Referenced by TEST().

uint8_t spdy3UnknownCtlFrame[]

Initial value:

=
{ 0x80, 0x03, 0x00, 0x0B, 
  0x00, 0x00, 0x00, 0x02, 
  0xD4, 0x74 
}

Definition at line 313 of file SPDYCodecTest.cpp.

Referenced by TEST().

uint8_t synStream[]

A request from firefox for facebook.com

Definition at line 108 of file SPDYCodecTest.cpp.

Referenced by TEST().