net/spdy/hpack_decoder_test.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/spdy/hpack_decoder.h"
   6
   7 #include <map>
   8 #include <string>
   9
  10 #include "base/basictypes.h"
  11 #include "base/logging.h"
  12 #include "base/strings/string_piece.h"
  13 #include "net/spdy/hpack_encoder.h"
  14 #include "net/spdy/hpack_input_stream.h"
  15 #include "net/spdy/hpack_output_stream.h"
  16 #include "net/spdy/spdy_test_utils.h"
  17 #include "testing/gmock/include/gmock/gmock.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19
  20 namespace net {
  21
  22 namespace test {
  23
  24 using base::StringPiece;
  25 using std::string;
  26
  27 class HpackDecoderPeer {
  28  public:
  29   explicit HpackDecoderPeer(HpackDecoder* decoder)
  30       : decoder_(decoder) {}
  31
  32   void HandleHeaderRepresentation(StringPiece name, StringPiece value) {
  33     decoder_->HandleHeaderRepresentation(name, value);
  34   }
  35   bool DecodeNextName(HpackInputStream* in, StringPiece* out) {
  36     return decoder_->DecodeNextName(in, out);
  37   }
  38   HpackHeaderTable* header_table() {
  39     return &decoder_->header_table_;
  40   }
  41   void set_cookie_value(string value) {
  42     decoder_->cookie_value_ = value;
  43   }
  44   string cookie_value() {
  45     return decoder_->cookie_value_;
  46   }
  47   const std::map<string, string>& decoded_block() const {
  48     return decoder_->decoded_block_;
  49   }
  50   const string& headers_block_buffer() const {
  51     return decoder_->headers_block_buffer_;
  52   }
  53
  54  private:
  55   HpackDecoder* decoder_;
  56 };
  57
  58 }  // namespace test
  59
  60 namespace {
  61
  62 using base::StringPiece;
  63 using std::string;
  64 using test::a2b_hex;
  65
  66 using testing::ElementsAre;
  67 using testing::Pair;
  68
  69 const size_t kLiteralBound = 1024;
  70
  71 class HpackDecoderTest : public ::testing::Test {
  72  protected:
  73   HpackDecoderTest()
  74       : decoder_(ObtainHpackHuffmanTable()),
  75         decoder_peer_(&decoder_) {}
  76
  77   bool DecodeHeaderBlock(StringPiece str) {
  78     return decoder_.HandleControlFrameHeadersData(0, str.data(), str.size()) &&
  79         decoder_.HandleControlFrameHeadersComplete(0);
  80   }
  81
  82   const std::map<string, string>& decoded_block() const {
  83     // TODO(jgraettinger): HpackDecoderTest should implement
  84     // SpdyHeadersHandlerInterface, and collect headers for examination.
  85     return decoder_peer_.decoded_block();
  86   }
  87
  88   const std::map<string, string>& DecodeBlockExpectingSuccess(StringPiece str) {
  89     EXPECT_TRUE(DecodeHeaderBlock(str));
  90     return decoded_block();
  91   }
  92
  93   void expectEntry(size_t index, size_t size, const string& name,
  94                    const string& value) {
  95     HpackEntry* entry = decoder_peer_.header_table()->GetByIndex(index);
  96     EXPECT_EQ(name, entry->name()) << "index " << index;
  97     EXPECT_EQ(value, entry->value());
  98     EXPECT_EQ(size, entry->Size());
  99     EXPECT_EQ(index, decoder_peer_.header_table()->IndexOf(entry));
 100   }
 101
 102   void expectStaticEntry(size_t index) {
 103     HpackEntry* entry = decoder_peer_.header_table()->GetByIndex(index);
 104     EXPECT_TRUE(entry->IsStatic()) << "index " << index;
 105   }
 106
 107   HpackDecoder decoder_;
 108   test::HpackDecoderPeer decoder_peer_;
 109 };
 110
 111 TEST_F(HpackDecoderTest, HandleControlFrameHeadersData) {
 112   // Strings under threshold are concatenated in the buffer.
 113   EXPECT_TRUE(decoder_.HandleControlFrameHeadersData(
 114       0, "small string one", 16));
 115   EXPECT_TRUE(decoder_.HandleControlFrameHeadersData(
 116       0, "small string two", 16));
 117   // A string which would push the buffer over the threshold is refused.
 118   EXPECT_FALSE(decoder_.HandleControlFrameHeadersData(
 119       0, "fails", kMaxDecodeBufferSize - 32 + 1));
 120
 121   EXPECT_EQ(decoder_peer_.headers_block_buffer(),
 122             "small string onesmall string two");
 123 }
 124
 125 TEST_F(HpackDecoderTest, HandleControlFrameHeadersComplete) {
 126   // Decode a block which toggles two static headers into the reference set.
 127   EXPECT_TRUE(DecodeHeaderBlock("\x82\x86"));
 128
 129   decoder_peer_.set_cookie_value("foobar=baz");
 130
 131   // Headers in the reference set should be emitted.
 132   // Incremental cookie buffer should be emitted and cleared.
 133   decoder_.HandleControlFrameHeadersData(0, NULL, 0);
 134   decoder_.HandleControlFrameHeadersComplete(0);
 135
 136   EXPECT_THAT(decoded_block(), ElementsAre(
 137       Pair(":method", "GET"),
 138       Pair(":path", "/index.html"),
 139       Pair("cookie", "foobar=baz")));
 140   EXPECT_EQ(decoder_peer_.cookie_value(), "");
 141 }
 142
 143 TEST_F(HpackDecoderTest, HandleHeaderRepresentation) {
 144   // All cookie crumbs are joined.
 145   decoder_peer_.HandleHeaderRepresentation("cookie", " part 1");
 146   decoder_peer_.HandleHeaderRepresentation("cookie", "part 2 ");
 147   decoder_peer_.HandleHeaderRepresentation("cookie", "part3");
 148
 149   // Already-delimited headers are passed through.
 150   decoder_peer_.HandleHeaderRepresentation("passed-through",
 151                                            string("foo\0baz", 7));
 152
 153   // Other headers are joined on \0. Case matters.
 154   decoder_peer_.HandleHeaderRepresentation("joined", "not joined");
 155   decoder_peer_.HandleHeaderRepresentation("joineD", "value 1");
 156   decoder_peer_.HandleHeaderRepresentation("joineD", "value 2");
 157
 158   // Empty headers remain empty.
 159   decoder_peer_.HandleHeaderRepresentation("empty", "");
 160
 161   // Joined empty headers work as expected.
 162   decoder_peer_.HandleHeaderRepresentation("empty-joined", "");
 163   decoder_peer_.HandleHeaderRepresentation("empty-joined", "foo");
 164   decoder_peer_.HandleHeaderRepresentation("empty-joined", "");
 165   decoder_peer_.HandleHeaderRepresentation("empty-joined", "");
 166
 167   // Non-contiguous cookie crumb.
 168   decoder_peer_.HandleHeaderRepresentation("cookie", " fin!");
 169
 170   // Finish and emit all headers.
 171   decoder_.HandleControlFrameHeadersComplete(0);
 172
 173   EXPECT_THAT(decoded_block(), ElementsAre(
 174       Pair("cookie", " part 1; part 2 ; part3;  fin!"),
 175       Pair("empty", ""),
 176       Pair("empty-joined", string("\0foo\0\0", 6)),
 177       Pair("joineD", string("value 1\0value 2", 15)),
 178       Pair("joined", "not joined"),
 179       Pair("passed-through", string("foo\0baz", 7))));
 180 }
 181
 182 // Decoding an encoded name with a valid string literal should work.
 183 TEST_F(HpackDecoderTest, DecodeNextNameLiteral) {
 184   HpackInputStream input_stream(kLiteralBound, StringPiece("\x00\x04name", 6));
 185
 186   StringPiece string_piece;
 187   EXPECT_TRUE(decoder_peer_.DecodeNextName(&input_stream, &string_piece));
 188   EXPECT_EQ("name", string_piece);
 189   EXPECT_FALSE(input_stream.HasMoreData());
 190 }
 191
 192 TEST_F(HpackDecoderTest, DecodeNextNameLiteralWithHuffmanEncoding) {
 193   string input = a2b_hex("0088571c5cdb737b2faf");
 194   HpackInputStream input_stream(kLiteralBound, input);
 195
 196   StringPiece string_piece;
 197   EXPECT_TRUE(decoder_peer_.DecodeNextName(&input_stream, &string_piece));
 198   EXPECT_EQ("custom-key", string_piece);
 199   EXPECT_FALSE(input_stream.HasMoreData());
 200 }
 201
 202 // Decoding an encoded name with a valid index should work.
 203 TEST_F(HpackDecoderTest, DecodeNextNameIndexed) {
 204   HpackInputStream input_stream(kLiteralBound, "\x01");
 205
 206   StringPiece string_piece;
 207   EXPECT_TRUE(decoder_peer_.DecodeNextName(&input_stream, &string_piece));
 208   EXPECT_EQ(":authority", string_piece);
 209   EXPECT_FALSE(input_stream.HasMoreData());
 210 }
 211
 212 // Decoding an encoded name with an invalid index should fail.
 213 TEST_F(HpackDecoderTest, DecodeNextNameInvalidIndex) {
 214   // One more than the number of static table entries.
 215   HpackInputStream input_stream(kLiteralBound, "\x3e");
 216
 217   StringPiece string_piece;
 218   EXPECT_FALSE(decoder_peer_.DecodeNextName(&input_stream, &string_piece));
 219 }
 220
 221 // Decoding an indexed header should toggle the index's presence in
 222 // the reference set, making a copy of static table entries if
 223 // necessary. It should also emit the header if toggled on (and only
 224 // as many times as it was toggled on).
 225 TEST_F(HpackDecoderTest, IndexedHeaderBasic) {
 226   // Toggle on static table entry #2 (and make a copy at index #1),
 227   // then toggle on static table entry #5 (which is now #6 because of
 228   // the copy of #2).
 229   std::map<string, string> header_set1 =
 230       DecodeBlockExpectingSuccess("\x82\x86");
 231   std::map<string, string> expected_header_set1;
 232   expected_header_set1[":method"] = "GET";
 233   expected_header_set1[":path"] = "/index.html";
 234   EXPECT_EQ(expected_header_set1, header_set1);
 235
 236   std::map<string, string> expected_header_set2;
 237   expected_header_set2[":path"] = "/index.html";
 238   // Toggle off the copy of static table entry #5.
 239   std::map<string, string> header_set2 =
 240       DecodeBlockExpectingSuccess("\x82");
 241   EXPECT_EQ(expected_header_set2, header_set2);
 242 }
 243
 244 // Test a too-large indexed header.
 245 TEST_F(HpackDecoderTest, InvalidIndexedHeader) {
 246   // High-bit set, and a prefix of one more than the number of static entries.
 247   EXPECT_FALSE(DecodeHeaderBlock(StringPiece("\xbe", 1)));
 248 }
 249
 250 TEST_F(HpackDecoderTest, ContextUpdateMaximumSize) {
 251   EXPECT_EQ(kDefaultHeaderTableSizeSetting,
 252             decoder_peer_.header_table()->max_size());
 253   string input;
 254   {
 255     // Maximum-size update with size 126. Succeeds.
 256     HpackOutputStream output_stream;
 257     output_stream.AppendPrefix(kEncodingContextOpcode);
 258     output_stream.AppendPrefix(kEncodingContextNewMaximumSize);
 259     output_stream.AppendUint32(126);
 260
 261     output_stream.TakeString(&input);
 262     EXPECT_TRUE(DecodeHeaderBlock(StringPiece(input)));
 263     EXPECT_EQ(126u, decoder_peer_.header_table()->max_size());
 264   }
 265   {
 266     // Maximum-size update with kDefaultHeaderTableSizeSetting. Succeeds.
 267     HpackOutputStream output_stream;
 268     output_stream.AppendPrefix(kEncodingContextOpcode);
 269     output_stream.AppendPrefix(kEncodingContextNewMaximumSize);
 270     output_stream.AppendUint32(kDefaultHeaderTableSizeSetting);
 271
 272     output_stream.TakeString(&input);
 273     EXPECT_TRUE(DecodeHeaderBlock(StringPiece(input)));
 274     EXPECT_EQ(kDefaultHeaderTableSizeSetting,
 275               decoder_peer_.header_table()->max_size());
 276   }
 277   {
 278     // Maximum-size update with kDefaultHeaderTableSizeSetting + 1. Fails.
 279     HpackOutputStream output_stream;
 280     output_stream.AppendPrefix(kEncodingContextOpcode);
 281     output_stream.AppendPrefix(kEncodingContextNewMaximumSize);
 282     output_stream.AppendUint32(kDefaultHeaderTableSizeSetting + 1);
 283
 284     output_stream.TakeString(&input);
 285     EXPECT_FALSE(DecodeHeaderBlock(StringPiece(input)));
 286     EXPECT_EQ(kDefaultHeaderTableSizeSetting,
 287               decoder_peer_.header_table()->max_size());
 288   }
 289 }
 290
 291 TEST_F(HpackDecoderTest, ContextUpdateClearReferenceSet) {
 292   // Toggle on a couple of headers.
 293   std::map<string, string> header_set1 =
 294       DecodeBlockExpectingSuccess("\x82\x86");
 295   std::map<string, string> expected_header_set1;
 296   expected_header_set1[":method"] = "GET";
 297   expected_header_set1[":path"] = "/index.html";
 298   EXPECT_EQ(expected_header_set1, header_set1);
 299
 300   // Send a context update to clear the reference set.
 301   std::map<string, string> header_set2 =
 302       DecodeBlockExpectingSuccess("\x30");
 303   std::map<string, string> expected_header_set2;
 304   EXPECT_EQ(expected_header_set2, header_set2);
 305 }
 306
 307 // Decoding two valid encoded literal headers with no indexing should
 308 // work.
 309 TEST_F(HpackDecoderTest, LiteralHeaderNoIndexing) {
 310   // First header with indexed name, second header with string literal
 311   // name.
 312   const char input[] = "\x04\x0c/sample/path\x00\x06:path2\x0e/sample/path/2";
 313   std::map<string, string> header_set =
 314       DecodeBlockExpectingSuccess(StringPiece(input, arraysize(input) - 1));
 315
 316   std::map<string, string> expected_header_set;
 317   expected_header_set[":path"] = "/sample/path";
 318   expected_header_set[":path2"] = "/sample/path/2";
 319   EXPECT_EQ(expected_header_set, header_set);
 320 }
 321
 322 // Decoding two valid encoded literal headers with incremental
 323 // indexing and string literal names should work and add the headers
 324 // to the reference set.
 325 TEST_F(HpackDecoderTest, LiteralHeaderIncrementalIndexing) {
 326   const char input[] = "\x44\x0c/sample/path\x40\x06:path2\x0e/sample/path/2";
 327   std::map<string, string> header_set =
 328       DecodeBlockExpectingSuccess(StringPiece(input, arraysize(input) - 1));
 329
 330   std::map<string, string> expected_header_set;
 331   expected_header_set[":path"] = "/sample/path";
 332   expected_header_set[":path2"] = "/sample/path/2";
 333   EXPECT_EQ(expected_header_set, header_set);
 334
 335   // Decoding an empty string should just return the reference set.
 336   std::map<string, string> header_set2 = DecodeBlockExpectingSuccess("");
 337   EXPECT_EQ(expected_header_set, header_set2);
 338 }
 339
 340 TEST_F(HpackDecoderTest, LiteralHeaderWithIndexingInvalidNameIndex) {
 341   decoder_.ApplyHeaderTableSizeSetting(0);
 342
 343   // Name is the last static index. Works.
 344   EXPECT_TRUE(DecodeHeaderBlock(StringPiece("\x7d\x03ooo")));
 345   // Name is one beyond the last static index. Fails.
 346   EXPECT_FALSE(DecodeHeaderBlock(StringPiece("\x7e\x03ooo")));
 347 }
 348
 349 TEST_F(HpackDecoderTest, LiteralHeaderNoIndexingInvalidNameIndex) {
 350   // Name is the last static index. Works.
 351   EXPECT_TRUE(DecodeHeaderBlock(StringPiece("\x0f\x2e\x03ooo")));
 352   // Name is one beyond the last static index. Fails.
 353   EXPECT_FALSE(DecodeHeaderBlock(StringPiece("\x0f\x2f\x03ooo")));
 354 }
 355
 356 TEST_F(HpackDecoderTest, LiteralHeaderNeverIndexedInvalidNameIndex) {
 357   // Name is the last static index. Works.
 358   EXPECT_TRUE(DecodeHeaderBlock(StringPiece("\x1f\x2e\x03ooo")));
 359   // Name is one beyond the last static index. Fails.
 360   EXPECT_FALSE(DecodeHeaderBlock(StringPiece("\x1f\x2f\x03ooo")));
 361 }
 362
 363 // Round-tripping the header set from E.2.1 should work.
 364 TEST_F(HpackDecoderTest, BasicE21) {
 365   HpackEncoder encoder(ObtainHpackHuffmanTable());
 366
 367   std::map<string, string> expected_header_set;
 368   expected_header_set[":method"] = "GET";
 369   expected_header_set[":scheme"] = "http";
 370   expected_header_set[":path"] = "/";
 371   expected_header_set[":authority"] = "www.example.com";
 372
 373   string encoded_header_set;
 374   EXPECT_TRUE(encoder.EncodeHeaderSet(
 375       expected_header_set, &encoded_header_set));
 376
 377   EXPECT_TRUE(DecodeHeaderBlock(encoded_header_set));
 378   EXPECT_EQ(expected_header_set, decoded_block());
 379 }
 380
 381 TEST_F(HpackDecoderTest, SectionD3RequestHuffmanExamples) {
 382   std::map<string, string> header_set;
 383
 384   // 82                                      | == Indexed - Add ==
 385   //                                         |   idx = 2
 386   //                                         | -> :method: GET
 387   // 87                                      | == Indexed - Add ==
 388   //                                         |   idx = 7
 389   //                                         | -> :scheme: http
 390   // 86                                      | == Indexed - Add ==
 391   //                                         |   idx = 6
 392   //                                         | -> :path: /
 393   // 44                                      | == Literal indexed ==
 394   //                                         |   Indexed name (idx = 4)
 395   //                                         |     :authority
 396   // 8c                                      |   Literal value (len = 15)
 397   //                                         |     Huffman encoded:
 398   // e7cf 9beb e89b 6fb1 6fa9 b6ff           | ......o.o...
 399   //                                         |     Decoded:
 400   //                                         | www.example.com
 401   //                                         | -> :authority: www.example.com
 402   string first = a2b_hex("828786448ce7cf9bebe89b6fb16fa9b6ff");
 403   header_set = DecodeBlockExpectingSuccess(first);
 404
 405   EXPECT_THAT(header_set, ElementsAre(
 406       Pair(":authority", "www.example.com"),
 407       Pair(":method", "GET"),
 408       Pair(":path", "/"),
 409       Pair(":scheme", "http")));
 410
 411   expectEntry(1, 57, ":authority", "www.example.com");
 412   expectEntry(2, 38, ":path", "/");
 413   expectEntry(3, 43, ":scheme", "http");
 414   expectEntry(4, 42, ":method", "GET");
 415   expectStaticEntry(5);
 416   EXPECT_EQ(180u, decoder_peer_.header_table()->size());
 417
 418   // 5c                                      | == Literal indexed ==
 419   //                                         |   Indexed name (idx = 28)
 420   //                                         |     cache-control
 421   // 86                                      |   Literal value (len = 8)
 422   //                                         |     Huffman encoded:
 423   // b9b9 9495 56bf                          | ....V.
 424   //                                         |     Decoded:
 425   //                                         | no-cache
 426   //                                         | -> cache-control: no-cache
 427   string second = a2b_hex("5c86b9b9949556bf");
 428   header_set = DecodeBlockExpectingSuccess(second);
 429
 430   EXPECT_THAT(header_set, ElementsAre(
 431       Pair(":authority", "www.example.com"),
 432       Pair(":method", "GET"),
 433       Pair(":path", "/"),
 434       Pair(":scheme", "http"),
 435       Pair("cache-control", "no-cache")));
 436
 437   expectEntry(1, 53, "cache-control", "no-cache");
 438   expectEntry(2, 57, ":authority", "www.example.com");
 439   expectEntry(3, 38, ":path", "/");
 440   expectEntry(4, 43, ":scheme", "http");
 441   expectEntry(5, 42, ":method", "GET");
 442   expectStaticEntry(6);
 443   EXPECT_EQ(233u, decoder_peer_.header_table()->size());
 444
 445   // 30                                      | == Empty reference set ==
 446   //                                         |   idx = 0
 447   //                                         |   flag = 1
 448   // 85                                      | == Indexed - Add ==
 449   //                                         |   idx = 5
 450   //                                         | -> :method: GET
 451   // 8c                                      | == Indexed - Add ==
 452   //                                         |   idx = 12
 453   //                                         | -> :scheme: https
 454   // 8b                                      | == Indexed - Add ==
 455   //                                         |   idx = 11
 456   //                                         | -> :path: /index.html
 457   // 84                                      | == Indexed - Add ==
 458   //                                         |   idx = 4
 459   //                                         | -> :authority: www.example.com
 460   // 40                                      | == Literal indexed ==
 461   // 88                                      |   Literal name (len = 10)
 462   //                                         |     Huffman encoded:
 463   // 571c 5cdb 737b 2faf                     | W.\.s{/.
 464   //                                         |     Decoded:
 465   //                                         | custom-key
 466   // 89                                      |   Literal value (len = 12)
 467   //                                         |     Huffman encoded:
 468   // 571c 5cdb 7372 4d9c 57                  | W.\.srM.W
 469   //                                         |     Decoded:
 470   //                                         | custom-value
 471   //                                         | -> custom-key: custom-value
 472   string third = a2b_hex("30858c8b844088571c5cdb737b2faf89"
 473                          "571c5cdb73724d9c57");
 474   header_set = DecodeBlockExpectingSuccess(third);
 475
 476   EXPECT_THAT(header_set, ElementsAre(
 477       Pair(":authority", "www.example.com"),
 478       Pair(":method", "GET"),
 479       Pair(":path", "/index.html"),
 480       Pair(":scheme", "https"),
 481       Pair("custom-key", "custom-value")));
 482
 483   expectEntry(1, 54, "custom-key", "custom-value");
 484   expectEntry(2, 48, ":path", "/index.html");
 485   expectEntry(3, 44, ":scheme", "https");
 486   expectEntry(4, 53, "cache-control", "no-cache");
 487   expectEntry(5, 57, ":authority", "www.example.com");
 488   expectEntry(6, 38, ":path", "/");
 489   expectEntry(7, 43, ":scheme", "http");
 490   expectEntry(8, 42, ":method", "GET");
 491   expectStaticEntry(9);
 492   EXPECT_EQ(379u, decoder_peer_.header_table()->size());
 493 }
 494
 495 TEST_F(HpackDecoderTest, SectionD5ResponseHuffmanExamples) {
 496   std::map<string, string> header_set;
 497   decoder_.ApplyHeaderTableSizeSetting(256);
 498
 499   // 48                                      | == Literal indexed ==
 500   //                                         |   Indexed name (idx = 8)
 501   //                                         |     :status
 502   // 82                                      |   Literal value (len = 3)
 503   //                                         |     Huffman encoded:
 504   // 4017                                    | @.
 505   //                                         |     Decoded:
 506   //                                         | 302
 507   //                                         | -> :status: 302
 508   // 59                                      | == Literal indexed ==
 509   //                                         |   Indexed name (idx = 25)
 510   //                                         |     cache-control
 511   // 85                                      |   Literal value (len = 7)
 512   //                                         |     Huffman encoded:
 513   // bf06 724b 97                            | ..rK.
 514   //                                         |     Decoded:
 515   //                                         | private
 516   //                                         | -> cache-control: private
 517   // 63                                      | == Literal indexed ==
 518   //                                         |   Indexed name (idx = 35)
 519   //                                         |     date
 520   // 93                                      |   Literal value (len = 29)
 521   //                                         |     Huffman encoded:
 522   // d6db b298 84de 2a71 8805 0620 9851 3109 | ......*q... .Q1.
 523   // b56b a3                                 | .k.
 524   //                                         |     Decoded:
 525   //                                         | Mon, 21 Oct 2013 20:13:21
 526   //                                         | GMT
 527   //                                         | -> date: Mon, 21 Oct 2013
 528   //                                         |   20:13:21 GMT
 529   // 71                                      | == Literal indexed ==
 530   //                                         |   Indexed name (idx = 49)
 531   //                                         |     location
 532   // 91                                      |   Literal value (len = 23)
 533   //                                         |     Huffman encoded:
 534   // adce bf19 8e7e 7cf9 bebe 89b6 fb16 fa9b | ......|.........
 535   // 6f                                      | o
 536   //                                         |     Decoded:
 537   //                                         | https://www.example.com
 538   //                                         | -> location: https://www.e
 539   //                                         |    xample.com
 540   string first = a2b_hex("488240175985bf06724b976393d6dbb2"
 541                          "9884de2a718805062098513109b56ba3"
 542                          "7191adcebf198e7e7cf9bebe89b6fb16"
 543                          "fa9b6f");
 544   header_set = DecodeBlockExpectingSuccess(first);
 545
 546   EXPECT_THAT(header_set, ElementsAre(
 547       Pair(":status", "302"),
 548       Pair("cache-control", "private"),
 549       Pair("date", "Mon, 21 Oct 2013 20:13:21 GMT"),
 550       Pair("location", "https://www.example.com")));
 551
 552   expectEntry(1, 63, "location", "https://www.example.com");
 553   expectEntry(2, 65, "date", "Mon, 21 Oct 2013 20:13:21 GMT");
 554   expectEntry(3, 52, "cache-control", "private");
 555   expectEntry(4, 42, ":status", "302");
 556   expectStaticEntry(5);
 557   EXPECT_EQ(222u, decoder_peer_.header_table()->size());
 558
 559   // 8c                                      | == Indexed - Add ==
 560   //                                         |   idx = 12
 561   //                                         | - evict: :status: 302
 562   //                                         | -> :status: 200
 563   string second = a2b_hex("8c");
 564   header_set = DecodeBlockExpectingSuccess(second);
 565
 566   EXPECT_THAT(header_set, ElementsAre(
 567       Pair(":status", "200"),
 568       Pair("cache-control", "private"),
 569       Pair("date", "Mon, 21 Oct 2013 20:13:21 GMT"),
 570       Pair("location", "https://www.example.com")));
 571
 572   expectEntry(1, 42, ":status", "200");
 573   expectEntry(2, 63, "location", "https://www.example.com");
 574   expectEntry(3, 65, "date", "Mon, 21 Oct 2013 20:13:21 GMT");
 575   expectEntry(4, 52, "cache-control", "private");
 576   expectStaticEntry(5);
 577   EXPECT_EQ(222u, decoder_peer_.header_table()->size());
 578
 579   // 84                                      | == Indexed - Remove ==
 580   //                                         |   idx = 4
 581   //                                         | -> cache-control: private
 582   // 84                                      | == Indexed - Add ==
 583   //                                         |   idx = 4
 584   //                                         | -> cache-control: private
 585   // 43                                      | == Literal indexed ==
 586   //                                         |   Indexed name (idx = 3)
 587   //                                         |     date
 588   // 93                                      |   Literal value (len = 29)
 589   //                                         |     Huffman encoded:
 590   // d6db b298 84de 2a71 8805 0620 9851 3111 | ......*q... .Q1.
 591   // b56b a3                                 | .k.
 592   //                                         |     Decoded:
 593   //                                         | Mon, 21 Oct 2013 20:13:22
 594   //                                         | GMT
 595   //                                         | - evict: cache-control: pr
 596   //                                         |   ivate
 597   //                                         | -> date: Mon, 21 Oct 2013
 598   //                                         |   20:13:22 GMT
 599   // 5e                                      | == Literal indexed ==
 600   //                                         |   Indexed name (idx = 30)
 601   //                                         |     content-encoding
 602   // 84                                      |   Literal value (len = 4)
 603   //                                         |     Huffman encoded:
 604   // abdd 97ff                               | ....
 605   //                                         |     Decoded:
 606   //                                         | gzip
 607   //                                         | - evict: date: Mon, 21 Oct
 608   //                                         |    2013 20:13:21 GMT
 609   //                                         | -> content-encoding: gzip
 610   // 84                                      | == Indexed - Remove ==
 611   //                                         |   idx = 4
 612   //                                         | -> location: https://www.e
 613   //                                         |   xample.com
 614   // 84                                      | == Indexed - Add ==
 615   //                                         |   idx = 4
 616   //                                         | -> location: https://www.e
 617   //                                         |   xample.com
 618   // 83                                      | == Indexed - Remove ==
 619   //                                         |   idx = 3
 620   //                                         | -> :status: 200
 621   // 83                                      | == Indexed - Add ==
 622   //                                         |   idx = 3
 623   //                                         | -> :status: 200
 624   // 7b                                      | == Literal indexed ==
 625   //                                         |   Indexed name (idx = 59)
 626   //                                         |     set-cookie
 627   // b1                                      |   Literal value (len = 56)
 628   //                                         |     Huffman encoded:
 629   // e0d6 cf9f 6e8f 9fd3 e5f6 fa76 fefd 3c7e | ....n......v....
 630   // df9e ff1f 2f0f 3cfe 9f6f cf7f 8f87 9f61 | ..../....o.....a
 631   // ad4f 4cc9 a973 a220 0ec3 725e 18b1 b74e | .OL..s. ..r^...N
 632   // 3f                                      | ?
 633   //                                         |     Decoded:
 634   //                                         | foo=ASDJKHQKBZXOQWEOPIUAXQ
 635   //                                         | WEOIU; max-age=3600; versi
 636   //                                         | on=1
 637   //                                         | - evict: location: https:/
 638   //                                         |   /www.example.com
 639   //                                         | - evict: :status: 200
 640   //                                         | -> set-cookie: foo=ASDJKHQ
 641   //                                         |   KBZXOQWEOPIUAXQWEOIU; ma
 642   //                                         |   x-age=3600; version=1
 643   string third = a2b_hex("84844393d6dbb29884de2a7188050620"
 644                          "98513111b56ba35e84abdd97ff848483"
 645                          "837bb1e0d6cf9f6e8f9fd3e5f6fa76fe"
 646                          "fd3c7edf9eff1f2f0f3cfe9f6fcf7f8f"
 647                          "879f61ad4f4cc9a973a2200ec3725e18"
 648                          "b1b74e3f");
 649   header_set = DecodeBlockExpectingSuccess(third);
 650
 651   EXPECT_THAT(header_set, ElementsAre(
 652       Pair(":status", "200"),
 653       Pair("cache-control", "private"),
 654       Pair("content-encoding", "gzip"),
 655       Pair("date", "Mon, 21 Oct 2013 20:13:22 GMT"),
 656       Pair("location", "https://www.example.com"),
 657       Pair("set-cookie", "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU;"
 658            " max-age=3600; version=1")));
 659
 660   expectEntry(1, 98, "set-cookie", "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU;"
 661               " max-age=3600; version=1");
 662   expectEntry(2, 52, "content-encoding", "gzip");
 663   expectEntry(3, 65, "date", "Mon, 21 Oct 2013 20:13:22 GMT");
 664   expectStaticEntry(4);
 665   EXPECT_EQ(215u, decoder_peer_.header_table()->size());
 666 }
 667
 668 }  // namespace
 669
 670 }  // namespace net