HTTP2FramerTest.cpp File Reference

#include <proxygen/lib/http/codec/test/HTTP2FramerTest.h>
#include <folly/Random.h>
#include <folly/portability/GTest.h>
#include <proxygen/lib/http/HTTPHeaderSize.h>
#include <proxygen/lib/http/HTTPMessage.h>
#include <proxygen/lib/http/codec/test/TestUtils.h>
#include <random>
#include <proxygen/lib/http/codec/HTTP2Framer.h>

Go to the source code of this file.

Classes
class	HTTP2FramerTest

Functions
void	writeFrameHeaderManual (IOBufQueue &queue, uint32_t length, uint8_t type, uint8_t flags, uint32_t stream)
	TEST_F (HTTP2FramerTest, WriteAndParseSmallDataNoPad)
	TEST_F (HTTP2FramerTest, WriteAndParseSmallDataZeroPad)
	TEST_F (HTTP2FramerTest, WriteAndParseSmallDataSmallPad)
	TEST_F (HTTP2FramerTest, ManyDataFrameSizes)
	TEST_F (HTTP2FramerTest, BadStreamData)
	TEST_F (HTTP2FramerTest, BadStreamSettings)
	TEST_F (HTTP2FramerTest, BadPad)
	TEST_F (HTTP2FramerTest, NoHeadroomOptimization)
	TEST_F (HTTP2FramerTest, UseHeadroomOptimization)
	TEST_F (HTTP2FramerTest, BadStreamId)
	TEST_F (HTTP2FramerTest, RstStream)
	TEST_F (HTTP2FramerTest, Goaway)
	TEST_F (HTTP2FramerTest, GoawayDebugData)
	TEST_F (HTTP2FramerTest, GoawayDoubleRead)
	TEST_F (HTTP2FramerTest, Priority)
	TEST_F (HTTP2FramerTest, HeadersWithPaddingAndPriority)
	TEST_F (HTTP2FramerTest, Ping)
	TEST_F (HTTP2FramerTest, WindowUpdate)
	TEST_F (HTTP2FramerTest, CertificateRequest)
	TEST_F (HTTP2FramerTest, EmptyCertificateRequest)
	TEST_F (HTTP2FramerTest, ShortCertificateRequest)
	TEST_F (HTTP2FramerTest, CertificateRequestOnNonzeroStream)
	TEST_F (HTTP2FramerTest, EndingCertificate)
	TEST_F (HTTP2FramerTest, Certificate)
	TEST_F (HTTP2FramerTest, EmptyCertificate)
	TEST_F (HTTP2FramerTest, ShortCertificate)
	TEST_F (HTTP2FramerTest, CertificateOnNonzeroStream)
	TEST_F (HTTP2FramerTest, ShortWindowUpdate)
	TEST_F (HTTP2FramerTest, Uint32MaxWindowUpdate)
	TEST_F (HTTP2FramerTest, AltSvc)
	TEST_F (HTTP2FramerTest, Settings)
	TEST_F (HTTP2FramerTest, SettingsAck)
	TEST_F (HTTP2FramerTest, BadSettingsAck)
	TEST_F (HTTP2FramerTest, UnknownSetting)
	TEST_F (HTTP2FramerTest, PushPromise)
	TEST_F (HTTP2FramerTest, Continuation)
	TEST_F (HTTP2FramerTest, ExHeaders)
	TEST_F (HTTP2FramerTest, ExHeadersWithFlagsSet)

Function Documentation

TEST_F	(	HTTP2FramerTest	,
		WriteAndParseSmallDataNoPad
	)

Definition at line 86 of file HTTP2FramerTest.cpp.

References proxygen::http2::kNoPadding.

                                                     {
  dataFrameTest(20, kNoPadding);
}

TEST_F	(	HTTP2FramerTest	,
		WriteAndParseSmallDataZeroPad
	)

Definition at line 90 of file HTTP2FramerTest.cpp.

                                                       {
  dataFrameTest(20, Padding(0));
}

TEST_F	(	HTTP2FramerTest	,
		WriteAndParseSmallDataSmallPad
	)

Definition at line 94 of file HTTP2FramerTest.cpp.

                                                        {
  dataFrameTest(20, Padding(20));
}

TEST_F	(	HTTP2FramerTest	,
		ManyDataFrameSizes
	)

Definition at line 98 of file HTTP2FramerTest.cpp.

References proxygen::http2::kMaxFramePayloadLength, proxygen::http2::kNoPadding, makeBuf(), uint32_t, and uint8_t.

                                            {
  dataFrameTest(0, kNoPadding);
  for (uint32_t dataLen = 1; dataLen < kMaxFramePayloadLength; dataLen <<= 1) {
    auto body = makeBuf(dataLen);
    dataFrameTest(body.get(), dataLen, Padding(0));
    dataFrameTest(0, Padding(dataLen));
    for (uint8_t padding = 1; padding != 0; padding <<= 1) {
      dataFrameTest(body.get(), dataLen, Padding(padding));
    }
  }
}

TEST_F	(	HTTP2FramerTest	,
		BadStreamData
	)

Definition at line 110 of file HTTP2FramerTest.cpp.

References EXPECT_EQ, proxygen::http2::parseData(), proxygen::http2::parseFrameHeader(), uint16_t, and writeFrameHeaderManual().

                                       {
  writeFrameHeaderManual(queue_, 0,
                         static_cast<uint8_t>(FrameType::DATA),
                         0, 0);
  FrameHeader outHeader;
  std::unique_ptr<IOBuf> outBuf;
  uint16_t padding = 0;
  Cursor cursor(queue_.front());
  EXPECT_EQ(parseFrameHeader(cursor, outHeader), ErrorCode::NO_ERROR);
  EXPECT_EQ(parseData(cursor, outHeader, outBuf, padding),
            ErrorCode::PROTOCOL_ERROR);
}

