Add CompareSpdyHeaderBlocks() test helper method.

net/spdy/hpack/hpack_decoder_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/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/hpack_encoder.h"
 #include "net/spdy/hpack/hpack_input_stream.h"
 #include "net/spdy/hpack/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 SpdyHeaderBlock& 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;
@@ skipping 139 matching lines @@
   EXPECT_FALSE(decoder_peer_.DecodeNextName(&input_stream, &string_piece));
 }
 
 // Decoding indexed static table field should work.
 TEST_F(HpackDecoderTest, IndexedHeaderStatic) {
   // Reference static table entries #2 and #5.
   SpdyHeaderBlock header_set1 = DecodeBlockExpectingSuccess("\x82\x85");
   SpdyHeaderBlock expected_header_set1;
   expected_header_set1[":method"] = "GET";
   expected_header_set1[":path"] = "/index.html";
-  EXPECT_EQ(expected_header_set1, header_set1);
+  EXPECT_TRUE(CompareSpdyHeaderBlocks(expected_header_set1, header_set1));
 
   // Reference static table entry #2.
   SpdyHeaderBlock header_set2 = DecodeBlockExpectingSuccess("\x82");
   SpdyHeaderBlock expected_header_set2;
   expected_header_set2[":method"] = "GET";
-  EXPECT_EQ(expected_header_set2, header_set2);
+  EXPECT_TRUE(CompareSpdyHeaderBlocks(expected_header_set2, header_set2));
 }
 
 TEST_F(HpackDecoderTest, IndexedHeaderDynamic) {
   // First header block: add an entry to header table.
   SpdyHeaderBlock header_set1 = DecodeBlockExpectingSuccess(
       "\x40\x03"
       "foo"
       "\x03"
       "bar");
   SpdyHeaderBlock expected_header_set1;
   expected_header_set1["foo"] = "bar";
-  EXPECT_EQ(expected_header_set1, header_set1);
+  EXPECT_TRUE(CompareSpdyHeaderBlocks(expected_header_set1, header_set1));
 
   // Second header block: add another entry to header table.
   SpdyHeaderBlock header_set2 = DecodeBlockExpectingSuccess(
       "\xbe\x40\x04"
       "spam"
       "\x04"
       "eggs");
   SpdyHeaderBlock expected_header_set2;
   expected_header_set2["foo"] = "bar";
   expected_header_set2["spam"] = "eggs";
-  EXPECT_EQ(expected_header_set2, header_set2);
+  EXPECT_TRUE(CompareSpdyHeaderBlocks(expected_header_set2, header_set2));
 
   // Third header block: refer to most recently added entry.
   SpdyHeaderBlock header_set3 = DecodeBlockExpectingSuccess("\xbe");
   SpdyHeaderBlock expected_header_set3;
   expected_header_set3["spam"] = "eggs";
-  EXPECT_EQ(expected_header_set3, header_set3);
+  EXPECT_TRUE(CompareSpdyHeaderBlocks(expected_header_set3, header_set3));
 }
 
 // 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 that a header block with a pseudo-header field following a regular one
 // is treated as malformed.  (HTTP2 draft-14 8.1.2.1., HPACK draft-09 3.1.)
@@ skipping 55 matching lines @@
 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";
   SpdyHeaderBlock header_set =
       DecodeBlockExpectingSuccess(StringPiece(input, arraysize(input) - 1));
 
   SpdyHeaderBlock expected_header_set;
   expected_header_set[":path"] = "/sample/path";
   expected_header_set[":path2"] = "/sample/path/2";
-  EXPECT_EQ(expected_header_set, header_set);
+  EXPECT_TRUE(CompareSpdyHeaderBlocks(expected_header_set, header_set));
 }
 
 // Decoding two valid encoded literal headers with incremental
 // indexing and string literal names should work.
 TEST_F(HpackDecoderTest, LiteralHeaderIncrementalIndexing) {
   const char input[] = "\x44\x0c/sample/path\x40\x06:path2\x0e/sample/path/2";
   SpdyHeaderBlock header_set =
       DecodeBlockExpectingSuccess(StringPiece(input, arraysize(input) - 1));
 
   SpdyHeaderBlock expected_header_set;
   expected_header_set[":path"] = "/sample/path";
   expected_header_set[":path2"] = "/sample/path/2";
-  EXPECT_EQ(expected_header_set, header_set);
+  EXPECT_TRUE(CompareSpdyHeaderBlocks(expected_header_set, header_set));
 }
 
 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")));
 }
@@ skipping 20 matching lines @@
   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());
+  EXPECT_TRUE(CompareSpdyHeaderBlocks(expected_header_set, decoded_block()));
 }
 
 TEST_F(HpackDecoderTest, SectionD4RequestHuffmanExamples) {
   SpdyHeaderBlock header_set;
 
   // 82                                      | == Indexed - Add ==
   //                                         |   idx = 2
   //                                         | -> :method: GET
   // 86                                      | == Indexed - Add ==
   //                                         |   idx = 6
@@ skipping 273 matching lines @@
 
   expectEntry(62, 98, "set-cookie",
               "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU;"
               " max-age=3600; version=1");
   expectEntry(63, 52, "content-encoding", "gzip");
   expectEntry(64, 65, "date", "Mon, 21 Oct 2013 20:13:22 GMT");
   EXPECT_EQ(215u, decoder_peer_.header_table()->size());
 }
 
 }  // namespace
-
+}  // namespace test
 }  // namespace net