HPACKHeaderTests.cpp File Reference

#include <folly/portability/GTest.h>
#include <proxygen/lib/http/codec/compress/HPACKHeader.h>
#include <proxygen/lib/http/codec/compress/HeaderIndexingStrategy.h>
#include <sstream>

Go to the source code of this file.

Classes
class	HPACKHeaderTests
class	HPACKHeaderNameTest

Functions
	TEST_F (HPACKHeaderTests, Size)
	TEST_F (HPACKHeaderTests, Operators)
	TEST_F (HPACKHeaderTests, HasValue)
	TEST_F (HPACKHeaderTests, HeaderIndexingStrategyBasic)
HPACKHeaderName	destroyedHPACKHeaderName (std::string name)
	TEST_F (HPACKHeaderNameTest, TestConstructor)
	TEST_F (HPACKHeaderNameTest, TestCopyConstructor)
	TEST_F (HPACKHeaderNameTest, TestMoveConstructor)
	TEST_F (HPACKHeaderNameTest, TestAssignmentOperators)
	TEST_F (HPACKHeaderNameTest, TestGetSize)
	TEST_F (HPACKHeaderNameTest, TestOperators)
	TEST_F (HPACKHeaderNameTest, TestIsCommonHeader)

Function Documentation

HPACKHeaderName destroyedHPACKHeaderName

(

std::string

name

)

Definition at line 71 of file HPACKHeaderTests.cpp.

Referenced by TEST_F().

                                                         {
  //return a HPACKHeaderName that goes destroyed
  HPACKHeaderName headerName(name);
  return headerName;
}

TEST_F	(	HPACKHeaderTests	,
		Size
	)

Definition at line 22 of file HPACKHeaderTests.cpp.

References proxygen::HPACKHeader::bytes(), EXPECT_EQ, and h.

                               {
  HPACKHeader h(":path", "/");
  EXPECT_EQ(h.bytes(), 32 + 5 + 1);
}

TEST_F	(	HPACKHeaderTests	,
		Operators
	)

Definition at line 27 of file HPACKHeaderTests.cpp.

References EXPECT_EQ, EXPECT_FALSE, and EXPECT_TRUE.

                                    {
  HPACKHeader h0(":path", "/");
  HPACKHeader h1(":path", "/");
  HPACKHeader h2(":path", "/index.php");
  HPACKHeader h3("x-fb-debug", "test");
  // ==
  EXPECT_TRUE(h0 == h1);
  EXPECT_FALSE(h1 == h2);
  // <
  EXPECT_FALSE(h1 < h1);
  EXPECT_TRUE(h1 < h2);
  EXPECT_TRUE(h1 < h3);
  // >
  EXPECT_FALSE(h2 > h2);
  EXPECT_TRUE(h3 > h2);
  EXPECT_TRUE(h2 > h1);

  stringstream out;
  out << h1;
  EXPECT_EQ(out.str(), ":path: /");
}

TEST_F	(	HPACKHeaderTests	,
		HasValue
	)

Definition at line 49 of file HPACKHeaderTests.cpp.

References EXPECT_FALSE, EXPECT_TRUE, and proxygen::HPACKHeader::hasValue().

                                   {
  HPACKHeader h1(":path", "");
  HPACKHeader h2(":path", "/");
  EXPECT_FALSE(h1.hasValue());
  EXPECT_TRUE(h2.hasValue());
}

TEST_F	(	HPACKHeaderTests	,
		HeaderIndexingStrategyBasic
	)

Definition at line 56 of file HPACKHeaderTests.cpp.

References data, EXPECT_FALSE, EXPECT_TRUE, and proxygen::HeaderIndexingStrategy::indexHeader().

                                                      {
  HeaderIndexingStrategy indexingStrat;
  HPACKHeader path(":path", "index.php?q=42");
  EXPECT_FALSE(indexingStrat.indexHeader(path));
  HPACKHeader cdn(":path", "/hprofile-ak-prn1/49496_6024432_1026115112_n.jpg");
  EXPECT_FALSE(indexingStrat.indexHeader(cdn));
  HPACKHeader clen("content-length", "512");
  EXPECT_FALSE(indexingStrat.indexHeader(clen));
  HPACKHeader data("data", "value");
  EXPECT_TRUE(indexingStrat.indexHeader(data));
}

TEST_F	(	HPACKHeaderNameTest	,
		TestConstructor
	)

Definition at line 77 of file HPACKHeaderTests.cpp.

References EXPECT_EQ, and proxygen::HPACKHeaderName::get().

                                             {
  // Test constructor
  HPACKHeaderName name1("accept-encoding");
  HPACKHeaderName name2("content-length");
  HPACKHeaderName name3("uncommon-name");
  HPACKHeaderName name4("uncommon-name-2");
  EXPECT_EQ(name1.get(), "accept-encoding");
  EXPECT_EQ(name2.get(), "content-length");
  EXPECT_EQ(name3.get(), "uncommon-name");
  EXPECT_EQ(name4.get(), "uncommon-name-2");
}

TEST_F	(	HPACKHeaderNameTest	,
		TestCopyConstructor
	)

Definition at line 89 of file HPACKHeaderTests.cpp.

