QPACKCodecTests.cpp File Reference

#include <folly/Range.h>
#include <folly/io/Cursor.h>
#include <folly/io/IOBuf.h>
#include <glog/logging.h>
#include <folly/portability/GTest.h>
#include <proxygen/lib/http/codec/compress/Header.h>
#include <proxygen/lib/http/codec/compress/HeaderCodec.h>
#include <proxygen/lib/http/codec/compress/QPACKCodec.h>
#include <proxygen/lib/http/codec/compress/test/TestStreamingCallback.h>
#include <proxygen/lib/http/codec/compress/test/TestUtil.h>
#include <vector>

Go to the source code of this file.

Classes
class	QPACKTests

Functions
	TEST_F (QPACKTests, TestSimple)
	TEST_F (QPACKTests, TestAbsoluteIndex)
	TEST_F (QPACKTests, TestWithQueue)
	TEST_F (QPACKTests, HeaderCodecStats)

Function Documentation

TEST_F	(	QPACKTests	,
		TestSimple
	)

Definition at line 64 of file QPACKCodecTests.cpp.

References ASSERT_NE, proxygen::hpack::basicHeaders(), EXPECT_EQ, EXPECT_TRUE, and folly::gen::move.

                               {
  vector<Header> req = basicHeaders();
  auto encodeResult = client.encode(req, 1);
  ASSERT_NE(encodeResult.control.get(), nullptr);
  EXPECT_EQ(server.decodeEncoderStream(std::move(encodeResult.control)),
            HPACK::DecodeError::NONE);
  TestStreamingCallback cb;
  auto length = encodeResult.stream->computeChainDataLength();
  server.decodeStreaming(1, std::move(encodeResult.stream), length, &cb);
  headerAck(1);
  auto result = cb.getResult();
  EXPECT_TRUE(!result.hasError());
  headersEq(req, result->headers);
}

TEST_F	(	QPACKTests	,
		TestAbsoluteIndex
	)

Definition at line 79 of file QPACKCodecTests.cpp.

References ASSERT_NE, EXPECT_EQ, EXPECT_TRUE, proxygen::hpack::headersFromArray(), folly::gen::move, string, and folly::value().

                                      {
  int flights = 10;
  for (int i = 0; i < flights; i++) {
    vector<vector<string>> headers;
    for (int j = 0; j < 32; j++) {
      int value = (i >> 1) * 32 + j; // duplicate the last flight
      headers.emplace_back(
        vector<string>({string("foomonkey"), folly::to<string>(value)}));
    }
    auto req = headersFromArray(headers);
    auto encodeResult = client.encode(req, i + 1);
    if (i % 2 == 1) {
      EXPECT_EQ(encodeResult.control.get(), nullptr);
    } else {
      ASSERT_NE(encodeResult.control.get(), nullptr);
      CHECK_EQ(server.decodeEncoderStream(std::move(encodeResult.control)),
               HPACK::DecodeError::NONE);
    }
    TestStreamingCallback cb;
    auto length = encodeResult.stream->computeChainDataLength();
    server.decodeStreaming(i + 1, std::move(encodeResult.stream), length, &cb);
    headerAck(i + 1);
    auto result = cb.getResult();
    EXPECT_TRUE(!result.hasError());
    headersEq(req, result->headers);
  }
}

TEST_F	(	QPACKTests	,
		TestWithQueue
	)

Definition at line 107 of file QPACKCodecTests.cpp.

