OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 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/http/http_server_properties_impl.h" | 5 #include "net/http/http_server_properties_impl.h" |
6 | 6 |
7 #include <string> | 7 #include <string> |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
10 #include "base/basictypes.h" | 10 #include "base/basictypes.h" |
(...skipping 225 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
236 ASSERT_EQ(spdy_server_g, string_value_g); | 236 ASSERT_EQ(spdy_server_g, string_value_g); |
237 ASSERT_TRUE(spdy_server_list.GetString(1, &string_value_m)); | 237 ASSERT_TRUE(spdy_server_list.GetString(1, &string_value_m)); |
238 ASSERT_EQ(spdy_server_m, string_value_m); | 238 ASSERT_EQ(spdy_server_m, string_value_m); |
239 } | 239 } |
240 | 240 |
241 typedef HttpServerPropertiesImplTest AlternateProtocolServerPropertiesTest; | 241 typedef HttpServerPropertiesImplTest AlternateProtocolServerPropertiesTest; |
242 | 242 |
243 TEST_F(AlternateProtocolServerPropertiesTest, Basic) { | 243 TEST_F(AlternateProtocolServerPropertiesTest, Basic) { |
244 HostPortPair test_host_port_pair("foo", 80); | 244 HostPortPair test_host_port_pair("foo", 80); |
245 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); | 245 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); |
246 impl_.SetAlternateProtocol(test_host_port_pair, 443, NPN_SPDY_3, 1); | 246 impl_.AddAlternateProtocol(test_host_port_pair, 443, NPN_SPDY_3, 1); |
247 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); | 247 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); |
248 const AlternateProtocolInfo alternate = | 248 const AlternateProtocols alternate_protocols = |
249 impl_.GetAlternateProtocol(test_host_port_pair); | 249 impl_.GetAlternateProtocol(test_host_port_pair); |
250 ASSERT_EQ(1u, alternate_protocols.size()); | |
251 const AlternateProtocolInfo alternate = alternate_protocols[0]; | |
250 EXPECT_EQ(443, alternate.port); | 252 EXPECT_EQ(443, alternate.port); |
251 EXPECT_EQ(NPN_SPDY_3, alternate.protocol); | 253 EXPECT_EQ(NPN_SPDY_3, alternate.protocol); |
252 | 254 |
253 impl_.Clear(); | 255 impl_.Clear(); |
254 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); | 256 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); |
255 } | 257 } |
256 | 258 |
257 TEST_F(AlternateProtocolServerPropertiesTest, DefaultProbabilityExcluded) { | 259 TEST_F(AlternateProtocolServerPropertiesTest, DefaultProbabilityExcluded) { |
258 HostPortPair test_host_port_pair("foo", 80); | 260 HostPortPair test_host_port_pair("foo", 80); |
259 impl_.SetAlternateProtocol(test_host_port_pair, 443, NPN_SPDY_3, .99); | 261 impl_.AddAlternateProtocol(test_host_port_pair, 443, NPN_SPDY_3, .99); |
260 | 262 |
261 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); | 263 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); |
262 } | 264 } |
263 | 265 |
264 TEST_F(AlternateProtocolServerPropertiesTest, Probability) { | 266 TEST_F(AlternateProtocolServerPropertiesTest, Probability) { |
265 impl_.SetAlternateProtocolProbabilityThreshold(.25); | 267 impl_.SetAlternateProtocolProbabilityThreshold(.25); |
266 | 268 |
267 HostPortPair test_host_port_pair("foo", 80); | 269 HostPortPair test_host_port_pair("foo", 80); |
268 impl_.SetAlternateProtocol(test_host_port_pair, 443, NPN_SPDY_3, .5); | 270 impl_.AddAlternateProtocol(test_host_port_pair, 443, NPN_SPDY_3, .5); |
269 | 271 |
270 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); | 272 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); |
271 const AlternateProtocolInfo alternate = | 273 const AlternateProtocols alternate_protocols = |
272 impl_.GetAlternateProtocol(test_host_port_pair); | 274 impl_.GetAlternateProtocol(test_host_port_pair); |
275 ASSERT_EQ(1u, alternate_protocols.size()); | |
276 const AlternateProtocolInfo alternate = alternate_protocols[0]; | |
273 EXPECT_EQ(443, alternate.port); | 277 EXPECT_EQ(443, alternate.port); |
274 EXPECT_EQ(NPN_SPDY_3, alternate.protocol); | 278 EXPECT_EQ(NPN_SPDY_3, alternate.protocol); |
275 EXPECT_EQ(.5, alternate.probability); | 279 EXPECT_EQ(.5, alternate.probability); |
276 } | 280 } |
277 | 281 |
278 TEST_F(AlternateProtocolServerPropertiesTest, ProbabilityExcluded) { | 282 TEST_F(AlternateProtocolServerPropertiesTest, ProbabilityExcluded) { |
279 impl_.SetAlternateProtocolProbabilityThreshold(.75); | 283 impl_.SetAlternateProtocolProbabilityThreshold(.75); |
280 | 284 |
281 HostPortPair test_host_port_pair("foo", 80); | 285 HostPortPair test_host_port_pair("foo", 80); |
282 | 286 |
283 impl_.SetAlternateProtocol(test_host_port_pair, 443, NPN_SPDY_3, .5); | 287 impl_.AddAlternateProtocol(test_host_port_pair, 443, NPN_SPDY_3, .5); |
284 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); | 288 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); |
285 } | 289 } |
286 | 290 |
287 TEST_F(AlternateProtocolServerPropertiesTest, Initialize) { | 291 TEST_F(AlternateProtocolServerPropertiesTest, Initialize) { |
288 HostPortPair test_host_port_pair1("foo1", 80); | 292 HostPortPair test_host_port_pair1("foo1", 80); |
289 impl_.SetBrokenAlternateProtocol(test_host_port_pair1); | 293 impl_.AddAlternateProtocol(test_host_port_pair1, 123, NPN_SPDY_3, 1); |
294 { | |
295 AlternateProtocolInfo alternate_protocol(123, NPN_SPDY_3, 1); | |
296 impl_.SetBrokenAlternateProtocol(test_host_port_pair1, alternate_protocol); | |
297 } | |
Ryan Hamilton
2014/11/03 19:00:30
Unless it's critical to scope these two lines, pre
Bence
2014/11/03 22:32:26
Done.
| |
290 HostPortPair test_host_port_pair2("foo2", 80); | 298 HostPortPair test_host_port_pair2("foo2", 80); |
291 impl_.SetAlternateProtocol(test_host_port_pair2, 443, NPN_SPDY_3, 1); | 299 impl_.AddAlternateProtocol(test_host_port_pair2, 443, NPN_SPDY_3, 1); |
292 | 300 |
293 AlternateProtocolMap alternate_protocol_map( | 301 AlternateProtocolMap alternate_protocol_map( |
294 AlternateProtocolMap::NO_AUTO_EVICT); | 302 AlternateProtocolMap::NO_AUTO_EVICT); |
295 AlternateProtocolInfo port_alternate_protocol_pair(123, NPN_SPDY_3, 1); | 303 AlternateProtocolInfo port_alternate_protocol_pair(123, NPN_SPDY_3, 1); |
296 alternate_protocol_map.Put(test_host_port_pair2, | 304 alternate_protocol_map.Put( |
297 port_alternate_protocol_pair); | 305 test_host_port_pair2, |
306 AlternateProtocols(/* size = */ 1, | |
307 /* val = */ port_alternate_protocol_pair)); | |
298 HostPortPair test_host_port_pair3("foo3", 80); | 308 HostPortPair test_host_port_pair3("foo3", 80); |
299 port_alternate_protocol_pair.port = 1234; | 309 port_alternate_protocol_pair.port = 1234; |
300 alternate_protocol_map.Put(test_host_port_pair3, | 310 alternate_protocol_map.Put( |
301 port_alternate_protocol_pair); | 311 test_host_port_pair3, |
312 AlternateProtocols(/* size = */ 1, | |
313 /* val = */ port_alternate_protocol_pair)); | |
302 impl_.InitializeAlternateProtocolServers(&alternate_protocol_map); | 314 impl_.InitializeAlternateProtocolServers(&alternate_protocol_map); |
303 | 315 |
304 // Verify test_host_port_pair3 is the MRU server. | 316 // Verify test_host_port_pair3 is the MRU server. |
305 const net::AlternateProtocolMap& map = impl_.alternate_protocol_map(); | 317 const net::AlternateProtocolMap& map = impl_.alternate_protocol_map(); |
306 net::AlternateProtocolMap::const_iterator it = map.begin(); | 318 net::AlternateProtocolMap::const_iterator it = map.begin(); |
307 it = map.begin(); | |
308 EXPECT_TRUE(it->first.Equals(test_host_port_pair3)); | 319 EXPECT_TRUE(it->first.Equals(test_host_port_pair3)); |
309 EXPECT_EQ(1234, it->second.port); | 320 ASSERT_EQ(1u, it->second.size()); |
310 EXPECT_EQ(NPN_SPDY_3, it->second.protocol); | 321 EXPECT_EQ(1234, it->second[0].port); |
322 EXPECT_EQ(NPN_SPDY_3, it->second[0].protocol); | |
311 | 323 |
312 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair1)); | 324 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair1)); |
313 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair2)); | 325 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair2)); |
314 port_alternate_protocol_pair = | 326 AlternateProtocols alternate_protocols = |
315 impl_.GetAlternateProtocol(test_host_port_pair1); | 327 impl_.GetAlternateProtocol(test_host_port_pair1); |
316 EXPECT_EQ(ALTERNATE_PROTOCOL_BROKEN, port_alternate_protocol_pair.protocol); | 328 ASSERT_EQ(1u, alternate_protocols.size()); |
317 port_alternate_protocol_pair = | 329 EXPECT_EQ(ALTERNATE_PROTOCOL_BROKEN, alternate_protocols[0].protocol); |
318 impl_.GetAlternateProtocol(test_host_port_pair2); | 330 alternate_protocols = impl_.GetAlternateProtocol(test_host_port_pair2); |
319 EXPECT_EQ(123, port_alternate_protocol_pair.port); | 331 ASSERT_EQ(1u, alternate_protocols.size()); |
320 EXPECT_EQ(NPN_SPDY_3, port_alternate_protocol_pair.protocol); | 332 EXPECT_EQ(123, alternate_protocols[0].port); |
333 EXPECT_EQ(NPN_SPDY_3, alternate_protocols[0].protocol); | |
321 } | 334 } |
322 | 335 |
323 TEST_F(AlternateProtocolServerPropertiesTest, MRUOfHasAlternateProtocol) { | 336 TEST_F(AlternateProtocolServerPropertiesTest, MRUOfHasAlternateProtocol) { |
324 HostPortPair test_host_port_pair1("foo1", 80); | 337 HostPortPair test_host_port_pair1("foo1", 80); |
325 impl_.SetAlternateProtocol(test_host_port_pair1, 443, NPN_SPDY_3, 1); | 338 impl_.AddAlternateProtocol(test_host_port_pair1, 443, NPN_SPDY_3, 1); |
326 HostPortPair test_host_port_pair2("foo2", 80); | 339 HostPortPair test_host_port_pair2("foo2", 80); |
327 impl_.SetAlternateProtocol(test_host_port_pair2, 1234, NPN_SPDY_3, 1); | 340 impl_.AddAlternateProtocol(test_host_port_pair2, 1234, NPN_SPDY_3, 1); |
328 | 341 |
329 const net::AlternateProtocolMap& map = impl_.alternate_protocol_map(); | 342 const net::AlternateProtocolMap& map = impl_.alternate_protocol_map(); |
330 net::AlternateProtocolMap::const_iterator it = map.begin(); | 343 net::AlternateProtocolMap::const_iterator it = map.begin(); |
331 EXPECT_TRUE(it->first.Equals(test_host_port_pair2)); | 344 EXPECT_TRUE(it->first.Equals(test_host_port_pair2)); |
332 EXPECT_EQ(1234, it->second.port); | 345 ASSERT_EQ(1u, it->second.size()); |
333 EXPECT_EQ(NPN_SPDY_3, it->second.protocol); | 346 EXPECT_EQ(1234, it->second[0].port); |
347 EXPECT_EQ(NPN_SPDY_3, it->second[0].protocol); | |
334 | 348 |
335 // HasAlternateProtocol should reoder the AlternateProtocol map. | 349 // HasAlternateProtocol should reoder the AlternateProtocol map. |
336 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair1)); | 350 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair1)); |
337 it = map.begin(); | 351 it = map.begin(); |
338 EXPECT_TRUE(it->first.Equals(test_host_port_pair1)); | 352 EXPECT_TRUE(it->first.Equals(test_host_port_pair1)); |
339 EXPECT_EQ(443, it->second.port); | 353 ASSERT_EQ(1u, it->second.size()); |
340 EXPECT_EQ(NPN_SPDY_3, it->second.protocol); | 354 EXPECT_EQ(443, it->second[0].port); |
355 EXPECT_EQ(NPN_SPDY_3, it->second[0].protocol); | |
341 } | 356 } |
342 | 357 |
343 TEST_F(AlternateProtocolServerPropertiesTest, MRUOfGetAlternateProtocol) { | 358 TEST_F(AlternateProtocolServerPropertiesTest, MRUOfGetAlternateProtocol) { |
344 HostPortPair test_host_port_pair1("foo1", 80); | 359 HostPortPair test_host_port_pair1("foo1", 80); |
345 impl_.SetAlternateProtocol(test_host_port_pair1, 443, NPN_SPDY_3, 1); | 360 impl_.AddAlternateProtocol(test_host_port_pair1, 443, NPN_SPDY_3, 1); |
346 HostPortPair test_host_port_pair2("foo2", 80); | 361 HostPortPair test_host_port_pair2("foo2", 80); |
347 impl_.SetAlternateProtocol(test_host_port_pair2, 1234, NPN_SPDY_3, 1); | 362 impl_.AddAlternateProtocol(test_host_port_pair2, 1234, NPN_SPDY_3, 1); |
348 | 363 |
349 const net::AlternateProtocolMap& map = impl_.alternate_protocol_map(); | 364 const net::AlternateProtocolMap& map = impl_.alternate_protocol_map(); |
350 net::AlternateProtocolMap::const_iterator it = map.begin(); | 365 net::AlternateProtocolMap::const_iterator it = map.begin(); |
351 EXPECT_TRUE(it->first.Equals(test_host_port_pair2)); | 366 EXPECT_TRUE(it->first.Equals(test_host_port_pair2)); |
352 EXPECT_EQ(1234, it->second.port); | 367 ASSERT_EQ(1u, it->second.size()); |
353 EXPECT_EQ(NPN_SPDY_3, it->second.protocol); | 368 EXPECT_EQ(1234, it->second[0].port); |
369 EXPECT_EQ(NPN_SPDY_3, it->second[0].protocol); | |
354 | 370 |
355 // GetAlternateProtocol should reoder the AlternateProtocol map. | 371 // GetAlternateProtocol should reorder the AlternateProtocol map. |
356 AlternateProtocolInfo alternate = | 372 const AlternateProtocols alternate_protocols = |
357 impl_.GetAlternateProtocol(test_host_port_pair1); | 373 impl_.GetAlternateProtocol(test_host_port_pair1); |
374 ASSERT_EQ(1u, alternate_protocols.size()); | |
375 const AlternateProtocolInfo alternate = alternate_protocols[0]; | |
358 EXPECT_EQ(443, alternate.port); | 376 EXPECT_EQ(443, alternate.port); |
359 EXPECT_EQ(NPN_SPDY_3, alternate.protocol); | 377 EXPECT_EQ(NPN_SPDY_3, alternate.protocol); |
360 it = map.begin(); | 378 it = map.begin(); |
361 EXPECT_TRUE(it->first.Equals(test_host_port_pair1)); | 379 EXPECT_TRUE(it->first.Equals(test_host_port_pair1)); |
362 EXPECT_EQ(443, it->second.port); | 380 ASSERT_EQ(1u, it->second.size()); |
363 EXPECT_EQ(NPN_SPDY_3, it->second.protocol); | 381 EXPECT_EQ(443, it->second[0].port); |
382 EXPECT_EQ(NPN_SPDY_3, it->second[0].protocol); | |
364 } | 383 } |
365 | 384 |
366 TEST_F(AlternateProtocolServerPropertiesTest, SetBroken) { | 385 TEST_F(AlternateProtocolServerPropertiesTest, SetBroken) { |
367 HostPortPair test_host_port_pair("foo", 80); | 386 HostPortPair test_host_port_pair("foo", 80); |
368 impl_.SetBrokenAlternateProtocol(test_host_port_pair); | 387 impl_.AddAlternateProtocol(test_host_port_pair, 123, NPN_SPDY_3, 1); |
388 AlternateProtocolInfo alternate(123, NPN_SPDY_3, 1); | |
389 impl_.SetBrokenAlternateProtocol(test_host_port_pair, alternate); | |
369 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); | 390 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); |
370 AlternateProtocolInfo alternate = | 391 AlternateProtocols alternate_protocols = |
371 impl_.GetAlternateProtocol(test_host_port_pair); | 392 impl_.GetAlternateProtocol(test_host_port_pair); |
372 EXPECT_EQ(ALTERNATE_PROTOCOL_BROKEN, alternate.protocol); | 393 ASSERT_EQ(1u, alternate_protocols.size()); |
394 EXPECT_EQ(ALTERNATE_PROTOCOL_BROKEN, alternate_protocols[0].protocol); | |
373 | 395 |
374 impl_.SetAlternateProtocol( | 396 impl_.AddAlternateProtocol(test_host_port_pair, 123, NPN_SPDY_3, 1); |
375 test_host_port_pair, | 397 alternate_protocols = impl_.GetAlternateProtocol(test_host_port_pair); |
376 1234, | 398 ASSERT_EQ(1u, alternate_protocols.size()) |
377 NPN_SPDY_3, | |
378 1); | |
379 alternate = impl_.GetAlternateProtocol(test_host_port_pair); | |
380 EXPECT_EQ(ALTERNATE_PROTOCOL_BROKEN, alternate.protocol) | |
381 << "Second attempt should be ignored."; | 399 << "Second attempt should be ignored."; |
400 EXPECT_EQ(ALTERNATE_PROTOCOL_BROKEN, alternate_protocols[0].protocol); | |
401 | |
402 impl_.AddAlternateProtocol(test_host_port_pair, 1234, NPN_SPDY_3, 1); | |
403 alternate_protocols = impl_.GetAlternateProtocol(test_host_port_pair); | |
404 ASSERT_EQ(2u, alternate_protocols.size()) << "Different port should be fine."; | |
382 } | 405 } |
Ryan Hamilton
2014/11/03 19:00:30
Do you feel like you have sufficient test coverage
Bence
2014/11/03 22:32:26
Done.
| |
383 | 406 |
384 TEST_F(AlternateProtocolServerPropertiesTest, ClearBroken) { | 407 TEST_F(AlternateProtocolServerPropertiesTest, ClearBroken) { |
385 HostPortPair test_host_port_pair("foo", 80); | 408 HostPortPair test_host_port_pair("foo", 80); |
386 impl_.SetBrokenAlternateProtocol(test_host_port_pair); | 409 impl_.AddAlternateProtocol(test_host_port_pair, 123, NPN_SPDY_3, 1); |
410 AlternateProtocolInfo alternate(123, NPN_SPDY_3, 1); | |
411 impl_.SetBrokenAlternateProtocol(test_host_port_pair, alternate); | |
387 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); | 412 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); |
388 AlternateProtocolInfo alternate = | 413 AlternateProtocols alternate_protocols = |
389 impl_.GetAlternateProtocol(test_host_port_pair); | 414 impl_.GetAlternateProtocol(test_host_port_pair); |
390 EXPECT_EQ(ALTERNATE_PROTOCOL_BROKEN, alternate.protocol); | 415 ASSERT_EQ(1u, alternate_protocols.size()); |
416 EXPECT_EQ(ALTERNATE_PROTOCOL_BROKEN, alternate_protocols[0].protocol); | |
391 impl_.ClearAlternateProtocol(test_host_port_pair); | 417 impl_.ClearAlternateProtocol(test_host_port_pair); |
392 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); | 418 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); |
393 } | 419 } |
394 | 420 |
395 TEST_F(AlternateProtocolServerPropertiesTest, Forced) { | 421 TEST_F(AlternateProtocolServerPropertiesTest, Forced) { |
396 // Test forced alternate protocols. | 422 // Test forced alternate protocols. |
397 | 423 |
398 AlternateProtocolInfo default_protocol(1234, NPN_SPDY_3, 1); | 424 AlternateProtocolInfo default_protocol(1234, NPN_SPDY_3, 1); |
399 HttpServerPropertiesImpl::ForceAlternateProtocol(default_protocol); | 425 HttpServerPropertiesImpl::ForceAlternateProtocol(default_protocol); |
400 | 426 |
401 // Verify the forced protocol. | 427 // Verify the forced protocol. |
402 HostPortPair test_host_port_pair("foo", 80); | 428 HostPortPair test_host_port_pair("foo", 80); |
403 EXPECT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); | 429 EXPECT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); |
404 AlternateProtocolInfo alternate = | 430 AlternateProtocols alternate_protocols = |
405 impl_.GetAlternateProtocol(test_host_port_pair); | 431 impl_.GetAlternateProtocol(test_host_port_pair); |
406 EXPECT_EQ(default_protocol.port, alternate.port); | 432 ASSERT_EQ(1u, alternate_protocols.size()); |
407 EXPECT_EQ(default_protocol.protocol, alternate.protocol); | 433 EXPECT_EQ(default_protocol.port, alternate_protocols[0].port); |
434 EXPECT_EQ(default_protocol.protocol, alternate_protocols[0].protocol); | |
408 | 435 |
409 // Verify the real protocol overrides the forced protocol. | 436 // Verify the real protocol overrides the forced protocol. |
410 impl_.SetAlternateProtocol(test_host_port_pair, 443, NPN_SPDY_3, 1); | 437 impl_.AddAlternateProtocol(test_host_port_pair, 443, NPN_SPDY_3, 1); |
411 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); | 438 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); |
412 alternate = impl_.GetAlternateProtocol(test_host_port_pair); | 439 alternate_protocols = impl_.GetAlternateProtocol(test_host_port_pair); |
413 EXPECT_EQ(443, alternate.port); | 440 ASSERT_EQ(1u, alternate_protocols.size()); |
414 EXPECT_EQ(NPN_SPDY_3, alternate.protocol); | 441 EXPECT_EQ(443, alternate_protocols[0].port); |
442 EXPECT_EQ(NPN_SPDY_3, alternate_protocols[0].protocol); | |
415 | 443 |
416 // Turn off the static, forced alternate protocol so that tests don't | 444 // Turn off the static, forced alternate protocol so that tests don't |
417 // have this state. | 445 // have this state. |
418 HttpServerPropertiesImpl::DisableForcedAlternateProtocol(); | 446 HttpServerPropertiesImpl::DisableForcedAlternateProtocol(); |
419 | 447 |
420 // Verify the forced protocol is off. | 448 // Verify the forced protocol is off. |
421 HostPortPair test_host_port_pair2("bar", 80); | 449 HostPortPair test_host_port_pair2("bar", 80); |
422 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair2)); | 450 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair2)); |
423 } | 451 } |
424 | 452 |
425 TEST_F(AlternateProtocolServerPropertiesTest, Canonical) { | 453 TEST_F(AlternateProtocolServerPropertiesTest, Canonical) { |
426 HostPortPair test_host_port_pair("foo.c.youtube.com", 80); | 454 HostPortPair test_host_port_pair("foo.c.youtube.com", 80); |
427 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); | 455 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); |
428 | 456 |
429 HostPortPair canonical_port_pair("bar.c.youtube.com", 80); | 457 HostPortPair canonical_port_pair("bar.c.youtube.com", 80); |
430 EXPECT_FALSE(impl_.HasAlternateProtocol(canonical_port_pair)); | 458 EXPECT_FALSE(impl_.HasAlternateProtocol(canonical_port_pair)); |
431 | 459 |
432 AlternateProtocolInfo canonical_protocol(1234, QUIC, 1); | 460 AlternateProtocolInfo canonical_protocol(1234, QUIC, 1); |
433 | 461 |
434 impl_.SetAlternateProtocol(canonical_port_pair, | 462 impl_.AddAlternateProtocol(canonical_port_pair, |
435 canonical_protocol.port, | 463 canonical_protocol.port, |
436 canonical_protocol.protocol, | 464 canonical_protocol.protocol, |
437 1); | 465 1); |
438 // Verify the forced protocol. | 466 // Verify the forced protocol. |
439 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); | 467 ASSERT_TRUE(impl_.HasAlternateProtocol(test_host_port_pair)); |
440 AlternateProtocolInfo alternate = | 468 AlternateProtocols alternate_protocols = |
441 impl_.GetAlternateProtocol(test_host_port_pair); | 469 impl_.GetAlternateProtocol(test_host_port_pair); |
442 EXPECT_EQ(canonical_protocol.port, alternate.port); | 470 ASSERT_EQ(1u, alternate_protocols.size()); |
443 EXPECT_EQ(canonical_protocol.protocol, alternate.protocol); | 471 EXPECT_EQ(canonical_protocol.port, alternate_protocols[0].port); |
472 EXPECT_EQ(canonical_protocol.protocol, alternate_protocols[0].protocol); | |
444 | 473 |
445 // Verify the canonical suffix. | 474 // Verify the canonical suffix. |
446 EXPECT_EQ(".c.youtube.com", impl_.GetCanonicalSuffix(test_host_port_pair)); | 475 EXPECT_EQ(".c.youtube.com", impl_.GetCanonicalSuffix(test_host_port_pair)); |
447 EXPECT_EQ(".c.youtube.com", impl_.GetCanonicalSuffix(canonical_port_pair)); | 476 EXPECT_EQ(".c.youtube.com", impl_.GetCanonicalSuffix(canonical_port_pair)); |
448 } | 477 } |
449 | 478 |
450 TEST_F(AlternateProtocolServerPropertiesTest, ClearCanonical) { | 479 TEST_F(AlternateProtocolServerPropertiesTest, ClearCanonical) { |
451 HostPortPair test_host_port_pair("foo.c.youtube.com", 80); | 480 HostPortPair test_host_port_pair("foo.c.youtube.com", 80); |
452 HostPortPair canonical_port_pair("bar.c.youtube.com", 80); | 481 HostPortPair canonical_port_pair("bar.c.youtube.com", 80); |
453 | 482 |
454 AlternateProtocolInfo canonical_protocol(1234, QUIC, 1); | 483 AlternateProtocolInfo canonical_protocol(1234, QUIC, 1); |
455 | 484 |
456 impl_.SetAlternateProtocol(canonical_port_pair, | 485 impl_.AddAlternateProtocol(canonical_port_pair, |
457 canonical_protocol.port, | 486 canonical_protocol.port, |
458 canonical_protocol.protocol, | 487 canonical_protocol.protocol, |
459 canonical_protocol.probability); | 488 canonical_protocol.probability); |
460 | 489 |
461 impl_.ClearAlternateProtocol(canonical_port_pair); | 490 impl_.ClearAlternateProtocol(canonical_port_pair); |
462 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); | 491 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); |
463 } | 492 } |
464 | 493 |
465 TEST_F(AlternateProtocolServerPropertiesTest, CanonicalBroken) { | 494 TEST_F(AlternateProtocolServerPropertiesTest, CanonicalBroken) { |
466 HostPortPair test_host_port_pair("foo.c.youtube.com", 80); | 495 HostPortPair test_host_port_pair("foo.c.youtube.com", 80); |
467 HostPortPair canonical_port_pair("bar.c.youtube.com", 80); | 496 HostPortPair canonical_port_pair("bar.c.youtube.com", 80); |
468 | 497 |
469 AlternateProtocolInfo canonical_protocol(1234, QUIC, 1); | 498 AlternateProtocolInfo canonical_protocol(1234, QUIC, 1); |
470 | 499 |
471 impl_.SetAlternateProtocol(canonical_port_pair, | 500 impl_.AddAlternateProtocol(canonical_port_pair, |
472 canonical_protocol.port, | 501 canonical_protocol.port, |
473 canonical_protocol.protocol, | 502 canonical_protocol.protocol, |
474 canonical_protocol.probability); | 503 canonical_protocol.probability); |
475 | 504 |
476 impl_.SetBrokenAlternateProtocol(canonical_port_pair); | 505 impl_.SetBrokenAlternateProtocol(canonical_port_pair, canonical_protocol); |
477 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); | 506 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); |
478 } | 507 } |
479 | 508 |
480 TEST_F(AlternateProtocolServerPropertiesTest, ClearWithCanonical) { | 509 TEST_F(AlternateProtocolServerPropertiesTest, ClearWithCanonical) { |
481 HostPortPair test_host_port_pair("foo.c.youtube.com", 80); | 510 HostPortPair test_host_port_pair("foo.c.youtube.com", 80); |
482 HostPortPair canonical_port_pair("bar.c.youtube.com", 80); | 511 HostPortPair canonical_port_pair("bar.c.youtube.com", 80); |
483 | 512 |
484 AlternateProtocolInfo canonical_protocol(1234, QUIC, 1); | 513 AlternateProtocolInfo canonical_protocol(1234, QUIC, 1); |
485 | 514 |
486 impl_.SetAlternateProtocol(canonical_port_pair, | 515 impl_.AddAlternateProtocol(canonical_port_pair, |
487 canonical_protocol.port, | 516 canonical_protocol.port, |
488 canonical_protocol.protocol, | 517 canonical_protocol.protocol, |
489 canonical_protocol.probability); | 518 canonical_protocol.probability); |
490 | 519 |
491 impl_.Clear(); | 520 impl_.Clear(); |
492 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); | 521 EXPECT_FALSE(impl_.HasAlternateProtocol(test_host_port_pair)); |
493 } | 522 } |
494 | 523 |
495 typedef HttpServerPropertiesImplTest SpdySettingsServerPropertiesTest; | 524 typedef HttpServerPropertiesImplTest SpdySettingsServerPropertiesTest; |
496 | 525 |
(...skipping 215 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
712 EXPECT_EQ("foo", supports_quic1.address); | 741 EXPECT_EQ("foo", supports_quic1.address); |
713 | 742 |
714 impl_.Clear(); | 743 impl_.Clear(); |
715 SupportsQuic supports_quic2 = impl_.GetSupportsQuic(test_host_port_pair); | 744 SupportsQuic supports_quic2 = impl_.GetSupportsQuic(test_host_port_pair); |
716 EXPECT_FALSE(supports_quic2.used_quic); | 745 EXPECT_FALSE(supports_quic2.used_quic); |
717 EXPECT_EQ("", supports_quic2.address); | 746 EXPECT_EQ("", supports_quic2.address); |
718 } | 747 } |
719 } // namespace | 748 } // namespace |
720 | 749 |
721 } // namespace net | 750 } // namespace net |
OLD | NEW |