TEST_F	(	HTTP2FramerTest	,
		BadStreamSettings
	)

Definition at line 123 of file HTTP2FramerTest.cpp.

References proxygen::http2::ACK, EXPECT_EQ, proxygen::http2::parseFrameHeader(), proxygen::http2::parseSettings(), proxygen::spdy::SETTINGS, and writeFrameHeaderManual().

                                           {
  writeFrameHeaderManual(queue_, 0,
                         static_cast<uint8_t>(FrameType::SETTINGS),
                         ACK, 1);
  FrameHeader outHeader;
  std::deque<SettingPair> outSettings;
  Cursor cursor(queue_.front());
  EXPECT_EQ(parseFrameHeader(cursor, outHeader), ErrorCode::NO_ERROR);
  EXPECT_EQ(parseSettings(cursor, outHeader, outSettings),
            ErrorCode::PROTOCOL_ERROR);
}

TEST_F	(	HTTP2FramerTest	,
		BadPad
	)

Definition at line 135 of file HTTP2FramerTest.cpp.

References EXPECT_EQ, makeBuf(), proxygen::http2::parseData(), proxygen::http2::parseFrameHeader(), uint16_t, and proxygen::http2::writeData().

                                {
  auto body = makeBuf(5);
  writeData(queue_, body->clone(), 1, Padding(5), false, true);
  queue_.trimEnd(5);
  queue_.append(string("abcde"));

  FrameHeader outHeader;
  std::unique_ptr<IOBuf> outBuf;
  uint16_t padding = 0;
  Cursor cursor(queue_.front());
  EXPECT_EQ(parseFrameHeader(cursor, outHeader), ErrorCode::NO_ERROR);
  EXPECT_EQ(parseData(cursor, outHeader, outBuf, padding),
            ErrorCode::PROTOCOL_ERROR);
}

TEST_F	(	HTTP2FramerTest	,
		NoHeadroomOptimization
	)

Definition at line 150 of file HTTP2FramerTest.cpp.

References folly::IOBuf::create(), EXPECT_EQ, EXPECT_TRUE, proxygen::http2::kFrameHeaderSize, proxygen::http2::kFramePrioritySize, folly::gen::move, and proxygen::http2::writeData().

                                                {
  queue_.move();
  auto buf = folly::IOBuf::create(200);
  // This should make enough headroom so we will apply the optimization:
  auto headRoomSize = kFrameHeaderSize + kFramePrioritySize * 2 + 10;
  buf->advance(headRoomSize);
  buf->append(20); // make a positive length
  writeData(queue_, std::move(buf), 1, Padding(0), false,
            false /* reuseIOBufHeadroom */);
  auto queueHead = queue_.front();
  EXPECT_TRUE(queueHead->isChained());
  // This is our original iobuf:
  auto queueNode = queueHead->prev();
  EXPECT_TRUE(queueNode != nullptr);
  // And its headroom or length is untouched:
  EXPECT_EQ(headRoomSize, queueNode->headroom());
  EXPECT_EQ(20, queueNode->length());
}

TEST_F	(	HTTP2FramerTest	,
		UseHeadroomOptimization
	)

Definition at line 169 of file HTTP2FramerTest.cpp.

References folly::IOBuf::create(), EXPECT_FALSE, EXPECT_LT, proxygen::http2::kFrameHeaderSize, proxygen::http2::kFramePrioritySize, folly::gen::move, and proxygen::http2::writeData().

                                                 {
  queue_.move();
  auto buf = folly::IOBuf::create(200);
  // This should make enough headroom so we will apply the optimization:
  auto headRoomSize = kFrameHeaderSize + kFramePrioritySize * 2 + 10;
  buf->advance(headRoomSize);
  buf->append(20); // make a positive length
  writeData(queue_, std::move(buf), 1, Padding(0), false,
            true /* reuseIOBufHeadroom */);
  // There won't be a chain, frame header is written in-place into our IOBuf:
  auto queueNode = queue_.front();
  EXPECT_FALSE(queueNode->isChained());
  // And its headroom has been shrinked:
  EXPECT_LT(queueNode->headroom(), headRoomSize);
}

TEST_F	(	HTTP2FramerTest	,
		BadStreamId
	)

Definition at line 185 of file HTTP2FramerTest.cpp.

References EXPECT_DEATH_NO_CORE, and proxygen::http2::writeRstStream().

                                     {
  // We should crash on DBG builds if the stream id > 2^31 - 1
  EXPECT_DEATH_NO_CORE(writeRstStream(queue_,
                                      static_cast<uint32_t>(-1),
                                      ErrorCode::PROTOCOL_ERROR), ".*");
}

TEST_F	(	HTTP2FramerTest	,
		RstStream
	)

Definition at line 192 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, proxygen::http2::FrameHeader::flags, proxygen::http2::kFrameRstStreamSize, proxygen::http2::FrameHeader::length, parse(), proxygen::http2::parseRstStream(), proxygen::spdy::RST_STREAM, proxygen::http2::FrameHeader::stream, proxygen::http2::FrameHeader::type, and proxygen::http2::writeRstStream().

                                   {
  writeRstStream(queue_, 1, ErrorCode::CANCEL);

  FrameHeader header;
  ErrorCode outCode;
  parse(&parseRstStream, header, outCode);

  ASSERT_EQ(FrameType::RST_STREAM, header.type);
  ASSERT_EQ(1, header.stream);
  ASSERT_EQ(0, header.flags);
  ASSERT_EQ(kFrameRstStreamSize, header.length);
  ASSERT_EQ(ErrorCode::CANCEL, outCode);
}

