HPACK changes required for specification draft '07

net/spdy/hpack_input_stream_test.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/spdy/hpack_input_stream.h"
 
 #include <bitset>
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "net/spdy/hpack_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 using base::StringPiece;
 using std::string;
 
 const size_t kLiteralBound = 1024;
 
 class HpackInputStreamTest : public ::testing::Test {
+ protected:
   virtual void SetUp() {
     std::vector<HpackHuffmanSymbol> code = HpackHuffmanCode();
     EXPECT_TRUE(huffman_table.Initialize(&code[0], code.size()));
   }
 
- protected:
+  string a2b_hex(const char* hex_data) {
+    std::vector<uint8> output;
+    string result;
+    if (base::HexStringToBytes(hex_data, &output))
+      result.assign(reinterpret_cast<const char*>(&output[0]), output.size());
+    return result;
+  }
+
   HpackHuffmanTable huffman_table;
 };
 
-const char kEncodedFixture[] = "\x33"  // Length prefix.
-  "\xc5\xad\xb7\x7f\x87\x6f\xc7\xfb\xf7\xfd\xbf\xbe\xbf\xf3\xf7\xf4"
-  "\xfb\x7e\xbb\xbe\x9f\x5f\x87\xe3\x7f\xef\xed\xfa\xee\xfa\x7c\x3f"
-  "\x1d\x5d\x1a\x23\xce\x54\x64\x36\xcd\x49\x4b\xd5\xd1\xcc\x5f\x05"
-  "\x35\x96\x9b";
+// Hex representation of encoded length and Huffman string.
+const char kEncodedHuffmanFixture[] = "31"  // Length prefix.
+  "e0d6cf9f6e8f9fd3e5f6fa76fefd3c7e"
+  "df9eff1f2f0f3cfe9f6fcf7f8f879f61"
+  "ad4f4cc9a973a2200ec3725e18b1b74e"
+  "3f";
 
-const char kDecodedFixture[] =
+const char kDecodedHuffmanFixture[] =
   "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1";
 
 // Utility function to decode an assumed-valid uint32 with an N-bit
 // prefix.
 uint32 DecodeValidUint32(uint8 N, StringPiece str) {
   EXPECT_GT(N, 0);
   EXPECT_LE(N, 8);
   HpackInputStream input_stream(kLiteralBound, str);
   input_stream.SetBitOffsetForTest(8 - N);
   uint32 I;
-  EXPECT_TRUE(input_stream.DecodeNextUint32ForTest(&I));
+  EXPECT_TRUE(input_stream.DecodeNextUint32(&I));
   return I;
 }
 
 // Utility function to decode an assumed-invalid uint32 with an N-bit
 // prefix.
 void ExpectDecodeUint32Invalid(uint8 N, StringPiece str) {
   EXPECT_GT(N, 0);
   EXPECT_LE(N, 8);
   HpackInputStream input_stream(kLiteralBound, str);
   input_stream.SetBitOffsetForTest(8 - N);
   uint32 I;
-  EXPECT_FALSE(input_stream.DecodeNextUint32ForTest(&I));
+  EXPECT_FALSE(input_stream.DecodeNextUint32(&I));
 }
 
 uint32 bits32(const string& bitstring) {
   return std::bitset<32>(bitstring).to_ulong();
 }
 
 // The {Number}ByteIntegersEightBitPrefix tests below test that
 // certain integers are decoded correctly with an 8-bit prefix in
 // exactly {Number} bytes.
 
@@ skipping 432 matching lines @@
 TEST_F(HpackInputStreamTest, DecodeNextIdentityStringNotEnoughInput) {
   // Set the length to be one more than it should be.
   HpackInputStream input_stream(kLiteralBound, "\x0fstring literal");
 
   EXPECT_TRUE(input_stream.HasMoreData());
   StringPiece string_piece;
   EXPECT_FALSE(input_stream.DecodeNextIdentityString(&string_piece));
 }
 
 TEST_F(HpackInputStreamTest, DecodeNextHuffmanString) {
-  string output, input(kEncodedFixture, arraysize(kEncodedFixture)-1);
-  HpackInputStream input_stream(arraysize(kDecodedFixture)-1, input);
+  string output, input(a2b_hex(kEncodedHuffmanFixture));
+  HpackInputStream input_stream(arraysize(kDecodedHuffmanFixture)-1, input);
 
   EXPECT_TRUE(input_stream.HasMoreData());
   EXPECT_TRUE(input_stream.DecodeNextHuffmanString(huffman_table, &output));
-  EXPECT_EQ(kDecodedFixture, output);
+  EXPECT_EQ(kDecodedHuffmanFixture, output);
   EXPECT_FALSE(input_stream.HasMoreData());
 }
 
 TEST_F(HpackInputStreamTest, DecodeNextHuffmanStringSizeLimit) {
-  string output, input(kEncodedFixture, arraysize(kEncodedFixture)-1);
+  string output, input(a2b_hex(kEncodedHuffmanFixture));
   // Max string literal is one byte shorter than the decoded fixture.
-  HpackInputStream input_stream(arraysize(kDecodedFixture)-2, input);
+  HpackInputStream input_stream(arraysize(kDecodedHuffmanFixture)-2, input);
 
   // Decoded string overflows the max string literal.
   EXPECT_TRUE(input_stream.HasMoreData());
   EXPECT_FALSE(input_stream.DecodeNextHuffmanString(huffman_table, &output));
 }
 
 TEST_F(HpackInputStreamTest, DecodeNextHuffmanStringNotEnoughInput) {
-  string output, input(kEncodedFixture, arraysize(kEncodedFixture)-1);
+  string output, input(a2b_hex(kEncodedHuffmanFixture));
   input[0]++;  // Input prefix is one byte larger than available input.
-  HpackInputStream input_stream(arraysize(kDecodedFixture)-1, input);
+  HpackInputStream input_stream(arraysize(kDecodedHuffmanFixture)-1, input);
 
   // Not enough buffer for declared encoded length.
   EXPECT_TRUE(input_stream.HasMoreData());
   EXPECT_FALSE(input_stream.DecodeNextHuffmanString(huffman_table, &output));
 }
 
 TEST_F(HpackInputStreamTest, PeekBitsAndConsume) {
   HpackInputStream input_stream(kLiteralBound, "\xad\xab\xad\xab\xad");
 
   uint32 bits = 0;
@@ skipping 67 matching lines @@
 
   input_stream.ConsumeBits(6);
   EXPECT_TRUE(input_stream.HasMoreData());
   input_stream.ConsumeByteRemainder();
   EXPECT_FALSE(input_stream.HasMoreData());
 }
 
 }  // namespace
 
 }  // namespace net