proxygen::hpack Namespace Reference

Classes
class	TestHeaderCodecStats

Functions
void	dumpToFile (const string &filename, const IOBuf *buf)
void	verifyHeaders (vector< HPACKHeader > &headers, vector< HPACKHeader > &decodedHeaders)
unique_ptr< IOBuf >	encodeDecode (vector< HPACKHeader > &headers, HPACKEncoder &encoder, HPACKDecoder &decoder)
void	encodeDecode (vector< HPACKHeader > &headers, QPACKEncoder &encoder, QPACKDecoder &decoder)
unique_ptr< HPACKDecoder::headers_t >	decode (HPACKDecoder &decoder, const IOBuf *buffer)
vector< compress::Header >	headersFromArray (vector< vector< string >> &a)
vector< compress::Header >	basicHeaders ()

Function Documentation

std::vector< compress::Header > proxygen::hpack::basicHeaders

(

)

Definition at line 116 of file TestUtil.cpp.

References headersFromArray().

Referenced by TEST_F(), and TEST_P().

                                      {
  static vector<vector<string>> headersStrings = {
    {":path", "/index.php"},
    {":authority", "www.facebook.com"},
    {":method", "GET"},
    {":scheme", "https"},
    {"Host", "www.facebook.com"},
    {"accept-encoding", "gzip"}
  };
  static vector<compress::Header> headers = headersFromArray(headersStrings);
  return headers;
}

std::unique_ptr< HPACKDecoder::headers_t > proxygen::hpack::decode	(	HPACKDecoder &	decoder,
		const IOBuf *	buffer
	)

Definition at line 95 of file TestUtil.cpp.

References proxygen::HPACKDecoder::decodeStreaming(), proxygen::TestStreamingCallback::hasError(), proxygen::TestStreamingCallback::hpackHeaders(), and uint32_t.

Referenced by checkError(), encodeDecode(), TEST_F(), and TEST_P().

                                                                {
  auto headers = std::make_unique<HPACKDecoder::headers_t>();
  folly::io::Cursor cursor(buffer);
  uint32_t totalBytes = buffer ? cursor.totalLength() : 0;
  TestStreamingCallback cb;
  decoder.decodeStreaming(cursor, totalBytes, &cb);
  if (cb.hasError()) {
    return headers;
  }
  return cb.hpackHeaders();
}

void proxygen::hpack::dumpToFile	(	const string &	filename,
		const IOBuf *	buf
	)

Definition at line 27 of file TestUtil.cpp.

References folly::IOBuf::data(), folly::IOBuf::length(), and folly::IOBuf::next().

                                                          {
  ofstream outfile(filename, ofstream::binary);
  if (buf) {
    const IOBuf* p = buf;
    do {
      outfile.write((const char *)p->data(), p->length());
      p = p->next();
    } while (p->next() != buf);
  }
  outfile.close();
}

std::unique_ptr< folly::IOBuf > proxygen::hpack::encodeDecode	(	vector< HPACKHeader > &	headers,
		HPACKEncoder &	encoder,
		HPACKDecoder &	decoder
	)

Definition at line 55 of file TestUtil.cpp.

References decode(), proxygen::HPACKEncoder::encode(), EXPECT_EQ, proxygen::HPACKContext::getTable(), proxygen::HPACKDecoderBase::hasError(), and verifyHeaders().

                           {
  unique_ptr<IOBuf> encoded = encoder.encode(headers);
  auto decodedHeaders = hpack::decode(decoder, encoded.get());
  CHECK(!decoder.hasError());

  verifyHeaders(headers, *decodedHeaders);

  // header tables should look the same
  CHECK(encoder.getTable() == decoder.getTable());
  EXPECT_EQ(encoder.getTable(), decoder.getTable());

  return encoded;
}

void proxygen::hpack::encodeDecode	(	vector< HPACKHeader > &	headers,
		QPACKEncoder &	encoder,
		QPACKDecoder &	decoder
	)

Definition at line 72 of file TestUtil.cpp.

References proxygen::QPACKEncoder::decodeDecoderStream(), proxygen::QPACKDecoder::decodeEncoderStream(), proxygen::QPACKDecoder::decodeStreaming(), proxygen::QPACKEncoder::encode(), proxygen::QPACKDecoder::encodeHeaderAck(), proxygen::QPACKDecoder::encodeTableStateSync(), EXPECT_EQ, proxygen::QPACKContext::getTable(), proxygen::TestStreamingCallback::hasError(), proxygen::TestStreamingCallback::hpackHeaders(), folly::gen::move, and verifyHeaders().

                           {
  auto encoded = encoder.encode(headers, 0, 1);
  TestStreamingCallback cb;
  if (encoded.control) {
    decoder.decodeEncoderStream(std::move(encoded.control));
    encoder.decodeDecoderStream(decoder.encodeTableStateSync());
  }
  CHECK(encoded.stream);
  auto length = encoded.stream->computeChainDataLength();
  decoder.decodeStreaming(1, std::move(encoded.stream), length, &cb);
  CHECK(!cb.hasError());
  auto decodedHeaders = cb.hpackHeaders();
  verifyHeaders(headers, *decodedHeaders);
  encoder.decodeDecoderStream(decoder.encodeHeaderAck(1));

  // header tables should look the same
  CHECK(encoder.getTable() == decoder.getTable());
  EXPECT_EQ(encoder.getTable(), decoder.getTable());
}

std::vector< compress::Header > proxygen::hpack::headersFromArray

(

vector< vector< string >> &

a

)

Definition at line 108 of file TestUtil.cpp.

References a, and proxygen::compress::Header::makeHeaderForTest().

Referenced by basicHeaders(), and TEST_F().

                                                                   {
  vector<compress::Header> headers;
  for (auto& ha : a) {
    headers.push_back(compress::Header::makeHeaderForTest(ha[0], ha[1]));
  }
  return headers;
}

void proxygen::hpack::verifyHeaders	(	vector< HPACKHeader > &	headers,
		vector< HPACKHeader > &	decodedHeaders
	)

Definition at line 39 of file TestUtil.cpp.

References EXPECT_EQ, and proxygen::printDelta().

Referenced by encodeDecode().

                                                        {
  EXPECT_EQ(headers.size(), decodedHeaders.size());
  std::sort(decodedHeaders.begin(), decodedHeaders.end());
  std::sort(headers.begin(), headers.end());
  if (headers.size() != decodedHeaders.size()) {
    std::cerr << printDelta(decodedHeaders, headers);
    CHECK(false) << "Mismatched headers size";
  }
  EXPECT_EQ(headers, decodedHeaders);
  if (headers != decodedHeaders) {
    std::cerr << printDelta(headers, decodedHeaders);
    CHECK(false) << "Mismatched headers";
  }
}