TEST_F	(	HTTP2FramerTest	,
		Goaway
	)

Definition at line 206 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, ASSERT_FALSE, proxygen::http2::FrameHeader::flags, proxygen::spdy::GOAWAY, proxygen::http2::kFrameGoawaySize, proxygen::http2::FrameHeader::length, parse(), proxygen::http2::parseGoaway(), proxygen::http2::FrameHeader::stream, proxygen::http2::FrameHeader::type, uint32_t, and proxygen::http2::writeGoaway().

                                {
  writeGoaway(queue_, 0, ErrorCode::FLOW_CONTROL_ERROR);

  FrameHeader header;
  uint32_t lastStreamID;
  ErrorCode outCode;
  std::unique_ptr<IOBuf> outDebugData;
  parse(&parseGoaway, header, lastStreamID, outCode, outDebugData);

  ASSERT_EQ(FrameType::GOAWAY, header.type);
  ASSERT_EQ(0, header.stream);
  ASSERT_EQ(0, header.flags);
  ASSERT_EQ(kFrameGoawaySize, header.length);
  ASSERT_EQ(ErrorCode::FLOW_CONTROL_ERROR, outCode);
  ASSERT_EQ(0, lastStreamID);
  ASSERT_FALSE(outDebugData);
}

TEST_F	(	HTTP2FramerTest	,
		GoawayDebugData
	)

Definition at line 224 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, folly::IOBuf::computeChainDataLength(), folly::data(), EXPECT_EQ, proxygen::http2::FrameHeader::flags, proxygen::spdy::GOAWAY, proxygen::http2::kFrameGoawaySize, proxygen::http2::FrameHeader::length, makeBuf(), folly::gen::move, folly::IOBuf::moveToFbString(), parse(), proxygen::http2::parseGoaway(), proxygen::http2::FrameHeader::stream, proxygen::http2::FrameHeader::type, uint32_t, and proxygen::http2::writeGoaway().

                                         {
  string data("abcde");
  auto debugData = makeBuf(5);
  memcpy(debugData->writableData(), data.data(), data.length());
  writeGoaway(queue_, 0, ErrorCode::FLOW_CONTROL_ERROR, std::move(debugData));

  FrameHeader header;
  uint32_t lastStreamID;
  ErrorCode outCode;
  std::unique_ptr<IOBuf> outDebugData;
  parse(&parseGoaway, header, lastStreamID, outCode, outDebugData);

  ASSERT_EQ(FrameType::GOAWAY, header.type);
  ASSERT_EQ(0, header.stream);
  ASSERT_EQ(0, header.flags);
  ASSERT_EQ(kFrameGoawaySize + data.length(), header.length);
  ASSERT_EQ(ErrorCode::FLOW_CONTROL_ERROR, outCode);
  ASSERT_EQ(0, lastStreamID);
  ASSERT_EQ(outDebugData->computeChainDataLength(), data.length());
  EXPECT_EQ(outDebugData->moveToFbString(), data);
}

TEST_F	(	HTTP2FramerTest	,
		GoawayDoubleRead
	)

Definition at line 248 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, proxygen::spdy::GOAWAY, proxygen::http2::kFrameGoawaySize, proxygen::http2::parseFrameHeader(), proxygen::http2::parseGoaway(), proxygen::http2::FrameHeader::type, uint32_t, folly::io::detail::Writable< Derived >::writeBE(), and writeFrameHeaderManual().

                                          {
    writeFrameHeaderManual(
      queue_,
      kFrameGoawaySize,
      static_cast<uint8_t>(FrameType::GOAWAY),
      0,
      0);

    QueueAppender appender(&queue_, kFrameGoawaySize);
    appender.writeBE<uint32_t>(0);
    // Here's the invalid value:
    appender.writeBE<uint32_t>(static_cast<uint32_t>(0xffffffff));

    uint32_t outLastStreamID;
    ErrorCode outCode;
    std::unique_ptr<IOBuf> outDebugData;
    FrameHeader outHeader;
    Cursor cursor(queue_.front());

    auto ret1 = parseFrameHeader(cursor, outHeader);
    ASSERT_EQ(ErrorCode::NO_ERROR, ret1);
    ASSERT_EQ(FrameType::GOAWAY, outHeader.type);
    auto ret2 = parseGoaway(cursor, outHeader, outLastStreamID,
                            outCode, outDebugData);
    ASSERT_EQ(ErrorCode::PROTOCOL_ERROR, ret2);
}

TEST_F	(	HTTP2FramerTest	,
		Priority
	)

Definition at line 275 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, ASSERT_FALSE, proxygen::http2::PriorityUpdate::exclusive, parse(), proxygen::http2::parsePriority(), proxygen::http2::PRIORITY, proxygen::http2::PriorityUpdate::streamDependency, proxygen::http2::PriorityUpdate::weight, and proxygen::http2::writePriority().

                                  {
  writePriority(queue_, 102, {0, false, 30});

  FrameHeader header;
  PriorityUpdate priority;
  parse(&parsePriority, header, priority);

  ASSERT_EQ(FrameType::PRIORITY, header.type);
  ASSERT_EQ(102, header.stream);
  ASSERT_EQ(0, header.flags);
  ASSERT_EQ(0, priority.streamDependency);
  ASSERT_FALSE(priority.exclusive);
  ASSERT_EQ(30, priority.weight);
}

TEST_F	(	HTTP2FramerTest	,
		HeadersWithPaddingAndPriority
	)