References destroyedHPACKHeaderName(), EXPECT_EQ, and proxygen::HPACKHeaderName::get().

                                                 {
  HPACKHeaderName name1("accept-encoding");
  HPACKHeaderName name2("uncommon-name");

  // Test copy constructor
  HPACKHeaderName name3(name1);
  HPACKHeaderName name4(name2);
  HPACKHeaderName name5(destroyedHPACKHeaderName("x-fb-debug"));
  HPACKHeaderName name6(destroyedHPACKHeaderName("uncommon-name"));
  EXPECT_EQ(name3.get(), "accept-encoding");
  EXPECT_EQ(name4.get(), "uncommon-name");
  EXPECT_EQ(name5.get(), "x-fb-debug");
  EXPECT_EQ(name6.get(), "uncommon-name");
}

TEST_F	(	HPACKHeaderNameTest	,
		TestMoveConstructor
	)

Definition at line 104 of file HPACKHeaderTests.cpp.

References EXPECT_EQ, proxygen::HPACKHeaderName::get(), and folly::gen::move.

                                                 {
  HPACKHeaderName name1("accept-encoding");
  HPACKHeaderName name2("uncommon-name");

  // Test move constructor
  HPACKHeaderName name3(std::move(name1));
  HPACKHeaderName name4(std::move(name2));
  EXPECT_EQ(name3.get(), "accept-encoding");
  EXPECT_EQ(name4.get(), "uncommon-name");
}

TEST_F	(	HPACKHeaderNameTest	,
		TestAssignmentOperators
	)

Definition at line 115 of file HPACKHeaderTests.cpp.

References EXPECT_EQ, proxygen::HPACKHeaderName::get(), folly::gen::move, and string.

                                                     {
  std::string testHeaderName = "accept-encoding";

  HPACKHeaderName name1(testHeaderName);
  EXPECT_EQ(name1.get(), testHeaderName);

  // Explicitly test some self assignment overloads
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunknown-warning-option"
#pragma clang diagnostic ignored "-Wself-assign-overloaded"
#endif
  name1 = name1;
#ifdef __clang__
#pragma clang diagnostic pop
#endif
  EXPECT_EQ(name1.get(), testHeaderName);
  HPACKHeaderName* pName1 = &name1;
  // Specifically require a temporary above to throw off the compiler/lint:
  // explicitly moving variable of type 'proxygen::HPACKHeaderName' to itself
  name1 = std::move(*pName1);
  EXPECT_EQ(name1.get(), testHeaderName);

  std::string otherHeaderName = "uncommon-name";
  HPACKHeaderName name2(otherHeaderName);
  name1 = name2;
  EXPECT_EQ(name1.get(), otherHeaderName);
  EXPECT_EQ(name2.get(), otherHeaderName);

  HPACKHeaderName name3(testHeaderName);
  name1 = std::move(name3);
  EXPECT_EQ(name1.get(), testHeaderName);

  name1 = otherHeaderName;
  EXPECT_EQ(name1.get(), otherHeaderName);
}

TEST_F	(	HPACKHeaderNameTest	,
		TestGetSize
	)

Definition at line 152 of file HPACKHeaderTests.cpp.

References EXPECT_EQ, and proxygen::HPACKHeaderName::size().

                                         {
  // Test size()
  HPACKHeaderName name1("accept-encoding");
  HPACKHeaderName name2("uncommon-header_now");
  EXPECT_EQ(name1.size(), 15);
  EXPECT_EQ(name2.size(), 19);
}

TEST_F	(	HPACKHeaderNameTest	,
		TestOperators
	)

Definition at line 160 of file HPACKHeaderTests.cpp.

                                           {
  // Test operators
  HPACKHeaderName name1("aaa");
  HPACKHeaderName name2("bbb");
  HPACKHeaderName name3("aaa");
  HPACKHeaderName name4("bbb");
  CHECK(name1 == name3);
  CHECK(name1 != name2);
  CHECK(name1 < name2);
  CHECK(name2 > name1);
  CHECK(name1 >= name3);
  CHECK(name2 >= name1);
  CHECK(name2 <= name4);
  CHECK(name1 <= name2);
}

TEST_F	(	HPACKHeaderNameTest	,
		TestIsCommonHeader
	)

Definition at line 176 of file HPACKHeaderTests.cpp.

References EXPECT_EQ, EXPECT_FALSE, proxygen::HTTPCommonHeaders::getPointerToHeaderName(), proxygen::HTTPHeaderCodeCommonOffset, proxygen::HPACKHeaderName::isCommonHeader(), proxygen::HPACKHeader::name, proxygen::HTTPCommonHeaders::num_header_codes, string, and uint64_t.

                                                {
  for (uint64_t j = 0; j < HTTPCommonHeaders::num_header_codes; ++j) {
    HTTPHeaderCode code = static_cast<HTTPHeaderCode>(j);
    HPACKHeader testHPACKHeader(
      *HTTPCommonHeaders::getPointerToHeaderName(code), "");

    bool checkResult = j >= HTTPHeaderCodeCommonOffset;
    EXPECT_EQ(testHPACKHeader.name.isCommonHeader(), checkResult);
  }
  std::string externalHeader = "externalHeader";
  HPACKHeader testHPACKHeader(externalHeader, "");
  EXPECT_FALSE(testHPACKHeader.name.isCommonHeader());
}