References proxygen::hpack::basicHeaders(), folly::data(), EXPECT_EQ, EXPECT_TRUE, f, proxygen::HTTP_HEADER_CONNECTION, i, max, folly::gen::move, and values().

                                  {
  // Sends 10 flights of 4 requests each
  // Each request contains two 'connection' headers, one with the current
  // index, and current index - 8.
  // Each flight is processed in the order 0, 3, 2, 1, unless an eviction
  // happens on 2 or 3, in which case we force an blocking event.
  vector<Header> req = basicHeaders();
  vector<string> values;
  int flights = 10;
  for (auto i = 0; i < flights * 4; i++) {
    values.push_back(folly::to<string>(i));
  }
  client.setEncoderHeaderTableSize(1024);
  for (auto f = 0; f < flights; f++) {
    vector<std::pair<unique_ptr<IOBuf>, TestStreamingCallback>> data;
    list<unique_ptr<IOBuf>> controlFrames;
    for (int i = 0; i < 4; i++) {
      auto reqI = req;
      for (int j = 0; j < 2; j++) {
        reqI.emplace_back(HTTP_HEADER_CONNECTION, values[
                            std::max(f * 4 + i - j * 8, 0)]);
      }
      VLOG(4) << "Encoding req=" << f * 4 + i;
      auto res = client.encode(reqI, f * 4 + i);
      if (res.control && res.control->computeChainDataLength() > 0) {
        controlFrames.emplace_back(std::move(res.control));
      }
      data.emplace_back(std::move(res.stream), TestStreamingCallback());
    }

    std::vector<int> insertOrder{0, 3, 2, 1};
    if (!controlFrames.empty()) {
      auto control = std::move(controlFrames.front());
      controlFrames.pop_front();
      server.decodeEncoderStream(std::move(control));
    }
    for (auto i: insertOrder) {
      auto& encodedReq = data[i].first;
      auto len = encodedReq->computeChainDataLength();
      server.decodeStreaming(i, std::move(encodedReq), len, &data[i].second);
    }
    while (!controlFrames.empty()) {
      auto control = std::move(controlFrames.front());
      controlFrames.pop_front();
      server.decodeEncoderStream(std::move(control));
    }
    int i = 0;
    for (auto& d: data) {
      auto result = d.second.getResult();
      EXPECT_TRUE(!result.hasError());
      auto reqI = req;
      for (int j = 0; j < 2; j++) {
        reqI.emplace_back(HTTP_HEADER_CONNECTION,
                          values[std::max(f * 4 + i - j * 8, 0)]);
      }
      headersEq(reqI, result->headers);
      headerAck(f * 4 + i);
      i++;
    }
    VLOG(4) << "getHolBlockCount=" << server.getHolBlockCount();
  }
  // Skipping redundant table adds reduces the HOL block count
  EXPECT_EQ(server.getHolBlockCount(), 30);

}

TEST_F	(	QPACKTests	,
		HeaderCodecStats
	)

Definition at line 173 of file QPACKCodecTests.cpp.

References proxygen::hpack::TestHeaderCodecStats::decodedBytesCompr, proxygen::hpack::TestHeaderCodecStats::decodedBytesUncompr, proxygen::hpack::TestHeaderCodecStats::decodes, proxygen::hpack::TestHeaderCodecStats::encodedBytesCompr, proxygen::hpack::TestHeaderCodecStats::encodedBytesUncompr, proxygen::hpack::TestHeaderCodecStats::encodes, proxygen::hpack::TestHeaderCodecStats::errors, EXPECT_EQ, EXPECT_GT, EXPECT_TRUE, proxygen::TestStreamingCallback::getResult(), proxygen::hpack::headersFromArray(), folly::gen::move, and proxygen::hpack::TestHeaderCodecStats::reset().

                                     {
  vector<vector<string>> headers = {
    {"Content-Length", "80"},
    {"Content-Encoding", "gzip"},
    {"X-FB-Debug", "eirtijvdgtccffkutnbttcgbfieghgev"}
  };
  vector<Header> resp = headersFromArray(headers);

  TestHeaderCodecStats stats(HeaderCodec::Type::QPACK);
  // encode
  server.setStats(&stats);
  auto encResult = server.encode(resp, 1);
  EXPECT_EQ(stats.encodes, 1);
  EXPECT_EQ(stats.decodes, 0);
  EXPECT_EQ(stats.errors, 0);
  EXPECT_TRUE(stats.encodedBytesCompr > 0);
  EXPECT_TRUE(stats.encodedBytesUncompr > 0);
  EXPECT_EQ(stats.decodedBytesCompr, 0);
  EXPECT_EQ(stats.decodedBytesUncompr, 0);
  server.setStats(nullptr);

  // decode
  stats.reset();
  client.setStats(&stats);
  TestStreamingCallback cb;
  auto len = encResult.stream->computeChainDataLength();
  client.decodeEncoderStream(std::move(encResult.control));
  client.decodeStreaming(1, std::move(encResult.stream), len, &cb);
  auto result = cb.getResult();
  EXPECT_TRUE(!result.hasError());
  auto& decoded = result->headers;
  CHECK_EQ(decoded.size(), 3 * 2);
  EXPECT_EQ(stats.decodes, 1);
  EXPECT_EQ(stats.encodes, 0);
  EXPECT_GT(stats.decodedBytesCompr, 0);
  EXPECT_GT(stats.decodedBytesUncompr, 0);
  EXPECT_EQ(stats.encodedBytesCompr, 0);
  EXPECT_EQ(stats.encodedBytesUncompr, 0);
  client.setStats(nullptr);
}