Definition at line 290 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, ASSERT_FALSE, ASSERT_TRUE, proxygen::http2::END_HEADERS, proxygen::http2::END_STREAM, proxygen::http2::PriorityUpdate::exclusive, EXPECT_EQ, proxygen::spdy::HEADERS, makeBuf(), folly::IOBuf::moveToFbString(), parse(), proxygen::http2::parseHeaders(), proxygen::http2::PRIORITY, proxygen::http2::PriorityUpdate::streamDependency, proxygen::http2::PriorityUpdate::weight, and proxygen::http2::writeHeaders().

                                                       {
  auto body = makeBuf(500);
  writeHeaders(queue_, body->clone(), 1, {{0, true, 12}}, 200,
               false, false);

  FrameHeader header;
  folly::Optional<PriorityUpdate> priority;
  std::unique_ptr<IOBuf> outBuf;
  parse(&parseHeaders, header, priority, outBuf);

  ASSERT_EQ(FrameType::HEADERS, header.type);
  ASSERT_EQ(1, header.stream);
  ASSERT_TRUE(PRIORITY & header.flags);
  ASSERT_FALSE(END_STREAM & header.flags);
  ASSERT_FALSE(END_HEADERS & header.flags);
  ASSERT_EQ(0, priority->streamDependency);
  ASSERT_TRUE(priority->exclusive);
  ASSERT_EQ(12, priority->weight);
  EXPECT_EQ(outBuf->moveToFbString(), body->moveToFbString());
}

TEST_F	(	HTTP2FramerTest	,
		Ping
	)

Definition at line 311 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, folly::data(), EXPECT_EQ, proxygen::http2::FrameHeader::flags, parse(), proxygen::http2::parsePing(), proxygen::spdy::PING, folly::Random::rand64(), proxygen::http2::FrameHeader::stream, proxygen::http2::FrameHeader::type, uint64_t, and proxygen::http2::writePing().

                              {
  uint64_t data = folly::Random::rand64();
  writePing(queue_, data, false);

  FrameHeader header;
  uint64_t outData;
  parse(&parsePing, header, outData);

  ASSERT_EQ(FrameType::PING, header.type);
  ASSERT_EQ(0, header.stream);
  ASSERT_EQ(0, header.flags);
  EXPECT_EQ(data, outData);
}

TEST_F	(	HTTP2FramerTest	,
		WindowUpdate
	)

Definition at line 325 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, EXPECT_EQ, proxygen::http2::FrameHeader::flags, parse(), proxygen::http2::parseWindowUpdate(), proxygen::http2::FrameHeader::stream, proxygen::http2::FrameHeader::type, uint32_t, proxygen::spdy::WINDOW_UPDATE, and proxygen::http2::writeWindowUpdate().

                                      {
  writeWindowUpdate(queue_, 33, 120);

  FrameHeader header;
  uint32_t amount;
  parse(&parseWindowUpdate, header, amount);

  ASSERT_EQ(FrameType::WINDOW_UPDATE, header.type);
  ASSERT_EQ(33, header.stream);
  ASSERT_EQ(0, header.flags);
  EXPECT_EQ(120, amount);
}

TEST_F	(	HTTP2FramerTest	,
		CertificateRequest
	)

Definition at line 338 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, folly::IOBuf::computeChainDataLength(), folly::data(), EXPECT_EQ, proxygen::http2::FrameHeader::flags, proxygen::http2::kFrameCertificateRequestSizeBase, proxygen::http2::FrameHeader::length, makeBuf(), folly::gen::move, folly::IOBuf::moveToFbString(), parse(), proxygen::http2::parseCertificateRequest(), proxygen::http2::FrameHeader::stream, proxygen::http2::FrameHeader::type, uint16_t, and proxygen::http2::writeCertificateRequest().

                                            {
  string data("abcdef");
  auto authRequest = makeBuf(6);
  memcpy(authRequest->writableData(), data.data(), data.length());
  uint16_t requestId = 120;
  writeCertificateRequest(queue_, requestId, std::move(authRequest));

  FrameHeader header;
  uint16_t outRequestId;
  std::unique_ptr<IOBuf> outAuthRequest;
  parse(&parseCertificateRequest, header, outRequestId, outAuthRequest);

  ASSERT_EQ(FrameType::CERTIFICATE_REQUEST, header.type);
  ASSERT_EQ(0, header.stream);
  ASSERT_EQ(0, header.flags);
  ASSERT_EQ(kFrameCertificateRequestSizeBase + data.length(), header.length);
  ASSERT_EQ(outRequestId, requestId);
  ASSERT_EQ(outAuthRequest->computeChainDataLength(), data.length());
  EXPECT_EQ(outAuthRequest->moveToFbString(), data);
}

TEST_F	(	HTTP2FramerTest	,
		EmptyCertificateRequest
	)

Definition at line 359 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, ASSERT_FALSE, proxygen::http2::FrameHeader::flags, proxygen::http2::kFrameCertificateRequestSizeBase, proxygen::http2::FrameHeader::length, parse(), proxygen::http2::parseCertificateRequest(), proxygen::http2::FrameHeader::stream, proxygen::http2::FrameHeader::type, uint16_t, and proxygen::http2::writeCertificateRequest().

                                                 {
  uint16_t requestId = 120;
  writeCertificateRequest(queue_, requestId, nullptr);

  FrameHeader header;
  uint16_t outRequestId;
  std::unique_ptr<IOBuf> outAuthRequest;
  parse(&parseCertificateRequest, header, outRequestId, outAuthRequest);

  ASSERT_EQ(FrameType::CERTIFICATE_REQUEST, header.type);
  ASSERT_EQ(0, header.stream);
  ASSERT_EQ(0, header.flags);
  ASSERT_EQ(kFrameCertificateRequestSizeBase, header.length);
  ASSERT_EQ(outRequestId, requestId);
  ASSERT_FALSE(outAuthRequest);
}

TEST_F	(	HTTP2FramerTest	,
		ShortCertificateRequest
	)

