| // 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_decoder.h" |
| |
| #include <map> |
| #include <string> |
| |
| #include "base/basictypes.h" |
| #include "base/logging.h" |
| #include "base/strings/string_piece.h" |
| #include "net/spdy/hpack_encoder.h" |
| #include "net/spdy/hpack_input_stream.h" |
| #include "net/spdy/hpack_output_stream.h" |
| #include "net/spdy/spdy_test_utils.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace net { |
| |
| namespace test { |
| |
| using base::StringPiece; |
| using std::string; |
| |
| class HpackDecoderPeer { |
| public: |
| explicit HpackDecoderPeer(HpackDecoder* decoder) |
| : decoder_(decoder) {} |
| |
| void HandleHeaderRepresentation(StringPiece name, StringPiece value) { |
| decoder_->HandleHeaderRepresentation(name, value); |
| } |
| bool DecodeNextName(HpackInputStream* in, StringPiece* out) { |
| return decoder_->DecodeNextName(in, out); |
| } |
| HpackHeaderTable* header_table() { |
| return &decoder_->header_table_; |
| } |
| void set_cookie_value(string value) { |
| decoder_->cookie_value_ = value; |
| } |
| string cookie_value() { |
| return decoder_->cookie_value_; |
| } |
| const std::map<string, string>& decoded_block() const { |
| return decoder_->decoded_block_; |
| } |
| const string& headers_block_buffer() const { |
| return decoder_->headers_block_buffer_; |
| } |
| |
| private: |
| HpackDecoder* decoder_; |
| }; |
| |
| } // namespace test |
| |
| namespace { |
| |
| using base::StringPiece; |
| using std::string; |
| using test::a2b_hex; |
| |
| using testing::ElementsAre; |
| using testing::Pair; |
| |
| const size_t kLiteralBound = 1024; |
| |
| class HpackDecoderTest : public ::testing::Test { |
| protected: |
| HpackDecoderTest() |
| : decoder_(ObtainHpackHuffmanTable()), |
| decoder_peer_(&decoder_) {} |
| |
| bool DecodeHeaderBlock(StringPiece str) { |
| return decoder_.HandleControlFrameHeadersData(0, str.data(), str.size()) && |
| decoder_.HandleControlFrameHeadersComplete(0); |
| } |
| |
| const std::map<string, string>& decoded_block() const { |
| // TODO(jgraettinger): HpackDecoderTest should implement |
| // SpdyHeadersHandlerInterface, and collect headers for examination. |
| return decoder_peer_.decoded_block(); |
| } |
| |
| const std::map<string, string>& DecodeBlockExpectingSuccess(StringPiece str) { |
| EXPECT_TRUE(DecodeHeaderBlock(str)); |
| return decoded_block(); |
| } |
| |
| void expectEntry(size_t index, size_t size, const string& name, |
| const string& value) { |
| HpackEntry* entry = decoder_peer_.header_table()->GetByIndex(index); |
| EXPECT_EQ(name, entry->name()) << "index " << index; |
| EXPECT_EQ(value, entry->value()); |
| EXPECT_EQ(size, entry->Size()); |
| EXPECT_EQ(index, decoder_peer_.header_table()->IndexOf(entry)); |
| } |
| |
| void expectStaticEntry(size_t index) { |
| HpackEntry* entry = decoder_peer_.header_table()->GetByIndex(index); |
| EXPECT_TRUE(entry->IsStatic()) << "index " << index; |
| } |
| |
| HpackDecoder decoder_; |
| test::HpackDecoderPeer decoder_peer_; |
| }; |
| |
| TEST_F(HpackDecoderTest, HandleControlFrameHeadersData) { |
| // Strings under threshold are concatenated in the buffer. |
| EXPECT_TRUE(decoder_.HandleControlFrameHeadersData( |
| 0, "small string one", 16)); |
| EXPECT_TRUE(decoder_.HandleControlFrameHeadersData( |
| 0, "small string two", 16)); |
| // A string which would push the buffer over the threshold is refused. |
| EXPECT_FALSE(decoder_.HandleControlFrameHeadersData( |
| 0, "fails", kMaxDecodeBufferSize - 32 + 1)); |
| |
| EXPECT_EQ(decoder_peer_.headers_block_buffer(), |
| "small string onesmall string two"); |
| } |
| |
| TEST_F(HpackDecoderTest, HandleControlFrameHeadersComplete) { |
| // Decode a block which toggles two static headers into the reference set. |
| EXPECT_TRUE(DecodeHeaderBlock("\x82\x86")); |
| |
| decoder_peer_.set_cookie_value("foobar=baz"); |
| |
| // Headers in the reference set should be emitted. |
| // Incremental cookie buffer should be emitted and cleared. |
| decoder_.HandleControlFrameHeadersData(0, NULL, 0); |
| decoder_.HandleControlFrameHeadersComplete(0); |
| |
| EXPECT_THAT(decoded_block(), ElementsAre( |
| Pair(":method", "GET"), |
| Pair(":path", "/index.html"), |
| Pair("cookie", "foobar=baz"))); |
| EXPECT_EQ(decoder_peer_.cookie_value(), ""); |
| } |
| |
| TEST_F(HpackDecoderTest, HandleHeaderRepresentation) { |
| // All cookie crumbs are joined. |
| decoder_peer_.HandleHeaderRepresentation("cookie", " part 1"); |
| decoder_peer_.HandleHeaderRepresentation("cookie", "part 2 "); |
| decoder_peer_.HandleHeaderRepresentation("cookie", "part3"); |
| |
| // Already-delimited headers are passed through. |
| decoder_peer_.HandleHeaderRepresentation("passed-through", |
| string("foo\0baz", 7)); |
| |
| // Other headers are joined on \0. Case matters. |
| decoder_peer_.HandleHeaderRepresentation("joined", "not joined"); |
| decoder_peer_.HandleHeaderRepresentation("joineD", "value 1"); |
| decoder_peer_.HandleHeaderRepresentation("joineD", "value 2"); |
| |
| // Empty headers remain empty. |
| decoder_peer_.HandleHeaderRepresentation("empty", ""); |
| |
| // Joined empty headers work as expected. |
| decoder_peer_.HandleHeaderRepresentation("empty-joined", ""); |
| decoder_peer_.HandleHeaderRepresentation("empty-joined", "foo"); |
| decoder_peer_.HandleHeaderRepresentation("empty-joined", ""); |
| decoder_peer_.HandleHeaderRepresentation("empty-joined", ""); |
| |
| // Non-contiguous cookie crumb. |
| decoder_peer_.HandleHeaderRepresentation("cookie", " fin!"); |
| |
| // Finish and emit all headers. |
| decoder_.HandleControlFrameHeadersComplete(0); |
| |
| EXPECT_THAT(decoded_block(), ElementsAre( |
| Pair("cookie", " part 1; part 2 ; part3; fin!"), |
| Pair("empty", ""), |
| Pair("empty-joined", string("\0foo\0\0", 6)), |
| Pair("joineD", string("value 1\0value 2", 15)), |
| Pair("joined", "not joined"), |
| Pair("passed-through", string("foo\0baz", 7)))); |
| } |
| |
| // Decoding an encoded name with a valid string literal should work. |
| TEST_F(HpackDecoderTest, DecodeNextNameLiteral) { |
| HpackInputStream input_stream(kLiteralBound, StringPiece("\x00\x04name", 6)); |
| |
| StringPiece string_piece; |
| EXPECT_TRUE(decoder_peer_.DecodeNextName(&input_stream, &string_piece)); |
| EXPECT_EQ("name", string_piece); |
| EXPECT_FALSE(input_stream.HasMoreData()); |
| } |
| |
| TEST_F(HpackDecoderTest, DecodeNextNameLiteralWithHuffmanEncoding) { |
| string input = a2b_hex("0088571c5cdb737b2faf"); |
| HpackInputStream input_stream(kLiteralBound, input); |
| |
| StringPiece string_piece; |
| EXPECT_TRUE(decoder_peer_.DecodeNextName(&input_stream, &string_piece)); |
| EXPECT_EQ("custom-key", string_piece); |
| EXPECT_FALSE(input_stream.HasMoreData()); |
| } |
| |
| // Decoding an encoded name with a valid index should work. |
| TEST_F(HpackDecoderTest, DecodeNextNameIndexed) { |
| HpackInputStream input_stream(kLiteralBound, "\x01"); |
| |
| StringPiece string_piece; |
| EXPECT_TRUE(decoder_peer_.DecodeNextName(&input_stream, &string_piece)); |
| EXPECT_EQ(":authority", string_piece); |
| EXPECT_FALSE(input_stream.HasMoreData()); |
| } |
| |
| // Decoding an encoded name with an invalid index should fail. |
| TEST_F(HpackDecoderTest, DecodeNextNameInvalidIndex) { |
| // One more than the number of static table entries. |
| HpackInputStream input_stream(kLiteralBound, "\x3e"); |
| |
| StringPiece string_piece; |
| EXPECT_FALSE(decoder_peer_.DecodeNextName(&input_stream, &string_piece)); |
| } |
| |
| // Decoding an indexed header should toggle the index's presence in |
| // the reference set, making a copy of static table entries if |
| // necessary. It should also emit the header if toggled on (and only |
| // as many times as it was toggled on). |
| TEST_F(HpackDecoderTest, IndexedHeaderBasic) { |
| // Toggle on static table entry #2 (and make a copy at index #1), |
| // then toggle on static table entry #5 (which is now #6 because of |
| // the copy of #2). |
| std::map<string, string> header_set1 = |
| DecodeBlockExpectingSuccess("\x82\x86"); |
| std::map<string, string> expected_header_set1; |
| expected_header_set1[":method"] = "GET"; |
| expected_header_set1[":path"] = "/index.html"; |
| EXPECT_EQ(expected_header_set1, header_set1); |
| |
| std::map<string, string> expected_header_set2; |
| expected_header_set2[":path"] = "/index.html"; |
| // Toggle off the copy of static table entry #5. |
| std::map<string, string> header_set2 = |
| DecodeBlockExpectingSuccess("\x82"); |
| EXPECT_EQ(expected_header_set2, header_set2); |
| } |
| |
| // Test a too-large indexed header. |
| TEST_F(HpackDecoderTest, InvalidIndexedHeader) { |
| // High-bit set, and a prefix of one more than the number of static entries. |
| EXPECT_FALSE(DecodeHeaderBlock(StringPiece("\xbe", 1))); |
| } |
| |
| TEST_F(HpackDecoderTest, ContextUpdateMaximumSize) { |
| EXPECT_EQ(kDefaultHeaderTableSizeSetting, |
| decoder_peer_.header_table()->max_size()); |
| string input; |
| { |
| // Maximum-size update with size 126. Succeeds. |
| HpackOutputStream output_stream; |
| output_stream.AppendPrefix(kEncodingContextOpcode); |
| output_stream.AppendPrefix(kEncodingContextNewMaximumSize); |
| output_stream.AppendUint32(126); |
| |
| output_stream.TakeString(&input); |
| EXPECT_TRUE(DecodeHeaderBlock(StringPiece(input))); |
| EXPECT_EQ(126u, decoder_peer_.header_table()->max_size()); |
| } |
| { |
| // Maximum-size update with kDefaultHeaderTableSizeSetting. Succeeds. |
| HpackOutputStream output_stream; |
| output_stream.AppendPrefix(kEncodingContextOpcode); |
| output_stream.AppendPrefix(kEncodingContextNewMaximumSize); |
| output_stream.AppendUint32(kDefaultHeaderTableSizeSetting); |
| |
| output_stream.TakeString(&input); |
| EXPECT_TRUE(DecodeHeaderBlock(StringPiece(input))); |
| EXPECT_EQ(kDefaultHeaderTableSizeSetting, |
| decoder_peer_.header_table()->max_size()); |
| } |
| { |
| // Maximum-size update with kDefaultHeaderTableSizeSetting + 1. Fails. |
| HpackOutputStream output_stream; |
| output_stream.AppendPrefix(kEncodingContextOpcode); |
| output_stream.AppendPrefix(kEncodingContextNewMaximumSize); |
| output_stream.AppendUint32(kDefaultHeaderTableSizeSetting + 1); |
| |
| output_stream.TakeString(&input); |
| EXPECT_FALSE(DecodeHeaderBlock(StringPiece(input))); |
| EXPECT_EQ(kDefaultHeaderTableSizeSetting, |
| decoder_peer_.header_table()->max_size()); |
| } |
| } |
| |
| TEST_F(HpackDecoderTest, ContextUpdateClearReferenceSet) { |
| // Toggle on a couple of headers. |
| std::map<string, string> header_set1 = |
| DecodeBlockExpectingSuccess("\x82\x86"); |
| std::map<string, string> expected_header_set1; |
| expected_header_set1[":method"] = "GET"; |
| expected_header_set1[":path"] = "/index.html"; |
| EXPECT_EQ(expected_header_set1, header_set1); |
| |
| // Send a context update to clear the reference set. |
| std::map<string, string> header_set2 = |
| DecodeBlockExpectingSuccess("\x30"); |
| std::map<string, string> expected_header_set2; |
| EXPECT_EQ(expected_header_set2, header_set2); |
| } |
| |
| // Decoding two valid encoded literal headers with no indexing should |
| // work. |
| TEST_F(HpackDecoderTest, LiteralHeaderNoIndexing) { |
| // First header with indexed name, second header with string literal |
| // name. |
| const char input[] = "\x04\x0c/sample/path\x00\x06:path2\x0e/sample/path/2"; |
| std::map<string, string> header_set = |
| DecodeBlockExpectingSuccess(StringPiece(input, arraysize(input) - 1)); |
| |
| std::map<string, string> expected_header_set; |
| expected_header_set[":path"] = "/sample/path"; |
| expected_header_set[":path2"] = "/sample/path/2"; |
| EXPECT_EQ(expected_header_set, header_set); |
| } |
| |
| // Decoding two valid encoded literal headers with incremental |
| // indexing and string literal names should work and add the headers |
| // to the reference set. |
| TEST_F(HpackDecoderTest, LiteralHeaderIncrementalIndexing) { |
| const char input[] = "\x44\x0c/sample/path\x40\x06:path2\x0e/sample/path/2"; |
| std::map<string, string> header_set = |
| DecodeBlockExpectingSuccess(StringPiece(input, arraysize(input) - 1)); |
| |
| std::map<string, string> expected_header_set; |
| expected_header_set[":path"] = "/sample/path"; |
| expected_header_set[":path2"] = "/sample/path/2"; |
| EXPECT_EQ(expected_header_set, header_set); |
| |
| // Decoding an empty string should just return the reference set. |
| std::map<string, string> header_set2 = DecodeBlockExpectingSuccess(""); |
| EXPECT_EQ(expected_header_set, header_set2); |
| } |
| |
| TEST_F(HpackDecoderTest, LiteralHeaderWithIndexingInvalidNameIndex) { |
| decoder_.ApplyHeaderTableSizeSetting(0); |
| |
| // Name is the last static index. Works. |
| EXPECT_TRUE(DecodeHeaderBlock(StringPiece("\x7d\x03ooo"))); |
| // Name is one beyond the last static index. Fails. |
| EXPECT_FALSE(DecodeHeaderBlock(StringPiece("\x7e\x03ooo"))); |
| } |
| |
| TEST_F(HpackDecoderTest, LiteralHeaderNoIndexingInvalidNameIndex) { |
| // Name is the last static index. Works. |
| EXPECT_TRUE(DecodeHeaderBlock(StringPiece("\x0f\x2e\x03ooo"))); |
| // Name is one beyond the last static index. Fails. |
| EXPECT_FALSE(DecodeHeaderBlock(StringPiece("\x0f\x2f\x03ooo"))); |
| } |
| |
| TEST_F(HpackDecoderTest, LiteralHeaderNeverIndexedInvalidNameIndex) { |
| // Name is the last static index. Works. |
| EXPECT_TRUE(DecodeHeaderBlock(StringPiece("\x1f\x2e\x03ooo"))); |
| // Name is one beyond the last static index. Fails. |
| EXPECT_FALSE(DecodeHeaderBlock(StringPiece("\x1f\x2f\x03ooo"))); |
| } |
| |
| // Round-tripping the header set from E.2.1 should work. |
| TEST_F(HpackDecoderTest, BasicE21) { |
| HpackEncoder encoder(ObtainHpackHuffmanTable()); |
| |
| std::map<string, string> expected_header_set; |
| expected_header_set[":method"] = "GET"; |
| expected_header_set[":scheme"] = "http"; |
| expected_header_set[":path"] = "/"; |
| expected_header_set[":authority"] = "www.example.com"; |
| |
| string encoded_header_set; |
| EXPECT_TRUE(encoder.EncodeHeaderSet( |
| expected_header_set, &encoded_header_set)); |
| |
| EXPECT_TRUE(DecodeHeaderBlock(encoded_header_set)); |
| EXPECT_EQ(expected_header_set, decoded_block()); |
| } |
| |
| TEST_F(HpackDecoderTest, SectionD3RequestHuffmanExamples) { |
| std::map<string, string> header_set; |
| |
| // 82 | == Indexed - Add == |
| // | idx = 2 |
| // | -> :method: GET |
| // 87 | == Indexed - Add == |
| // | idx = 7 |
| // | -> :scheme: http |
| // 86 | == Indexed - Add == |
| // | idx = 6 |
| // | -> :path: / |
| // 44 | == Literal indexed == |
| // | Indexed name (idx = 4) |
| // | :authority |
| // 8c | Literal value (len = 15) |
| // | Huffman encoded: |
| // e7cf 9beb e89b 6fb1 6fa9 b6ff | ......o.o... |
| // | Decoded: |
| // | www.example.com |
| // | -> :authority: www.example.com |
| string first = a2b_hex("828786448ce7cf9bebe89b6fb16fa9b6ff"); |
| header_set = DecodeBlockExpectingSuccess(first); |
| |
| EXPECT_THAT(header_set, ElementsAre( |
| Pair(":authority", "www.example.com"), |
| Pair(":method", "GET"), |
| Pair(":path", "/"), |
| Pair(":scheme", "http"))); |
| |
| expectEntry(1, 57, ":authority", "www.example.com"); |
| expectEntry(2, 38, ":path", "/"); |
| expectEntry(3, 43, ":scheme", "http"); |
| expectEntry(4, 42, ":method", "GET"); |
| expectStaticEntry(5); |
| EXPECT_EQ(180u, decoder_peer_.header_table()->size()); |
| |
| // 5c | == Literal indexed == |
| // | Indexed name (idx = 28) |
| // | cache-control |
| // 86 | Literal value (len = 8) |
| // | Huffman encoded: |
| // b9b9 9495 56bf | ....V. |
| // | Decoded: |
| // | no-cache |
| // | -> cache-control: no-cache |
| string second = a2b_hex("5c86b9b9949556bf"); |
| header_set = DecodeBlockExpectingSuccess(second); |
| |
| EXPECT_THAT(header_set, ElementsAre( |
| Pair(":authority", "www.example.com"), |
| Pair(":method", "GET"), |
| Pair(":path", "/"), |
| Pair(":scheme", "http"), |
| Pair("cache-control", "no-cache"))); |
| |
| expectEntry(1, 53, "cache-control", "no-cache"); |
| expectEntry(2, 57, ":authority", "www.example.com"); |
| expectEntry(3, 38, ":path", "/"); |
| expectEntry(4, 43, ":scheme", "http"); |
| expectEntry(5, 42, ":method", "GET"); |
| expectStaticEntry(6); |
| EXPECT_EQ(233u, decoder_peer_.header_table()->size()); |
| |
| // 30 | == Empty reference set == |
| // | idx = 0 |
| // | flag = 1 |
| // 85 | == Indexed - Add == |
| // | idx = 5 |
| // | -> :method: GET |
| // 8c | == Indexed - Add == |
| // | idx = 12 |
| // | -> :scheme: https |
| // 8b | == Indexed - Add == |
| // | idx = 11 |
| // | -> :path: /index.html |
| // 84 | == Indexed - Add == |
| // | idx = 4 |
| // | -> :authority: www.example.com |
| // 40 | == Literal indexed == |
| // 88 | Literal name (len = 10) |
| // | Huffman encoded: |
| // 571c 5cdb 737b 2faf | W.\.s{/. |
| // | Decoded: |
| // | custom-key |
| // 89 | Literal value (len = 12) |
| // | Huffman encoded: |
| // 571c 5cdb 7372 4d9c 57 | W.\.srM.W |
| // | Decoded: |
| // | custom-value |
| // | -> custom-key: custom-value |
| string third = a2b_hex("30858c8b844088571c5cdb737b2faf89" |
| "571c5cdb73724d9c57"); |
| header_set = DecodeBlockExpectingSuccess(third); |
| |
| EXPECT_THAT(header_set, ElementsAre( |
| Pair(":authority", "www.example.com"), |
| Pair(":method", "GET"), |
| Pair(":path", "/index.html"), |
| Pair(":scheme", "https"), |
| Pair("custom-key", "custom-value"))); |
| |
| expectEntry(1, 54, "custom-key", "custom-value"); |
| expectEntry(2, 48, ":path", "/index.html"); |
| expectEntry(3, 44, ":scheme", "https"); |
| expectEntry(4, 53, "cache-control", "no-cache"); |
| expectEntry(5, 57, ":authority", "www.example.com"); |
| expectEntry(6, 38, ":path", "/"); |
| expectEntry(7, 43, ":scheme", "http"); |
| expectEntry(8, 42, ":method", "GET"); |
| expectStaticEntry(9); |
| EXPECT_EQ(379u, decoder_peer_.header_table()->size()); |
| } |
| |
| TEST_F(HpackDecoderTest, SectionD5ResponseHuffmanExamples) { |
| std::map<string, string> header_set; |
| decoder_.ApplyHeaderTableSizeSetting(256); |
| |
| // 48 | == Literal indexed == |
| // | Indexed name (idx = 8) |
| // | :status |
| // 82 | Literal value (len = 3) |
| // | Huffman encoded: |
| // 4017 | @. |
| // | Decoded: |
| // | 302 |
| // | -> :status: 302 |
| // 59 | == Literal indexed == |
| // | Indexed name (idx = 25) |
| // | cache-control |
| // 85 | Literal value (len = 7) |
| // | Huffman encoded: |
| // bf06 724b 97 | ..rK. |
| // | Decoded: |
| // | private |
| // | -> cache-control: private |
| // 63 | == Literal indexed == |
| // | Indexed name (idx = 35) |
| // | date |
| // 93 | Literal value (len = 29) |
| // | Huffman encoded: |
| // d6db b298 84de 2a71 8805 0620 9851 3109 | ......*q... .Q1. |
| // b56b a3 | .k. |
| // | Decoded: |
| // | Mon, 21 Oct 2013 20:13:21 |
| // | GMT |
| // | -> date: Mon, 21 Oct 2013 |
| // | 20:13:21 GMT |
| // 71 | == Literal indexed == |
| // | Indexed name (idx = 49) |
| // | location |
| // 91 | Literal value (len = 23) |
| // | Huffman encoded: |
| // adce bf19 8e7e 7cf9 bebe 89b6 fb16 fa9b | ......|......... |
| // 6f | o |
| // | Decoded: |
| // | https://www.example.com |
| // | -> location: https://www.e |
| // | xample.com |
| string first = a2b_hex("488240175985bf06724b976393d6dbb2" |
| "9884de2a718805062098513109b56ba3" |
| "7191adcebf198e7e7cf9bebe89b6fb16" |
| "fa9b6f"); |
| header_set = DecodeBlockExpectingSuccess(first); |
| |
| EXPECT_THAT(header_set, ElementsAre( |
| Pair(":status", "302"), |
| Pair("cache-control", "private"), |
| Pair("date", "Mon, 21 Oct 2013 20:13:21 GMT"), |
| Pair("location", "https://www.example.com"))); |
| |
| expectEntry(1, 63, "location", "https://www.example.com"); |
| expectEntry(2, 65, "date", "Mon, 21 Oct 2013 20:13:21 GMT"); |
| expectEntry(3, 52, "cache-control", "private"); |
| expectEntry(4, 42, ":status", "302"); |
| expectStaticEntry(5); |
| EXPECT_EQ(222u, decoder_peer_.header_table()->size()); |
| |
| // 8c | == Indexed - Add == |
| // | idx = 12 |
| // | - evict: :status: 302 |
| // | -> :status: 200 |
| string second = a2b_hex("8c"); |
| header_set = DecodeBlockExpectingSuccess(second); |
| |
| EXPECT_THAT(header_set, ElementsAre( |
| Pair(":status", "200"), |
| Pair("cache-control", "private"), |
| Pair("date", "Mon, 21 Oct 2013 20:13:21 GMT"), |
| Pair("location", "https://www.example.com"))); |
| |
| expectEntry(1, 42, ":status", "200"); |
| expectEntry(2, 63, "location", "https://www.example.com"); |
| expectEntry(3, 65, "date", "Mon, 21 Oct 2013 20:13:21 GMT"); |
| expectEntry(4, 52, "cache-control", "private"); |
| expectStaticEntry(5); |
| EXPECT_EQ(222u, decoder_peer_.header_table()->size()); |
| |
| // 84 | == Indexed - Remove == |
| // | idx = 4 |
| // | -> cache-control: private |
| // 84 | == Indexed - Add == |
| // | idx = 4 |
| // | -> cache-control: private |
| // 43 | == Literal indexed == |
| // | Indexed name (idx = 3) |
| // | date |
| // 93 | Literal value (len = 29) |
| // | Huffman encoded: |
| // d6db b298 84de 2a71 8805 0620 9851 3111 | ......*q... .Q1. |
| // b56b a3 | .k. |
| // | Decoded: |
| // | Mon, 21 Oct 2013 20:13:22 |
| // | GMT |
| // | - evict: cache-control: pr |
| // | ivate |
| // | -> date: Mon, 21 Oct 2013 |
| // | 20:13:22 GMT |
| // 5e | == Literal indexed == |
| // | Indexed name (idx = 30) |
| // | content-encoding |
| // 84 | Literal value (len = 4) |
| // | Huffman encoded: |
| // abdd 97ff | .... |
| // | Decoded: |
| // | gzip |
| // | - evict: date: Mon, 21 Oct |
| // | 2013 20:13:21 GMT |
| // | -> content-encoding: gzip |
| // 84 | == Indexed - Remove == |
| // | idx = 4 |
| // | -> location: https://www.e |
| // | xample.com |
| // 84 | == Indexed - Add == |
| // | idx = 4 |
| // | -> location: https://www.e |
| // | xample.com |
| // 83 | == Indexed - Remove == |
| // | idx = 3 |
| // | -> :status: 200 |
| // 83 | == Indexed - Add == |
| // | idx = 3 |
| // | -> :status: 200 |
| // 7b | == Literal indexed == |
| // | Indexed name (idx = 59) |
| // | set-cookie |
| // b1 | Literal value (len = 56) |
| // | Huffman encoded: |
| // e0d6 cf9f 6e8f 9fd3 e5f6 fa76 fefd 3c7e | ....n......v.... |
| // df9e ff1f 2f0f 3cfe 9f6f cf7f 8f87 9f61 | ..../....o.....a |
| // ad4f 4cc9 a973 a220 0ec3 725e 18b1 b74e | .OL..s. ..r^...N |
| // 3f | ? |
| // | Decoded: |
| // | foo=ASDJKHQKBZXOQWEOPIUAXQ |
| // | WEOIU; max-age=3600; versi |
| // | on=1 |
| // | - evict: location: https:/ |
| // | /www.example.com |
| // | - evict: :status: 200 |
| // | -> set-cookie: foo=ASDJKHQ |
| // | KBZXOQWEOPIUAXQWEOIU; ma |
| // | x-age=3600; version=1 |
| string third = a2b_hex("84844393d6dbb29884de2a7188050620" |
| "98513111b56ba35e84abdd97ff848483" |
| "837bb1e0d6cf9f6e8f9fd3e5f6fa76fe" |
| "fd3c7edf9eff1f2f0f3cfe9f6fcf7f8f" |
| "879f61ad4f4cc9a973a2200ec3725e18" |
| "b1b74e3f"); |
| header_set = DecodeBlockExpectingSuccess(third); |
| |
| EXPECT_THAT(header_set, ElementsAre( |
| Pair(":status", "200"), |
| Pair("cache-control", "private"), |
| Pair("content-encoding", "gzip"), |
| Pair("date", "Mon, 21 Oct 2013 20:13:22 GMT"), |
| Pair("location", "https://www.example.com"), |
| Pair("set-cookie", "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU;" |
| " max-age=3600; version=1"))); |
| |
| expectEntry(1, 98, "set-cookie", "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU;" |
| " max-age=3600; version=1"); |
| expectEntry(2, 52, "content-encoding", "gzip"); |
| expectEntry(3, 65, "date", "Mon, 21 Oct 2013 20:13:22 GMT"); |
| expectStaticEntry(4); |
| EXPECT_EQ(215u, decoder_peer_.header_table()->size()); |
| } |
| |
| } // namespace |
| |
| } // namespace net |
