Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(764)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/spdy/hpack_huffman_table_test.cc

Issue 266243004: Clang format slam. Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 6 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« net/base/mime_util_unittest.cc ('K') | « net/spdy/hpack_huffman_table.cc ('k') | net/spdy/hpack_input_stream.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/spdy/hpack_huffman_table_test.cc
diff --git a/net/spdy/hpack_huffman_table_test.cc b/net/spdy/hpack_huffman_table_test.cc
index b64c3743ddb3fcbd904a5187270bb2dc6d1bffb7..461c8c8d0aef1954b01defc6b65d79e9e5422257 100644
--- a/net/spdy/hpack_huffman_table_test.cc
+++ b/net/spdy/hpack_huffman_table_test.cc
@@ -30,11 +30,9 @@ typedef HpackHuffmanTable::DecodeTable DecodeTable;
class HpackHuffmanTablePeer {
public:
explicit HpackHuffmanTablePeer(const HpackHuffmanTable& table)
- : table_(table) { }
+ : table_(table) {}
- const std::vector<uint32>& code_by_id() const {
- return table_.code_by_id_;
- }
+ const std::vector<uint32>& code_by_id() const { return table_.code_by_id_; }
const std::vector<uint8>& length_by_id() const {
return table_.length_by_id_;
}
@@ -45,9 +43,7 @@ class HpackHuffmanTablePeer {
// Cast to match signed-ness of bits8().
return static_cast<char>(table_.pad_bits_);
}
- uint16 failed_symbol_id() const {
- return table_.failed_symbol_id_;
- }
+ uint16 failed_symbol_id() const { return table_.failed_symbol_id_; }
std::vector<DecodeEntry> decode_entries(const DecodeTable& decode_table) {
std::vector<DecodeEntry>::const_iterator begin =
table_.decode_entries_.begin() + decode_table.entries_offset;
@@ -55,22 +51,21 @@ class HpackHuffmanTablePeer {
}
void DumpDecodeTable(const DecodeTable& table) {
std::vector<DecodeEntry> entries = decode_entries(table);
- LOG(INFO) << "Table size " << (1 << table.indexed_length)
- << " prefix " << unsigned(table.prefix_length)
- << " indexed " << unsigned(table.indexed_length);
+ LOG(INFO) << "Table size " << (1 << table.indexed_length) << " prefix "
+ << unsigned(table.prefix_length) << " indexed "
+ << unsigned(table.indexed_length);
size_t i = 0;
while (i != table.size()) {
const DecodeEntry& entry = entries[i];
LOG(INFO) << i << ":"
<< " next_table " << unsigned(entry.next_table_index)
- << " length " << unsigned(entry.length)
- << " symbol " << unsigned(entry.symbol_id);
+ << " length " << unsigned(entry.length) << " symbol "
+ << unsigned(entry.symbol_id);
size_t j = 1;
for (; (i + j) != table.size(); j++) {
const DecodeEntry& next = entries[i + j];
if (next.next_table_index != entry.next_table_index ||
- next.length != entry.length ||
- next.symbol_id != entry.symbol_id)
+ next.length != entry.length || next.symbol_id != entry.symbol_id)
break;
}
if (j > 1) {
@@ -88,9 +83,7 @@ namespace {
class HpackHuffmanTableTest : public ::testing::Test {
protected:
- HpackHuffmanTableTest()
- : table_(),
- peer_(table_) {}
+ HpackHuffmanTableTest() : table_(), peer_(table_) {}
string EncodeString(StringPiece input) {
string result;
@@ -111,8 +104,7 @@ MATCHER(DecodeEntryEq, "") {
const DecodeEntry& lhs = std::tr1::get<0>(arg);
const DecodeEntry& rhs = std::tr1::get<1>(arg);
return lhs.next_table_index == rhs.next_table_index &&
- lhs.length == rhs.length &&
- lhs.symbol_id == rhs.symbol_id;
+ lhs.length == rhs.length && lhs.symbol_id == rhs.symbol_id;
}
uint32 bits32(const string& bitstring) {
@@ -133,28 +125,28 @@ TEST_F(HpackHuffmanTableTest, InitializeEdgeCases) {
{
// Verify eight symbols can be encoded with 3 bits per symbol.
HpackHuffmanSymbol code[] = {
- {bits32("00000000000000000000000000000000"), 3, 0},
- {bits32("00100000000000000000000000000000"), 3, 1},
- {bits32("01000000000000000000000000000000"), 3, 2},
- {bits32("01100000000000000000000000000000"), 3, 3},
- {bits32("10000000000000000000000000000000"), 3, 4},
- {bits32("10100000000000000000000000000000"), 3, 5},
- {bits32("11000000000000000000000000000000"), 3, 6},
- {bits32("11100000000000000000000000000000"), 8, 7}};
+ {bits32("00000000000000000000000000000000"), 3, 0},
+ {bits32("00100000000000000000000000000000"), 3, 1},
+ {bits32("01000000000000000000000000000000"), 3, 2},
+ {bits32("01100000000000000000000000000000"), 3, 3},
+ {bits32("10000000000000000000000000000000"), 3, 4},
+ {bits32("10100000000000000000000000000000"), 3, 5},
+ {bits32("11000000000000000000000000000000"), 3, 6},
+ {bits32("11100000000000000000000000000000"), 8, 7}};
HpackHuffmanTable table;
EXPECT_TRUE(table.Initialize(code, arraysize(code)));
}
{
// But using 2 bits with one symbol overflows the code.
HpackHuffmanSymbol code[] = {
- {bits32("01000000000000000000000000000000"), 3, 0},
- {bits32("01100000000000000000000000000000"), 3, 1},
- {bits32("00000000000000000000000000000000"), 2, 2},
- {bits32("10000000000000000000000000000000"), 3, 3},
- {bits32("10100000000000000000000000000000"), 3, 4},
- {bits32("11000000000000000000000000000000"), 3, 5},
- {bits32("11100000000000000000000000000000"), 3, 6},
- {bits32("00000000000000000000000000000000"), 8, 7}}; // Overflow.
+ {bits32("01000000000000000000000000000000"), 3, 0},
+ {bits32("01100000000000000000000000000000"), 3, 1},
+ {bits32("00000000000000000000000000000000"), 2, 2},
+ {bits32("10000000000000000000000000000000"), 3, 3},
+ {bits32("10100000000000000000000000000000"), 3, 4},
+ {bits32("11000000000000000000000000000000"), 3, 5},
+ {bits32("11100000000000000000000000000000"), 3, 6},
+ {bits32("00000000000000000000000000000000"), 8, 7}}; // Overflow.
HpackHuffmanTable table;
EXPECT_FALSE(table.Initialize(code, arraysize(code)));
EXPECT_EQ(7, HpackHuffmanTablePeer(table).failed_symbol_id());
@@ -162,20 +154,20 @@ TEST_F(HpackHuffmanTableTest, InitializeEdgeCases) {
{
// Verify four symbols can be encoded with incremental bits per symbol.
HpackHuffmanSymbol code[] = {
- {bits32("00000000000000000000000000000000"), 1, 0},
- {bits32("10000000000000000000000000000000"), 2, 1},
- {bits32("11000000000000000000000000000000"), 3, 2},
- {bits32("11100000000000000000000000000000"), 8, 3}};
+ {bits32("00000000000000000000000000000000"), 1, 0},
+ {bits32("10000000000000000000000000000000"), 2, 1},
+ {bits32("11000000000000000000000000000000"), 3, 2},
+ {bits32("11100000000000000000000000000000"), 8, 3}};
HpackHuffmanTable table;
EXPECT_TRUE(table.Initialize(code, arraysize(code)));
}
{
// But repeating a length overflows the code.
HpackHuffmanSymbol code[] = {
- {bits32("00000000000000000000000000000000"), 1, 0},
- {bits32("10000000000000000000000000000000"), 2, 1},
- {bits32("11000000000000000000000000000000"), 2, 2},
- {bits32("00000000000000000000000000000000"), 8, 3}}; // Overflow.
+ {bits32("00000000000000000000000000000000"), 1, 0},
+ {bits32("10000000000000000000000000000000"), 2, 1},
+ {bits32("11000000000000000000000000000000"), 2, 2},
+ {bits32("00000000000000000000000000000000"), 8, 3}}; // Overflow.
HpackHuffmanTable table;
EXPECT_FALSE(table.Initialize(code, arraysize(code)));
EXPECT_EQ(3, HpackHuffmanTablePeer(table).failed_symbol_id());
@@ -183,10 +175,10 @@ TEST_F(HpackHuffmanTableTest, InitializeEdgeCases) {
{
// Symbol IDs must be assigned sequentially with no gaps.
HpackHuffmanSymbol code[] = {
- {bits32("00000000000000000000000000000000"), 1, 0},
- {bits32("10000000000000000000000000000000"), 2, 1},
- {bits32("11000000000000000000000000000000"), 3, 1}, // Repeat.
- {bits32("11100000000000000000000000000000"), 8, 3}};
+ {bits32("00000000000000000000000000000000"), 1, 0},
+ {bits32("10000000000000000000000000000000"), 2, 1},
+ {bits32("11000000000000000000000000000000"), 3, 1}, // Repeat.
+ {bits32("11100000000000000000000000000000"), 8, 3}};
HpackHuffmanTable table;
EXPECT_FALSE(table.Initialize(code, arraysize(code)));
EXPECT_EQ(2, HpackHuffmanTablePeer(table).failed_symbol_id());
@@ -194,10 +186,10 @@ TEST_F(HpackHuffmanTableTest, InitializeEdgeCases) {
{
// Canonical codes must begin with zero.
HpackHuffmanSymbol code[] = {
- {bits32("10000000000000000000000000000000"), 4, 0},
- {bits32("10010000000000000000000000000000"), 4, 1},
- {bits32("10100000000000000000000000000000"), 4, 2},
- {bits32("10110000000000000000000000000000"), 8, 3}};
+ {bits32("10000000000000000000000000000000"), 4, 0},
+ {bits32("10010000000000000000000000000000"), 4, 1},
+ {bits32("10100000000000000000000000000000"), 4, 2},
+ {bits32("10110000000000000000000000000000"), 8, 3}};
HpackHuffmanTable table;
EXPECT_FALSE(table.Initialize(code, arraysize(code)));
EXPECT_EQ(0, HpackHuffmanTablePeer(table).failed_symbol_id());
@@ -205,10 +197,10 @@ TEST_F(HpackHuffmanTableTest, InitializeEdgeCases) {
{
// Codes must match the expected canonical sequence.
HpackHuffmanSymbol code[] = {
- {bits32("00000000000000000000000000000000"), 2, 0},
- {bits32("01000000000000000000000000000000"), 2, 1},
- {bits32("11000000000000000000000000000000"), 2, 2}, // Not canonical.
- {bits32("10000000000000000000000000000000"), 8, 3}};
+ {bits32("00000000000000000000000000000000"), 2, 0},
+ {bits32("01000000000000000000000000000000"), 2, 1},
+ {bits32("11000000000000000000000000000000"), 2, 2}, // Not canonical.
+ {bits32("10000000000000000000000000000000"), 8, 3}};
HpackHuffmanTable table;
EXPECT_FALSE(table.Initialize(code, arraysize(code)));
EXPECT_EQ(2, HpackHuffmanTablePeer(table).failed_symbol_id());
@@ -216,10 +208,10 @@ TEST_F(HpackHuffmanTableTest, InitializeEdgeCases) {
{
// At least one code must have a length of 8 bits (to ensure pad-ability).
HpackHuffmanSymbol code[] = {
- {bits32("00000000000000000000000000000000"), 1, 0},
- {bits32("10000000000000000000000000000000"), 2, 1},
- {bits32("11000000000000000000000000000000"), 3, 2},
- {bits32("11100000000000000000000000000000"), 7, 3}};
+ {bits32("00000000000000000000000000000000"), 1, 0},
+ {bits32("10000000000000000000000000000000"), 2, 1},
+ {bits32("11000000000000000000000000000000"), 3, 2},
+ {bits32("11100000000000000000000000000000"), 7, 3}};
HpackHuffmanTable table;
EXPECT_FALSE(table.Initialize(code, arraysize(code)));
}
@@ -227,27 +219,26 @@ TEST_F(HpackHuffmanTableTest, InitializeEdgeCases) {
TEST_F(HpackHuffmanTableTest, ValidateInternalsWithSmallCode) {
HpackHuffmanSymbol code[] = {
- {bits32("01100000000000000000000000000000"), 4, 0}, // 3rd.
- {bits32("01110000000000000000000000000000"), 4, 1}, // 4th.
- {bits32("00000000000000000000000000000000"), 2, 2}, // 1st assigned code.
- {bits32("01000000000000000000000000000000"), 3, 3}, // 2nd.
- {bits32("10000000000000000000000000000000"), 5, 4}, // 5th.
- {bits32("10001000000000000000000000000000"), 5, 5}, // 6th.
- {bits32("10011000000000000000000000000000"), 8, 6}, // 8th.
- {bits32("10010000000000000000000000000000"), 5, 7}}; // 7th.
+ {bits32("01100000000000000000000000000000"), 4, 0}, // 3rd.
+ {bits32("01110000000000000000000000000000"), 4, 1}, // 4th.
+ {bits32("00000000000000000000000000000000"), 2, 2}, // 1st assigned code.
+ {bits32("01000000000000000000000000000000"), 3, 3}, // 2nd.
+ {bits32("10000000000000000000000000000000"), 5, 4}, // 5th.
+ {bits32("10001000000000000000000000000000"), 5, 5}, // 6th.
+ {bits32("10011000000000000000000000000000"), 8, 6}, // 8th.
+ {bits32("10010000000000000000000000000000"), 5, 7}}; // 7th.
EXPECT_TRUE(table_.Initialize(code, arraysize(code)));
- EXPECT_THAT(peer_.code_by_id(), ElementsAre(
- bits32("01100000000000000000000000000000"),
- bits32("01110000000000000000000000000000"),
- bits32("00000000000000000000000000000000"),
- bits32("01000000000000000000000000000000"),
- bits32("10000000000000000000000000000000"),
- bits32("10001000000000000000000000000000"),
- bits32("10011000000000000000000000000000"),
- bits32("10010000000000000000000000000000")));
- EXPECT_THAT(peer_.length_by_id(), ElementsAre(
- 4, 4, 2, 3, 5, 5, 8, 5));
+ EXPECT_THAT(peer_.code_by_id(),
+ ElementsAre(bits32("01100000000000000000000000000000"),
+ bits32("01110000000000000000000000000000"),
+ bits32("00000000000000000000000000000000"),
+ bits32("01000000000000000000000000000000"),
+ bits32("10000000000000000000000000000000"),
+ bits32("10001000000000000000000000000000"),
+ bits32("10011000000000000000000000000000"),
+ bits32("10010000000000000000000000000000")));
+ EXPECT_THAT(peer_.length_by_id(), ElementsAre(4, 4, 2, 3, 5, 5, 8, 5));
EXPECT_EQ(1u, peer_.decode_tables().size());
{
@@ -260,7 +251,7 @@ TEST_F(HpackHuffmanTableTest, ValidateInternalsWithSmallCode) {
expected.resize(288, DecodeEntry(0, 5, 5)); // Fills 16.
expected.resize(304, DecodeEntry(0, 5, 7)); // Fills 16.
expected.resize(306, DecodeEntry(0, 8, 6)); // Fills 2.
- expected.resize(512, DecodeEntry()); // Remainder is empty.
+ expected.resize(512, DecodeEntry()); // Remainder is empty.
EXPECT_THAT(peer_.decode_entries(peer_.decode_tables()[0]),
Pointwise(DecodeEntryEq(), expected));
@@ -270,10 +261,8 @@ TEST_F(HpackHuffmanTableTest, ValidateInternalsWithSmallCode) {
char input_storage[] = {2, 3, 2, 7, 4};
StringPiece input(input_storage, arraysize(input_storage));
// By symbol: (2) 00 (3) 010 (2) 00 (7) 10010 (4) 10000 (6 as pad) 1001100.
- char expect_storage[] = {
- bits8("00010001"),
- bits8("00101000"),
- bits8("01001100")};
+ char expect_storage[] = {bits8("00010001"), bits8("00101000"),
+ bits8("01001100")};
StringPiece expect(expect_storage, arraysize(expect_storage));
string buffer_in = EncodeString(input);
@@ -281,27 +270,27 @@ TEST_F(HpackHuffmanTableTest, ValidateInternalsWithSmallCode) {
string buffer_out;
HpackInputStream input_stream(kuint32max, buffer_in);
- EXPECT_TRUE(table_.DecodeString(&input_stream, input.size(), &buffer_out));
+ EXPECT_TRUE(table_.DecodeString(&input_stream, input.size(), &buffer_out));
EXPECT_EQ(buffer_out, input);
}
TEST_F(HpackHuffmanTableTest, ValidateMultiLevelDecodeTables) {
HpackHuffmanSymbol code[] = {
- {bits32("00000000000000000000000000000000"), 6, 0},
- {bits32("00000100000000000000000000000000"), 6, 1},
- {bits32("00001000000000000000000000000000"), 11, 2},
- {bits32("00001000001000000000000000000000"), 11, 3},
- {bits32("00001000010000000000000000000000"), 12, 4},
+ {bits32("00000000000000000000000000000000"), 6, 0},
+ {bits32("00000100000000000000000000000000"), 6, 1},
+ {bits32("00001000000000000000000000000000"), 11, 2},
+ {bits32("00001000001000000000000000000000"), 11, 3},
+ {bits32("00001000010000000000000000000000"), 12, 4},
};
EXPECT_TRUE(table_.Initialize(code, arraysize(code)));
EXPECT_EQ(2u, peer_.decode_tables().size());
{
std::vector<DecodeEntry> expected;
- expected.resize(8, DecodeEntry(0, 6, 0)); // Fills 8.
- expected.resize(16, DecodeEntry(0, 6, 1)); // Fills 8.
+ expected.resize(8, DecodeEntry(0, 6, 0)); // Fills 8.
+ expected.resize(16, DecodeEntry(0, 6, 1)); // Fills 8.
expected.resize(17, DecodeEntry(1, 12, 0)); // Pointer. Fills 1.
- expected.resize(512, DecodeEntry()); // Remainder is empty.
+ expected.resize(512, DecodeEntry()); // Remainder is empty.
const DecodeTable& decode_table = peer_.decode_tables()[0];
EXPECT_EQ(decode_table.prefix_length, 0);
@@ -314,7 +303,7 @@ TEST_F(HpackHuffmanTableTest, ValidateMultiLevelDecodeTables) {
expected.resize(2, DecodeEntry(1, 11, 2)); // Fills 2.
expected.resize(4, DecodeEntry(1, 11, 3)); // Fills 2.
expected.resize(5, DecodeEntry(1, 12, 4)); // Fills 1.
- expected.resize(8, DecodeEntry()); // Remainder is empty.
+ expected.resize(8, DecodeEntry()); // Remainder is empty.
const DecodeTable& decode_table = peer_.decode_tables()[1];
EXPECT_EQ(decode_table.prefix_length, 9);
@@ -327,15 +316,15 @@ TEST_F(HpackHuffmanTableTest, ValidateMultiLevelDecodeTables) {
TEST_F(HpackHuffmanTableTest, DecodeWithBadInput) {
HpackHuffmanSymbol code[] = {
- {bits32("01100000000000000000000000000000"), 4, 0},
- {bits32("01110000000000000000000000000000"), 4, 1},
- {bits32("00000000000000000000000000000000"), 2, 2},
- {bits32("01000000000000000000000000000000"), 3, 3},
- {bits32("10000000000000000000000000000000"), 5, 4},
- {bits32("10001000000000000000000000000000"), 5, 5},
- {bits32("10011000000000000000000000000000"), 6, 6},
- {bits32("10010000000000000000000000000000"), 5, 7},
- {bits32("10011100000000000000000000000000"), 16, 8}};
+ {bits32("01100000000000000000000000000000"), 4, 0},
+ {bits32("01110000000000000000000000000000"), 4, 1},
+ {bits32("00000000000000000000000000000000"), 2, 2},
+ {bits32("01000000000000000000000000000000"), 3, 3},
+ {bits32("10000000000000000000000000000000"), 5, 4},
+ {bits32("10001000000000000000000000000000"), 5, 5},
+ {bits32("10011000000000000000000000000000"), 6, 6},
+ {bits32("10010000000000000000000000000000"), 5, 7},
+ {bits32("10011100000000000000000000000000"), 16, 8}};
EXPECT_TRUE(table_.Initialize(code, arraysize(code)));
string buffer;
@@ -389,23 +378,19 @@ TEST_F(HpackHuffmanTableTest, SpecRequestExamples) {
string buffer;
string test_table[] = {
- "\xdb\x6d\x88\x3e\x68\xd1\xcb\x12\x25\xba\x7f",
- "www.example.com",
- "\x63\x65\x4a\x13\x98\xff",
- "no-cache",
- "\x4e\xb0\x8b\x74\x97\x90\xfa\x7f",
- "custom-key",
- "\x4e\xb0\x8b\x74\x97\x9a\x17\xa8\xff",
- "custom-value",
+ "\xdb\x6d\x88\x3e\x68\xd1\xcb\x12\x25\xba\x7f", "www.example.com",
+ "\x63\x65\x4a\x13\x98\xff", "no-cache",
+ "\x4e\xb0\x8b\x74\x97\x90\xfa\x7f", "custom-key",
+ "\x4e\xb0\x8b\x74\x97\x9a\x17\xa8\xff", "custom-value",
};
// Round-trip each test example.
for (size_t i = 0; i != arraysize(test_table); i += 2) {
const string& encodedFixture(test_table[i]);
- const string& decodedFixture(test_table[i+1]);
+ const string& decodedFixture(test_table[i + 1]);
HpackInputStream input_stream(kuint32max, encodedFixture);
- EXPECT_TRUE(table_.DecodeString(&input_stream, decodedFixture.size(),
- &buffer));
+ EXPECT_TRUE(
+ table_.DecodeString(&input_stream, decodedFixture.size(), &buffer));
EXPECT_EQ(decodedFixture, buffer);
buffer = EncodeString(decodedFixture);
EXPECT_EQ(encodedFixture, buffer);
@@ -418,29 +403,26 @@ TEST_F(HpackHuffmanTableTest, SpecResponseExamples) {
string buffer;
string test_table[] = {
- "\x98\xa7",
- "302",
- "\x73\xd5\xcd\x11\x1f",
- "private",
- "\xef\x6b\x3a\x7a\x0e\x6e\x8f\xa2\x63\xd0\x72\x9a\x6e\x83\x97\xd8"
- "\x69\xbd\x87\x37\x47\xbb\xbf\xc7",
- "Mon, 21 Oct 2013 20:13:21 GMT",
- "\xce\x31\x74\x3d\x80\x1b\x6d\xb1\x07\xcd\x1a\x39\x62\x44\xb7\x4f",
- "https://www.example.com",
- "\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",
- "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1",
+ "\x98\xa7", "302", "\x73\xd5\xcd\x11\x1f", "private",
+ "\xef\x6b\x3a\x7a\x0e\x6e\x8f\xa2\x63\xd0\x72\x9a\x6e\x83\x97\xd8"
+ "\x69\xbd\x87\x37\x47\xbb\xbf\xc7",
+ "Mon, 21 Oct 2013 20:13:21 GMT",
+ "\xce\x31\x74\x3d\x80\x1b\x6d\xb1\x07\xcd\x1a\x39\x62\x44\xb7\x4f",
+ "https://www.example.com",
+ "\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",
+ "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1",
};
// Round-trip each test example.
for (size_t i = 0; i != arraysize(test_table); i += 2) {
const string& encodedFixture(test_table[i]);
- const string& decodedFixture(test_table[i+1]);
+ const string& decodedFixture(test_table[i + 1]);
HpackInputStream input_stream(kuint32max, encodedFixture);
- EXPECT_TRUE(table_.DecodeString(&input_stream, decodedFixture.size(),
- &buffer));
+ EXPECT_TRUE(
+ table_.DecodeString(&input_stream, decodedFixture.size(), &buffer));
EXPECT_EQ(decodedFixture, buffer);
buffer = EncodeString(decodedFixture);
EXPECT_EQ(encodedFixture, buffer);
@@ -469,7 +451,6 @@ TEST_F(HpackHuffmanTableTest, RoundTripSymbolSequence) {
std::vector<HpackHuffmanSymbol> code = HpackHuffmanCode();
EXPECT_TRUE(table_.Initialize(&code[0], code.size()));
-
char storage[512];
for (size_t i = 0; i != 256; i++) {
storage[i] = static_cast<char>(i);
@@ -490,17 +471,17 @@ TEST_F(HpackHuffmanTableTest, EncodedSizeAgreesWithEncodeString) {
EXPECT_TRUE(table_.Initialize(&code[0], code.size()));
string test_table[] = {
- "",
- "Mon, 21 Oct 2013 20:13:21 GMT",
- "https://www.example.com",
- "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1",
- string(1, '\0'),
- string("foo\0bar", 7),
- string(256, '\0'),
+ "",
+ "Mon, 21 Oct 2013 20:13:21 GMT",
+ "https://www.example.com",
+ "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1",
+ string(1, '\0'),
+ string("foo\0bar", 7),
+ string(256, '\0'),
};
for (size_t i = 0; i != 256; ++i) {
// Expand last |test_table| entry to cover all codes.
- test_table[arraysize(test_table)-1][i] = static_cast<char>(i);
+ test_table[arraysize(test_table) - 1][i] = static_cast<char>(i);
}
HpackOutputStream output_stream;
« net/base/mime_util_unittest.cc ('K') | « net/spdy/hpack_huffman_table.cc ('k') | net/spdy/hpack_input_stream.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698