Definition at line 376 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, proxygen::http2::parseCertificateRequest(), proxygen::http2::parseFrameHeader(), uint16_t, uint8_t, folly::io::detail::Writable< Derived >::writeBE(), and writeFrameHeaderManual().

                                                 {
  // length field is too short for frame type
  writeFrameHeaderManual(
      queue_, 1, static_cast<uint8_t>(FrameType::CERTIFICATE_REQUEST), 0, 0);
  QueueAppender appender(&queue_, 1);
  appender.writeBE<uint8_t>(1);

  Cursor cursor(queue_.front());
  FrameHeader header;
  uint16_t outRequestId;
  std::unique_ptr<IOBuf> outAuthRequest;
  parseFrameHeader(cursor, header);
  auto ret =
      parseCertificateRequest(cursor, header, outRequestId, outAuthRequest);
  ASSERT_EQ(ErrorCode::FRAME_SIZE_ERROR, ret);
}

TEST_F	(	HTTP2FramerTest	,
		CertificateRequestOnNonzeroStream
	)

Definition at line 393 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, proxygen::http2::parseCertificateRequest(), proxygen::http2::parseFrameHeader(), uint16_t, folly::io::detail::Writable< Derived >::writeBE(), and writeFrameHeaderManual().

                                                           {
  // received CERTIFICATE_REQUEST frame on nonzero stream
  writeFrameHeaderManual(
      queue_, 2, static_cast<uint8_t>(FrameType::CERTIFICATE_REQUEST), 0, 1);
  QueueAppender appender(&queue_, 1);
  appender.writeBE<uint16_t>(1);

  Cursor cursor(queue_.front());
  FrameHeader header;
  uint16_t outRequestId;
  std::unique_ptr<IOBuf> outAuthRequest;
  parseFrameHeader(cursor, header);
  auto ret =
      parseCertificateRequest(cursor, header, outRequestId, outAuthRequest);
  ASSERT_EQ(ErrorCode::PROTOCOL_ERROR, ret);
}

TEST_F	(	HTTP2FramerTest	,
		EndingCertificate
	)

Definition at line 410 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, folly::IOBuf::computeChainDataLength(), folly::data(), EXPECT_EQ, proxygen::http2::FrameHeader::flags, proxygen::http2::kFrameCertificateSizeBase, proxygen::http2::FrameHeader::length, makeBuf(), folly::gen::move, folly::IOBuf::moveToFbString(), parse(), proxygen::http2::parseCertificate(), proxygen::http2::FrameHeader::stream, proxygen::http2::FrameHeader::type, uint16_t, and proxygen::http2::writeCertificate().

                                           {
  string data("abcdef");
  auto authenticator = makeBuf(6);
  memcpy(authenticator->writableData(), data.data(), data.length());
  uint16_t certId = 120;
  // The last CERTIFICATE frame containing authenticator fragment.
  writeCertificate(queue_, certId, std::move(authenticator), false);

  FrameHeader header;
  uint16_t outCertId;
  std::unique_ptr<IOBuf> outAuthenticator;
  parse(&parseCertificate, header, outCertId, outAuthenticator);

  ASSERT_EQ(FrameType::CERTIFICATE, header.type);
  ASSERT_EQ(0, header.stream);
  ASSERT_EQ(0, header.flags);
  ASSERT_EQ(kFrameCertificateSizeBase + data.length(), header.length);
  ASSERT_EQ(outCertId, certId);
  ASSERT_EQ(outAuthenticator->computeChainDataLength(), data.length());
  EXPECT_EQ(outAuthenticator->moveToFbString(), data);
}

TEST_F	(	HTTP2FramerTest	,
		Certificate
	)

Definition at line 432 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, ASSERT_TRUE, folly::IOBuf::computeChainDataLength(), folly::data(), EXPECT_EQ, proxygen::http2::FrameHeader::flags, proxygen::http2::kFrameCertificateSizeBase, proxygen::http2::FrameHeader::length, makeBuf(), folly::gen::move, folly::IOBuf::moveToFbString(), parse(), proxygen::http2::parseCertificate(), proxygen::http2::FrameHeader::stream, proxygen::http2::TO_BE_CONTINUED, proxygen::http2::FrameHeader::type, uint16_t, and proxygen::http2::writeCertificate().

                                     {
  string data("abcdef");
  auto authenticator = makeBuf(6);
  memcpy(authenticator->writableData(), data.data(), data.length());
  uint16_t certId = 120;
  // CERTIFICATE frame containing an authenticator fragment but not the last
  // fragment.
  writeCertificate(queue_, certId, std::move(authenticator), true);

  FrameHeader header;
  uint16_t outCertId;
  std::unique_ptr<IOBuf> outAuthenticator;
  parse(&parseCertificate, header, outCertId, outAuthenticator);

  ASSERT_EQ(FrameType::CERTIFICATE, header.type);
  ASSERT_EQ(0, header.stream);
  ASSERT_TRUE(TO_BE_CONTINUED & header.flags);
  ASSERT_EQ(kFrameCertificateSizeBase + data.length(), header.length);
  ASSERT_EQ(outCertId, certId);
  ASSERT_EQ(outAuthenticator->computeChainDataLength(), data.length());
  EXPECT_EQ(outAuthenticator->moveToFbString(), data);
}

TEST_F	(	HTTP2FramerTest	,
		EmptyCertificate
	)

