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

Side by Side Diff: net/spdy/spdy_headers_block_parser_test.cc

Issue 2515143002: Removing SPDY3 from the code base. (Closed)
Patch Set: Addressed a failure on windows. Created 4 years 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 unified diff | Download patch
OLDNEW
1 // Copyright 2014 The Chromium Authors. All rights reserved. 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 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "net/spdy/spdy_headers_block_parser.h" 5 #include "net/spdy/spdy_headers_block_parser.h"
6 6
7 #include <memory> 7 #include <memory>
8 #include <string> 8 #include <string>
9 9
10 #include "base/strings/string_number_conversions.h" 10 #include "base/strings/string_number_conversions.h"
(...skipping 24 matching lines...) Expand all
35 }; 35 };
36 36
37 class SpdyHeadersBlockParserTest : 37 class SpdyHeadersBlockParserTest :
38 public ::testing::TestWithParam<SpdyMajorVersion> { 38 public ::testing::TestWithParam<SpdyMajorVersion> {
39 public: 39 public:
40 ~SpdyHeadersBlockParserTest() override {} 40 ~SpdyHeadersBlockParserTest() override {}
41 41
42 protected: 42 protected:
43 void SetUp() override { 43 void SetUp() override {
44 // Create a parser using the mock handler. 44 // Create a parser using the mock handler.
45 spdy_version_ = GetParam(); 45 parser_.reset(new SpdyHeadersBlockParser(HTTP2, &handler_));
46
47 parser_.reset(new SpdyHeadersBlockParser(spdy_version_, &handler_));
48 } 46 }
49 47
50 // Create a header block with a specified number of headers. 48 // Create a header block with a specified number of headers.
51 string CreateHeaders(uint32_t num_headers, bool insert_nulls) { 49 string CreateHeaders(uint32_t num_headers, bool insert_nulls) {
52 string headers; 50 string headers;
53 51
54 // First, write the number of headers in the header block. 52 // First, write the number of headers in the header block.
55 headers += EncodeLength(num_headers); 53 headers += EncodeLength(num_headers);
56 54
57 // Second, write the key-value pairs. 55 // Second, write the key-value pairs.
(...skipping 23 matching lines...) Expand all
81 return headers; 79 return headers;
82 } 80 }
83 81
84 string EncodeLength(uint32_t len) { 82 string EncodeLength(uint32_t len) {
85 char buffer[4]; 83 char buffer[4];
86 uint32_t net_order_len = base::HostToNet32(len); 84 uint32_t net_order_len = base::HostToNet32(len);
87 memcpy(buffer, &net_order_len, sizeof(uint32_t)); 85 memcpy(buffer, &net_order_len, sizeof(uint32_t));
88 return string(buffer, sizeof(uint32_t)); 86 return string(buffer, sizeof(uint32_t));
89 } 87 }
90 88
91 SpdyMajorVersion spdy_version_;
92
93 MockSpdyHeadersHandler handler_; 89 MockSpdyHeadersHandler handler_;
94 std::unique_ptr<SpdyHeadersBlockParser> parser_; 90 std::unique_ptr<SpdyHeadersBlockParser> parser_;
95 91
96 static const char *const kBaseKey; 92 static const char *const kBaseKey;
97 static const char *const kBaseValue; 93 static const char *const kBaseValue;
98 94
99 // Number of headers and header blocks used in the tests. 95 // Number of headers and header blocks used in the tests.
100 static const int kNumHeadersInBlock = 10; 96 static const int kNumHeadersInBlock = 10;
101 static const int kNumHeaderBlocks = 10; 97 static const int kNumHeaderBlocks = 10;
102 }; 98 };
103 99
104 const char *const SpdyHeadersBlockParserTest::kBaseKey = "test_key"; 100 const char *const SpdyHeadersBlockParserTest::kBaseKey = "test_key";
105 const char *const SpdyHeadersBlockParserTest::kBaseValue = "test_value"; 101 const char *const SpdyHeadersBlockParserTest::kBaseValue = "test_value";
106 102
107 // All tests are run with SPDY/3 and HTTP/2. 103 TEST_F(SpdyHeadersBlockParserTest, BasicTest) {
108 INSTANTIATE_TEST_CASE_P(SpdyHeadersBlockParserTests,
109 SpdyHeadersBlockParserTest,
110 ::testing::Values(SPDY3, HTTP2));
111
112 TEST_P(SpdyHeadersBlockParserTest, BasicTest) {
113 // Sanity test, verify that we parse out correctly a block with 104 // Sanity test, verify that we parse out correctly a block with
114 // a single key-value pair and that we notify when we start and finish 105 // a single key-value pair and that we notify when we start and finish
115 // handling a headers block. 106 // handling a headers block.
116 EXPECT_EQ(spdy_version_, parser_->spdy_version());
117 107
118 EXPECT_CALL(handler_, OnHeaderBlockStart()).Times(1); 108 EXPECT_CALL(handler_, OnHeaderBlockStart()).Times(1);
119 string expect_key = kBaseKey + IntToString(0); 109 string expect_key = kBaseKey + IntToString(0);
120 string expect_value = kBaseValue + IntToString(0); 110 string expect_value = kBaseValue + IntToString(0);
121 EXPECT_CALL(handler_, OnHeader(StringPiece(expect_key), 111 EXPECT_CALL(handler_, OnHeader(StringPiece(expect_key),
122 StringPiece(expect_value))).Times(1); 112 StringPiece(expect_value))).Times(1);
123 113
124 string headers(CreateHeaders(1, false)); 114 string headers(CreateHeaders(1, false));
125 if (FLAGS_chromium_http2_flag_log_compressed_size) { 115 if (FLAGS_chromium_http2_flag_log_compressed_size) {
126 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length(), _)).Times(1); 116 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length(), _)).Times(1);
127 } else { 117 } else {
128 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length())).Times(1); 118 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length())).Times(1);
129 } 119 }
130 EXPECT_TRUE(parser_-> 120 EXPECT_TRUE(parser_->
131 HandleControlFrameHeadersData(1, headers.c_str(), headers.length())); 121 HandleControlFrameHeadersData(1, headers.c_str(), headers.length()));
132 EXPECT_EQ(SpdyHeadersBlockParser::NO_PARSER_ERROR, parser_->get_error()); 122 EXPECT_EQ(SpdyHeadersBlockParser::NO_PARSER_ERROR, parser_->get_error());
133 } 123 }
134 124
135 TEST_P(SpdyHeadersBlockParserTest, NullsSupportedTest) { 125 TEST_F(SpdyHeadersBlockParserTest, NullsSupportedTest) {
136 // Sanity test, verify that we parse out correctly a block with 126 // Sanity test, verify that we parse out correctly a block with
137 // a single key-value pair when the key and value contain null charecters. 127 // a single key-value pair when the key and value contain null charecters.
138 EXPECT_CALL(handler_, OnHeaderBlockStart()).Times(1); 128 EXPECT_CALL(handler_, OnHeaderBlockStart()).Times(1);
139 129
140 string expect_key = kBaseKey + string("\0", 1) + IntToString(0); 130 string expect_key = kBaseKey + string("\0", 1) + IntToString(0);
141 string expect_value = kBaseValue + string("\0", 1) + IntToString(0); 131 string expect_value = kBaseValue + string("\0", 1) + IntToString(0);
142 EXPECT_CALL(handler_, OnHeader(StringPiece(expect_key), 132 EXPECT_CALL(handler_, OnHeader(StringPiece(expect_key),
143 StringPiece(expect_value))).Times(1); 133 StringPiece(expect_value))).Times(1);
144 134
145 string headers(CreateHeaders(1, true)); 135 string headers(CreateHeaders(1, true));
146 if (FLAGS_chromium_http2_flag_log_compressed_size) { 136 if (FLAGS_chromium_http2_flag_log_compressed_size) {
147 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length(), _)).Times(1); 137 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length(), _)).Times(1);
148 } else { 138 } else {
149 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length())).Times(1); 139 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length())).Times(1);
150 } 140 }
151 141
152 EXPECT_TRUE(parser_-> 142 EXPECT_TRUE(parser_->
153 HandleControlFrameHeadersData(1, headers.c_str(), headers.length())); 143 HandleControlFrameHeadersData(1, headers.c_str(), headers.length()));
154 EXPECT_EQ(SpdyHeadersBlockParser::NO_PARSER_ERROR, parser_->get_error()); 144 EXPECT_EQ(SpdyHeadersBlockParser::NO_PARSER_ERROR, parser_->get_error());
155 } 145 }
156 146
157 TEST_P(SpdyHeadersBlockParserTest, MultipleBlocksAndHeadersWithPartialData) { 147 TEST_F(SpdyHeadersBlockParserTest, MultipleBlocksAndHeadersWithPartialData) {
158 testing::InSequence s; 148 testing::InSequence s;
159 149
160 // CreateHeaders is deterministic; we can call it once for the whole test. 150 // CreateHeaders is deterministic; we can call it once for the whole test.
161 string headers(CreateHeaders(kNumHeadersInBlock, false)); 151 string headers(CreateHeaders(kNumHeadersInBlock, false));
162 152
163 // The mock doesn't retain storage of arguments, so keep them in scope. 153 // The mock doesn't retain storage of arguments, so keep them in scope.
164 std::vector<string> retained_arguments; 154 std::vector<string> retained_arguments;
165 for (int i = 0; i < kNumHeadersInBlock; i++) { 155 for (int i = 0; i < kNumHeadersInBlock; i++) {
166 retained_arguments.push_back(kBaseKey + IntToString(i)); 156 retained_arguments.push_back(kBaseKey + IntToString(i));
167 retained_arguments.push_back(kBaseValue + IntToString(i)); 157 retained_arguments.push_back(kBaseValue + IntToString(i));
(...skipping 21 matching lines...) Expand all
189 EXPECT_EQ(SpdyHeadersBlockParser::NO_PARSER_ERROR, 179 EXPECT_EQ(SpdyHeadersBlockParser::NO_PARSER_ERROR,
190 parser_->get_error()); 180 parser_->get_error());
191 } else { 181 } else {
192 EXPECT_FALSE(parser_->HandleControlFrameHeadersData(i, &(*it), 1)); 182 EXPECT_FALSE(parser_->HandleControlFrameHeadersData(i, &(*it), 1));
193 EXPECT_EQ(SpdyHeadersBlockParser::NEED_MORE_DATA, parser_->get_error()); 183 EXPECT_EQ(SpdyHeadersBlockParser::NEED_MORE_DATA, parser_->get_error());
194 } 184 }
195 } 185 }
196 } 186 }
197 } 187 }
198 188
199 TEST_P(SpdyHeadersBlockParserTest, HandlesEmptyCallsTest) { 189 TEST_F(SpdyHeadersBlockParserTest, HandlesEmptyCallsTest) {
200 EXPECT_CALL(handler_, OnHeaderBlockStart()).Times(1); 190 EXPECT_CALL(handler_, OnHeaderBlockStart()).Times(1);
201 191
202 string expect_key = kBaseKey + IntToString(0); 192 string expect_key = kBaseKey + IntToString(0);
203 string expect_value = kBaseValue + IntToString(0); 193 string expect_value = kBaseValue + IntToString(0);
204 EXPECT_CALL(handler_, OnHeader(StringPiece(expect_key), 194 EXPECT_CALL(handler_, OnHeader(StringPiece(expect_key),
205 StringPiece(expect_value))).Times(1); 195 StringPiece(expect_value))).Times(1);
206 196
207 string headers(CreateHeaders(1, false)); 197 string headers(CreateHeaders(1, false));
208 if (FLAGS_chromium_http2_flag_log_compressed_size) { 198 if (FLAGS_chromium_http2_flag_log_compressed_size) {
209 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length(), _)).Times(1); 199 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length(), _)).Times(1);
210 } else { 200 } else {
211 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length())).Times(1); 201 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length())).Times(1);
212 } 202 }
213 203
214 // Send a header in pieces with intermediate empty calls. 204 // Send a header in pieces with intermediate empty calls.
215 for (string::iterator it = headers.begin(); it != headers.end(); ++it) { 205 for (string::iterator it = headers.begin(); it != headers.end(); ++it) {
216 if ((it + 1) == headers.end()) { 206 if ((it + 1) == headers.end()) {
217 // Last byte completes the block. 207 // Last byte completes the block.
218 EXPECT_TRUE(parser_->HandleControlFrameHeadersData(1, &(*it), 1)); 208 EXPECT_TRUE(parser_->HandleControlFrameHeadersData(1, &(*it), 1));
219 EXPECT_EQ(SpdyHeadersBlockParser::NO_PARSER_ERROR, parser_->get_error()); 209 EXPECT_EQ(SpdyHeadersBlockParser::NO_PARSER_ERROR, parser_->get_error());
220 } else { 210 } else {
221 EXPECT_FALSE(parser_->HandleControlFrameHeadersData(1, &(*it), 1)); 211 EXPECT_FALSE(parser_->HandleControlFrameHeadersData(1, &(*it), 1));
222 EXPECT_EQ(SpdyHeadersBlockParser::NEED_MORE_DATA, parser_->get_error()); 212 EXPECT_EQ(SpdyHeadersBlockParser::NEED_MORE_DATA, parser_->get_error());
223 EXPECT_FALSE(parser_->HandleControlFrameHeadersData(1, NULL, 0)); 213 EXPECT_FALSE(parser_->HandleControlFrameHeadersData(1, NULL, 0));
224 } 214 }
225 } 215 }
226 } 216 }
227 217
228 TEST_P(SpdyHeadersBlockParserTest, LargeBlocksDiscardedTest) { 218 TEST_F(SpdyHeadersBlockParserTest, LargeBlocksDiscardedTest) {
229 // Header block with too many headers. 219 // Header block with too many headers.
230 { 220 {
231 string headers = EncodeLength(parser_->MaxNumberOfHeaders() + 1); 221 string headers = EncodeLength(parser_->MaxNumberOfHeaders() + 1);
232 EXPECT_FALSE(parser_-> 222 EXPECT_FALSE(parser_->
233 HandleControlFrameHeadersData(1, headers.c_str(), headers.length())); 223 HandleControlFrameHeadersData(1, headers.c_str(), headers.length()));
234 EXPECT_EQ(SpdyHeadersBlockParser::HEADER_BLOCK_TOO_LARGE, 224 EXPECT_EQ(SpdyHeadersBlockParser::HEADER_BLOCK_TOO_LARGE,
235 parser_->get_error()); 225 parser_->get_error());
236 } 226 }
237 parser_.reset(new SpdyHeadersBlockParser(spdy_version_, &handler_)); 227 parser_.reset(new SpdyHeadersBlockParser(HTTP2, &handler_));
238 // Header block with one header, which has a too-long key. 228 // Header block with one header, which has a too-long key.
239 { 229 {
240 string headers = EncodeLength(1) + EncodeLength( 230 string headers = EncodeLength(1) + EncodeLength(
241 SpdyHeadersBlockParser::kMaximumFieldLength + 1); 231 SpdyHeadersBlockParser::kMaximumFieldLength + 1);
242 EXPECT_FALSE(parser_-> 232 EXPECT_FALSE(parser_->
243 HandleControlFrameHeadersData(1, headers.c_str(), headers.length())); 233 HandleControlFrameHeadersData(1, headers.c_str(), headers.length()));
244 EXPECT_EQ(SpdyHeadersBlockParser::HEADER_FIELD_TOO_LARGE, 234 EXPECT_EQ(SpdyHeadersBlockParser::HEADER_FIELD_TOO_LARGE,
245 parser_->get_error()); 235 parser_->get_error());
246 } 236 }
247 } 237 }
248 238
249 TEST_P(SpdyHeadersBlockParserTest, ExtraDataTest) { 239 TEST_F(SpdyHeadersBlockParserTest, ExtraDataTest) {
250 EXPECT_CALL(handler_, OnHeaderBlockStart()).Times(1); 240 EXPECT_CALL(handler_, OnHeaderBlockStart()).Times(1);
251 241
252 string expect_key = kBaseKey + IntToString(0); 242 string expect_key = kBaseKey + IntToString(0);
253 string expect_value = kBaseValue + IntToString(0); 243 string expect_value = kBaseValue + IntToString(0);
254 EXPECT_CALL(handler_, OnHeader(StringPiece(expect_key), 244 EXPECT_CALL(handler_, OnHeader(StringPiece(expect_key),
255 StringPiece(expect_value))).Times(1); 245 StringPiece(expect_value))).Times(1);
256 246
257 string headers = CreateHeaders(1, false) + "foobar"; 247 string headers = CreateHeaders(1, false) + "foobar";
258 if (FLAGS_chromium_http2_flag_log_compressed_size) { 248 if (FLAGS_chromium_http2_flag_log_compressed_size) {
259 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length(), _)).Times(1); 249 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length(), _)).Times(1);
260 } else { 250 } else {
261 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length())).Times(1); 251 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length())).Times(1);
262 } 252 }
263 253
264 EXPECT_FALSE(parser_->HandleControlFrameHeadersData(1, headers.c_str(), 254 EXPECT_FALSE(parser_->HandleControlFrameHeadersData(1, headers.c_str(),
265 headers.length())); 255 headers.length()));
266 EXPECT_EQ(SpdyHeadersBlockParser::TOO_MUCH_DATA, parser_->get_error()); 256 EXPECT_EQ(SpdyHeadersBlockParser::TOO_MUCH_DATA, parser_->get_error());
267 } 257 }
268 258
269 TEST_P(SpdyHeadersBlockParserTest, WrongStreamIdTest) { 259 TEST_F(SpdyHeadersBlockParserTest, WrongStreamIdTest) {
270 string headers(CreateHeaders(kNumHeadersInBlock, false)); 260 string headers(CreateHeaders(kNumHeadersInBlock, false));
271 EXPECT_FALSE(parser_->HandleControlFrameHeadersData(1, headers.data(), 1)); 261 EXPECT_FALSE(parser_->HandleControlFrameHeadersData(1, headers.data(), 1));
272 EXPECT_EQ(SpdyHeadersBlockParser::NEED_MORE_DATA, parser_->get_error()); 262 EXPECT_EQ(SpdyHeadersBlockParser::NEED_MORE_DATA, parser_->get_error());
273 bool result; 263 bool result;
274 EXPECT_SPDY_BUG( 264 EXPECT_SPDY_BUG(
275 result = parser_->HandleControlFrameHeadersData(2, headers.data() + 1, 1), 265 result = parser_->HandleControlFrameHeadersData(2, headers.data() + 1, 1),
276 "Unexpected stream id: 2 \\(expected 1\\)"); 266 "Unexpected stream id: 2 \\(expected 1\\)");
277 EXPECT_FALSE(result); 267 EXPECT_FALSE(result);
278 EXPECT_EQ(SpdyHeadersBlockParser::UNEXPECTED_STREAM_ID, parser_->get_error()); 268 EXPECT_EQ(SpdyHeadersBlockParser::UNEXPECTED_STREAM_ID, parser_->get_error());
279 } 269 }
280 270
281 TEST_P(SpdyHeadersBlockParserTest, InvalidStreamIdTest) { 271 TEST_F(SpdyHeadersBlockParserTest, InvalidStreamIdTest) {
282 string headers(CreateHeaders(kNumHeadersInBlock, false)); 272 string headers(CreateHeaders(kNumHeadersInBlock, false));
283 bool result; 273 bool result;
284 EXPECT_SPDY_BUG( 274 EXPECT_SPDY_BUG(
285 result = parser_->HandleControlFrameHeadersData(0, headers.data(), 1), 275 result = parser_->HandleControlFrameHeadersData(0, headers.data(), 1),
286 "Expected nonzero stream id, saw: 0"); 276 "Expected nonzero stream id, saw: 0");
287 EXPECT_FALSE(result); 277 EXPECT_FALSE(result);
288 EXPECT_EQ(SpdyHeadersBlockParser::UNEXPECTED_STREAM_ID, parser_->get_error()); 278 EXPECT_EQ(SpdyHeadersBlockParser::UNEXPECTED_STREAM_ID, parser_->get_error());
289 } 279 }
290 280
291 } // namespace net 281 } // namespace net
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698