Definition at line 455 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, ASSERT_FALSE, ASSERT_TRUE, proxygen::http2::FrameHeader::flags, proxygen::http2::kFrameCertificateSizeBase, proxygen::http2::FrameHeader::length, parse(), proxygen::http2::parseCertificate(), proxygen::http2::FrameHeader::stream, proxygen::http2::TO_BE_CONTINUED, proxygen::http2::FrameHeader::type, uint16_t, and proxygen::http2::writeCertificate().

                                          {
  uint16_t certId = 120;
  writeCertificate(queue_, certId, nullptr, true);

  FrameHeader header;
  uint16_t outCertId;
  std::unique_ptr<IOBuf> outAuthenticator;
  parse(&parseCertificate, header, outCertId, outAuthenticator);

  ASSERT_EQ(FrameType::CERTIFICATE, header.type);
  ASSERT_EQ(0, header.stream);
  ASSERT_TRUE(TO_BE_CONTINUED & header.flags);
  ASSERT_EQ(kFrameCertificateSizeBase, header.length);
  ASSERT_EQ(outCertId, certId);
  ASSERT_FALSE(outAuthenticator);
}

TEST_F	(	HTTP2FramerTest	,
		ShortCertificate
	)

Definition at line 472 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, proxygen::http2::parseCertificate(), proxygen::http2::parseFrameHeader(), uint16_t, uint8_t, folly::io::detail::Writable< Derived >::writeBE(), and writeFrameHeaderManual().

                                          {
  // length field is too short for frame type
  writeFrameHeaderManual(
      queue_, 1, static_cast<uint8_t>(FrameType::CERTIFICATE), 0, 0);
  QueueAppender appender(&queue_, 1);
  appender.writeBE<uint8_t>(1);

  Cursor cursor(queue_.front());
  FrameHeader header;
  uint16_t outCertId;
  std::unique_ptr<IOBuf> outAuthenticator;
  parseFrameHeader(cursor, header);
  auto ret = parseCertificate(cursor, header, outCertId, outAuthenticator);
  ASSERT_EQ(ErrorCode::FRAME_SIZE_ERROR, ret);
}

TEST_F	(	HTTP2FramerTest	,
		CertificateOnNonzeroStream
	)

Definition at line 488 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, proxygen::http2::parseCertificate(), proxygen::http2::parseFrameHeader(), uint16_t, folly::io::detail::Writable< Derived >::writeBE(), and writeFrameHeaderManual().

                                                    {
  // received CERTIFICATE frame on nonzero stream
  writeFrameHeaderManual(
      queue_, 2, static_cast<uint8_t>(FrameType::CERTIFICATE), 0, 1);
  QueueAppender appender(&queue_, 1);
  appender.writeBE<uint16_t>(1);

  Cursor cursor(queue_.front());
  FrameHeader header;
  uint16_t outCertId;
  std::unique_ptr<IOBuf> outAuthenticator;
  parseFrameHeader(cursor, header);
  auto ret = parseCertificate(cursor, header, outCertId, outAuthenticator);
  ASSERT_EQ(ErrorCode::PROTOCOL_ERROR, ret);
}

TEST_F	(	HTTP2FramerTest	,
		ShortWindowUpdate
	)

Definition at line 505 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, proxygen::http2::parseFrameHeader(), proxygen::http2::parseWindowUpdate(), uint32_t, proxygen::spdy::WINDOW_UPDATE, and writeFrameHeaderManual().

                                           {
  // length field is too short for frame type
  writeFrameHeaderManual(queue_, 0,
                         static_cast<uint8_t>(FrameType::WINDOW_UPDATE),
                         0, 0);

  Cursor cursor(queue_.front());
  FrameHeader header;
  uint32_t amount;
  parseFrameHeader(cursor, header);
  auto ret2 = parseWindowUpdate(cursor, header, amount);
  ASSERT_EQ(ErrorCode::FRAME_SIZE_ERROR, ret2);
}

TEST_F	(	HTTP2FramerTest	,
		Uint32MaxWindowUpdate
	)

Definition at line 519 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, EXPECT_EQ, i, proxygen::http2::kFrameHeaderSize, parse(), proxygen::http2::parseWindowUpdate(), uint32_t, proxygen::spdy::WINDOW_UPDATE, and proxygen::http2::writeWindowUpdate().

                                               {
  const uint32_t uint31Max = 0x7fffffff;
  writeWindowUpdate(queue_, 33, 1); // we will overwrite the update size
  auto buf = queue_.move();
  buf->coalesce();
  // Set update size to unit32_t max
  for (unsigned i = 0; i < 4; ++i) {
    buf->writableData()[kFrameHeaderSize + i] = 0xff;
  }

  FrameHeader header;
  uint32_t amount;
  parse(buf.get(), &parseWindowUpdate, header, amount);

  ASSERT_EQ(FrameType::WINDOW_UPDATE, header.type);
  ASSERT_EQ(33, header.stream);
  ASSERT_EQ(0, header.flags);
  // We should ignore the top bit
  EXPECT_EQ(uint31Max, amount);
}

TEST_F	(	HTTP2FramerTest	,
		AltSvc
	)

Definition at line 540 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, EXPECT_EQ, proxygen::http2::FrameHeader::flags, parse(), proxygen::http2::parseAltSvc(), proxygen::http2::FrameHeader::stream, proxygen::http2::FrameHeader::type, uint32_t, and proxygen::http2::writeAltSvc().

                                {
  string protocol = "special-proto";
  string host = "special-host";
  string origin = "special-origin";
  writeAltSvc(queue_, 2, 150, 8080, protocol, host, origin);

  FrameHeader header;
  uint32_t outMaxAge;
  uint32_t outPort;
  string outProtocol;
  string outHost;
  string outOrigin;
  parse(&parseAltSvc, header, outMaxAge, outPort, outProtocol,
        outHost, outOrigin);

  ASSERT_EQ(FrameType::ALTSVC, header.type);
  ASSERT_EQ(2, header.stream);
  ASSERT_EQ(0, header.flags);
  EXPECT_EQ(150, outMaxAge);
  EXPECT_EQ(8080, outPort);
  EXPECT_EQ(protocol, outProtocol);
  EXPECT_EQ(host, outHost);
  EXPECT_EQ(origin, outOrigin);
}

TEST_F	(	HTTP2FramerTest	,
		Settings
	)

Definition at line 565 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, proxygen::http2::FrameHeader::flags, proxygen::http2::FrameHeader::length, parse(), proxygen::http2::parseSettings(), proxygen::spdy::SETTINGS, settings, proxygen::http2::FrameHeader::stream, proxygen::http2::FrameHeader::type, and proxygen::http2::writeSettings().

                                  {
  const deque<SettingPair> settings = {{SettingsId::HEADER_TABLE_SIZE, 3},
                                       {SettingsId::MAX_CONCURRENT_STREAMS, 4}};
  writeSettings(queue_, settings);

  FrameHeader header;
  std::deque<SettingPair> outSettings;
  parse(&parseSettings, header, outSettings);

  ASSERT_EQ(settings.size() * 6, header.length);
  ASSERT_EQ(FrameType::SETTINGS, header.type);
  ASSERT_EQ(0, header.stream);
  ASSERT_EQ(0, header.flags);
  ASSERT_EQ(settings, outSettings);
}

TEST_F	(	HTTP2FramerTest	,
		SettingsAck
	)

Definition at line 581 of file HTTP2FramerTest.cpp.

References proxygen::http2::ACK, ASSERT_EQ, EXPECT_EQ, proxygen::http2::parseFrameHeader(), proxygen::http2::parseSettings(), proxygen::spdy::SETTINGS, and proxygen::http2::writeSettingsAck().

                                     {
  writeSettingsAck(queue_);

  Cursor cursor(queue_.front());
  FrameHeader header;
  auto ret = parseFrameHeader(cursor, header);
  ASSERT_EQ(ErrorCode::NO_ERROR, ret);

  ASSERT_EQ(0, header.length);
  ASSERT_EQ(FrameType::SETTINGS, header.type);
  ASSERT_EQ(0, header.stream);
  ASSERT_EQ(ACK, header.flags);
  std::deque<SettingPair> outSettings;
  EXPECT_EQ(parseSettings(cursor, header, outSettings), ErrorCode::NO_ERROR);
}

TEST_F	(	HTTP2FramerTest	,
		BadSettingsAck
	)

Definition at line 597 of file HTTP2FramerTest.cpp.

References proxygen::http2::ACK, ASSERT_EQ, EXPECT_EQ, proxygen::http2::parseFrameHeader(), proxygen::http2::parseSettings(), proxygen::spdy::SETTINGS, uint32_t, uint8_t, and proxygen::http2::writeSettingsAck().

                                        {
  writeSettingsAck(queue_);
  // Add an extra byte to the frame
  uint32_t lengthAndType = htonl(1 << 8 | uint8_t(FrameType::SETTINGS));
  memcpy(((IOBuf*)queue_.front())->writableData(), &lengthAndType, 4);
  queue_.append("o");

  Cursor cursor(queue_.front());
  FrameHeader header;
  auto ret = parseFrameHeader(cursor, header);
  ASSERT_EQ(ErrorCode::NO_ERROR, ret);

  ASSERT_EQ(FrameType::SETTINGS, header.type);
  ASSERT_EQ(0, header.stream);
  ASSERT_EQ(ACK, header.flags);
  std::deque<SettingPair> outSettings;
  EXPECT_EQ(parseSettings(cursor, header, outSettings),
            ErrorCode::FRAME_SIZE_ERROR);
}

TEST_F	(	HTTP2FramerTest	,
		UnknownSetting
	)

Definition at line 617 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, proxygen::http2::FrameHeader::flags, proxygen::http2::FrameHeader::length, parse(), proxygen::http2::parseSettings(), proxygen::spdy::SETTINGS, settings, proxygen::http2::FrameHeader::stream, proxygen::http2::FrameHeader::type, and proxygen::http2::writeSettings().

                                        {
  const deque<SettingPair> settings = {{(proxygen::SettingsId)31337, 3},
                                       {(proxygen::SettingsId)0, 4}};
  writeSettings(queue_, settings);

  FrameHeader header;
  std::deque<SettingPair> outSettings;
  parse(&parseSettings, header, outSettings);

  ASSERT_EQ(settings.size() * 6, header.length);
  ASSERT_EQ(FrameType::SETTINGS, header.type);
  ASSERT_EQ(0, header.stream);
  ASSERT_EQ(0, header.flags);
  ASSERT_EQ(settings, outSettings);
}

TEST_F	(	HTTP2FramerTest	,
		PushPromise
	)

Definition at line 633 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, EXPECT_EQ, makeBuf(), folly::IOBuf::moveToFbString(), parse(), proxygen::http2::parsePushPromise(), uint32_t, and proxygen::http2::writePushPromise().

                                     {
  auto body = makeBuf(500);
  writePushPromise(queue_, 21, 22, body->clone(), 255, true);

  FrameHeader header;
  uint32_t promisedStream;
  std::unique_ptr<IOBuf> outBuf;
  parse(&parsePushPromise, header, promisedStream, outBuf);

  ASSERT_EQ(FrameType::PUSH_PROMISE, header.type);
  ASSERT_EQ(21, header.stream);
  ASSERT_EQ(22, promisedStream);
  EXPECT_EQ(outBuf->moveToFbString(), body->moveToFbString());
}

TEST_F	(	HTTP2FramerTest	,
		Continuation
	)

Definition at line 648 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, ASSERT_FALSE, ASSERT_TRUE, proxygen::http2::END_HEADERS, EXPECT_EQ, makeBuf(), folly::IOBuf::moveToFbString(), proxygen::http2::PADDED, parse(), proxygen::http2::parseContinuation(), and proxygen::http2::writeContinuation().

                                      {
  auto body = makeBuf(800);
  writeContinuation(queue_, 1, true, body->clone());

  FrameHeader header;
  std::unique_ptr<IOBuf> outBuf;
  parse(&parseContinuation, header, outBuf);

  ASSERT_EQ(FrameType::CONTINUATION, header.type);
  ASSERT_TRUE(END_HEADERS & header.flags);
  ASSERT_FALSE(PADDED & header.flags);
  ASSERT_EQ(1, header.stream);
  EXPECT_EQ(outBuf->moveToFbString(), body->moveToFbString());
}

TEST_F	(	HTTP2FramerTest	,
		ExHeaders
	)

Definition at line 663 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, ASSERT_FALSE, ASSERT_TRUE, proxygen::HTTPCodec::ExAttributes::controlStream, proxygen::http2::END_HEADERS, proxygen::http2::END_STREAM, proxygen::http2::PriorityUpdate::exclusive, EXPECT_EQ, makeBuf(), folly::IOBuf::moveToFbString(), parse(), proxygen::http2::parseExHeaders(), proxygen::http2::PRIORITY, folly::Random::rand32(), proxygen::http2::PriorityUpdate::streamDependency, streamID, uint32_t, proxygen::HTTPCodec::ExAttributes::unidirectional, proxygen::http2::UNIDIRECTIONAL, proxygen::http2::PriorityUpdate::weight, and proxygen::http2::writeExHeaders().

                                   {
  auto body = makeBuf(500);
  uint32_t streamID = folly::Random::rand32(10, 1024) * 2 + 1;
  uint32_t controlStream = streamID - 2;
  writeExHeaders(queue_, body->clone(), streamID,
                 HTTPCodec::ExAttributes(controlStream, false),
                 {{0, true, 12}}, 200, false, false);

  FrameHeader header;
  HTTPCodec::ExAttributes outExAttributes;
  folly::Optional<PriorityUpdate> priority;
  std::unique_ptr<IOBuf> outBuf;
  parse(&parseExHeaders, header, outExAttributes, priority, outBuf);

  ASSERT_EQ(FrameType::EX_HEADERS, header.type);
  ASSERT_EQ(streamID, header.stream);
  ASSERT_EQ(controlStream, outExAttributes.controlStream);
  ASSERT_TRUE(PRIORITY & header.flags);
  ASSERT_FALSE(END_STREAM & header.flags);
  ASSERT_FALSE(END_HEADERS & header.flags);
  ASSERT_FALSE(UNIDIRECTIONAL & header.flags);
  ASSERT_FALSE(outExAttributes.unidirectional);
  ASSERT_EQ(0, priority->streamDependency);
  ASSERT_TRUE(priority->exclusive);
  ASSERT_EQ(12, priority->weight);
  EXPECT_EQ(outBuf->moveToFbString(), body->moveToFbString());
}

TEST_F	(	HTTP2FramerTest	,
		ExHeadersWithFlagsSet
	)

Definition at line 691 of file HTTP2FramerTest.cpp.

References ASSERT_EQ, ASSERT_FALSE, ASSERT_TRUE, proxygen::HTTPCodec::ExAttributes::controlStream, proxygen::http2::END_HEADERS, proxygen::http2::END_STREAM, EXPECT_EQ, makeBuf(), folly::IOBuf::moveToFbString(), folly::none, parse(), proxygen::http2::parseExHeaders(), proxygen::http2::PRIORITY, folly::Random::rand32(), streamID, uint32_t, proxygen::HTTPCodec::ExAttributes::unidirectional, proxygen::http2::UNIDIRECTIONAL, and proxygen::http2::writeExHeaders().

                                               {
  auto body = makeBuf(500);
  uint32_t streamID = folly::Random::rand32(10, 1024) * 2 + 1;
  uint32_t controlStream = streamID - 2;
  writeExHeaders(queue_, body->clone(), streamID,
                 HTTPCodec::ExAttributes(controlStream, true),
                 folly::none, 0, true, true);

  FrameHeader header;
  HTTPCodec::ExAttributes outExAttributes;
  folly::Optional<PriorityUpdate> priority;
  std::unique_ptr<IOBuf> outBuf;
  parse(&parseExHeaders, header, outExAttributes, priority, outBuf);

  ASSERT_EQ(FrameType::EX_HEADERS, header.type);
  ASSERT_EQ(streamID, header.stream);
  ASSERT_EQ(controlStream, outExAttributes.controlStream);
  ASSERT_FALSE(PRIORITY & header.flags);
  ASSERT_TRUE(END_STREAM & header.flags);
  ASSERT_TRUE(END_HEADERS & header.flags);
  ASSERT_TRUE(UNIDIRECTIONAL & header.flags);
  ASSERT_TRUE(outExAttributes.unidirectional);
  EXPECT_EQ(outBuf->moveToFbString(), body->moveToFbString());
}

void writeFrameHeaderManual	(	IOBufQueue &	queue,
		uint32_t	length,
		uint8_t	type,
		uint8_t	flags,
		uint32_t	stream
	)

Definition at line 27 of file HTTP2FramerTest.cpp.

References proxygen::http2::kFrameHeaderSize, stream, type, uint32_t, uint8_t, and folly::io::detail::Writable< Derived >::writeBE().

Referenced by TEST_F().

                                                            {
  QueueAppender appender(&queue, kFrameHeaderSize);
  uint32_t lengthAndType = length << 8 | type;
  appender.writeBE<uint32_t>(lengthAndType);
  appender.writeBE<uint8_t>(flags);
  appender.writeBE<uint32_t>(stream);
}