net/tools/quic/end_to_end_test.cc

   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
   3 // found in the LICENSE file.
   4
   5 #include <stddef.h>
   6 #include <string>
   7
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/memory/singleton.h"
  10 #include "base/strings/string_number_conversions.h"
  11 #include "base/synchronization/waitable_event.h"
  12 #include "base/threading/simple_thread.h"
  13 #include "net/base/ip_endpoint.h"
  14 #include "net/quic/crypto/aes_128_gcm_12_encrypter.h"
  15 #include "net/quic/crypto/null_encrypter.h"
  16 #include "net/quic/quic_framer.h"
  17 #include "net/quic/quic_packet_creator.h"
  18 #include "net/quic/quic_protocol.h"
  19 #include "net/quic/test_tools/quic_connection_peer.h"
  20 #include "net/quic/test_tools/quic_session_peer.h"
  21 #include "net/quic/test_tools/reliable_quic_stream_peer.h"
  22 #include "net/tools/quic/quic_epoll_connection_helper.h"
  23 #include "net/tools/quic/quic_in_memory_cache.h"
  24 #include "net/tools/quic/quic_server.h"
  25 #include "net/tools/quic/quic_socket_utils.h"
  26 #include "net/tools/quic/test_tools/http_message_test_utils.h"
  27 #include "net/tools/quic/test_tools/quic_client_peer.h"
  28 #include "net/tools/quic/test_tools/quic_epoll_connection_helper_peer.h"
  29 #include "net/tools/quic/test_tools/quic_test_client.h"
  30 #include "testing/gtest/include/gtest/gtest.h"
  31
  32 using base::StringPiece;
  33 using base::WaitableEvent;
  34 using net::test::QuicConnectionPeer;
  35 using net::test::QuicSessionPeer;
  36 using net::test::ReliableQuicStreamPeer;
  37 using std::string;
  38
  39 namespace net {
  40 namespace tools {
  41 namespace test {
  42 namespace {
  43
  44 const char* kFooResponseBody = "Artichoke hearts make me happy.";
  45 const char* kBarResponseBody = "Palm hearts are pretty delicious, also.";
  46 const size_t kCongestionFeedbackFrameSize = 25;
  47 // If kCongestionFeedbackFrameSize increase we need to expand this string
  48 // accordingly.
  49 const char* kLargeRequest =
  50     "https://www.google.com/foo/test/a/request/string/longer/than/25/bytes";
  51
  52 void GenerateBody(string* body, int length) {
  53   body->clear();
  54   body->reserve(length);
  55   for (int i = 0; i < length; ++i) {
  56     body->append(1, static_cast<char>(32 + i % (126 - 32)));
  57   }
  58 }
  59
  60
  61 // Simple wrapper class to run server in a thread.
  62 class ServerThread : public base::SimpleThread {
  63  public:
  64   explicit ServerThread(IPEndPoint address, const QuicConfig& config)
  65       : SimpleThread("server_thread"),
  66         listening_(true, false),
  67         quit_(true, false),
  68         server_(config),
  69         address_(address),
  70         port_(0) {
  71   }
  72   virtual ~ServerThread() {
  73   }
  74
  75   virtual void Run() OVERRIDE {
  76     server_.Listen(address_);
  77
  78     port_lock_.Acquire();
  79     port_ = server_.port();
  80     port_lock_.Release();
  81
  82     listening_.Signal();
  83     while (!quit_.IsSignaled()) {
  84       server_.WaitForEvents();
  85     }
  86     server_.Shutdown();
  87   }
  88
  89   int GetPort() {
  90     port_lock_.Acquire();
  91     int rc = port_;
  92     port_lock_.Release();
  93     return rc;
  94   }
  95
  96   WaitableEvent* listening() { return &listening_; }
  97   WaitableEvent* quit() { return &quit_; }
  98
  99  private:
 100   WaitableEvent listening_;
 101   WaitableEvent quit_;
 102   base::Lock port_lock_;
 103   QuicServer server_;
 104   IPEndPoint address_;
 105   int port_;
 106
 107   DISALLOW_COPY_AND_ASSIGN(ServerThread);
 108 };
 109
 110 class EndToEndTest : public ::testing::TestWithParam<QuicVersion> {
 111  public:
 112   static void SetUpTestCase() {
 113     QuicInMemoryCache::GetInstance()->ResetForTests();
 114   }
 115
 116  protected:
 117   EndToEndTest()
 118       : server_hostname_("example.com"),
 119         server_started_(false) {
 120     net::IPAddressNumber ip;
 121     CHECK(net::ParseIPLiteralToNumber("127.0.0.1", &ip));
 122     server_address_ = IPEndPoint(ip, 0);
 123     client_config_.SetDefaults();
 124     server_config_.SetDefaults();
 125
 126     AddToCache("GET", kLargeRequest, "HTTP/1.1", "200", "OK", kFooResponseBody);
 127     AddToCache("GET", "https://www.google.com/foo",
 128                "HTTP/1.1", "200", "OK", kFooResponseBody);
 129     AddToCache("GET", "https://www.google.com/bar",
 130                "HTTP/1.1", "200", "OK", kBarResponseBody);
 131     version_ = GetParam();
 132   }
 133
 134   virtual QuicTestClient* CreateQuicClient() {
 135     QuicTestClient* client = new QuicTestClient(server_address_,
 136                                                 server_hostname_,
 137                                                 false,  // not secure
 138                                                 client_config_,
 139                                                 version_);
 140     client->Connect();
 141     return client;
 142   }
 143
 144   virtual bool Initialize() {
 145     // Start the server first, because CreateQuicClient() attempts
 146     // to connect to the server.
 147     StartServer();
 148     client_.reset(CreateQuicClient());
 149     return client_->client()->connected();
 150   }
 151
 152   virtual void TearDown() {
 153     StopServer();
 154   }
 155
 156   void StartServer() {
 157     server_thread_.reset(new ServerThread(server_address_, server_config_));
 158     server_thread_->Start();
 159     server_thread_->listening()->Wait();
 160     server_address_ = IPEndPoint(server_address_.address(),
 161                                  server_thread_->GetPort());
 162     server_started_ = true;
 163   }
 164
 165   void StopServer() {
 166     if (!server_started_)
 167       return;
 168     if (server_thread_.get()) {
 169       server_thread_->quit()->Signal();
 170       server_thread_->Join();
 171     }
 172   }
 173
 174   void AddToCache(const StringPiece& method,
 175                   const StringPiece& path,
 176                   const StringPiece& version,
 177                   const StringPiece& response_code,
 178                   const StringPiece& response_detail,
 179                   const StringPiece& body) {
 180     BalsaHeaders request_headers, response_headers;
 181     request_headers.SetRequestFirstlineFromStringPieces(method,
 182                                                         path,
 183                                                         version);
 184     response_headers.SetRequestFirstlineFromStringPieces(version,
 185                                                          response_code,
 186                                                          response_detail);
 187     response_headers.AppendHeader("content-length",
 188                                   base::IntToString(body.length()));
 189
 190     // Check if response already exists and matches.
 191     QuicInMemoryCache* cache = QuicInMemoryCache::GetInstance();
 192     const QuicInMemoryCache::Response* cached_response =
 193         cache->GetResponse(request_headers);
 194     if (cached_response != NULL) {
 195       string cached_response_headers_str, response_headers_str;
 196       cached_response->headers().DumpToString(&cached_response_headers_str);
 197       response_headers.DumpToString(&response_headers_str);
 198       CHECK_EQ(cached_response_headers_str, response_headers_str);
 199       CHECK_EQ(cached_response->body(), body);
 200       return;
 201     }
 202     cache->AddResponse(request_headers, response_headers, body);
 203   }
 204
 205   IPEndPoint server_address_;
 206   string server_hostname_;
 207   scoped_ptr<ServerThread> server_thread_;
 208   scoped_ptr<QuicTestClient> client_;
 209   bool server_started_;
 210   QuicConfig client_config_;
 211   QuicConfig server_config_;
 212   QuicVersion version_;
 213 };
 214
 215 // Run all end to end tests with all supported versions.
 216 INSTANTIATE_TEST_CASE_P(EndToEndTests,
 217                         EndToEndTest,
 218                         ::testing::ValuesIn(kSupportedQuicVersions));
 219
 220 TEST_P(EndToEndTest, SimpleRequestResponse) {
 221   // TODO(rtenneti): Delete this when NSS is supported.
 222   if (!Aes128Gcm12Encrypter::IsSupported()) {
 223     LOG(INFO) << "AES GCM not supported. Test skipped.";
 224     return;
 225   }
 226
 227   ASSERT_TRUE(Initialize());
 228
 229   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
 230   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 231 }
 232
 233 // TODO(rch): figure out how to detect missing v6 supprt (like on the linux
 234 // try bots) and selectively disable this test.
 235 TEST_P(EndToEndTest, DISABLED_SimpleRequestResponsev6) {
 236   // TODO(rtenneti): Delete this when NSS is supported.
 237   if (!Aes128Gcm12Encrypter::IsSupported()) {
 238     LOG(INFO) << "AES GCM not supported. Test skipped.";
 239     return;
 240   }
 241
 242   IPAddressNumber ip;
 243   CHECK(net::ParseIPLiteralToNumber("::1", &ip));
 244   server_address_ = IPEndPoint(ip, server_address_.port());
 245   ASSERT_TRUE(Initialize());
 246
 247   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
 248   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 249 }
 250
 251 TEST_P(EndToEndTest, SeparateFinPacket) {
 252   // TODO(rtenneti): Delete this when NSS is supported.
 253   if (!Aes128Gcm12Encrypter::IsSupported()) {
 254     LOG(INFO) << "AES GCM not supported. Test skipped.";
 255     return;
 256   }
 257
 258   ASSERT_TRUE(Initialize());
 259
 260   HTTPMessage request(HttpConstants::HTTP_1_1,
 261                       HttpConstants::POST, "/foo");
 262   request.set_has_complete_message(false);
 263
 264   client_->SendMessage(request);
 265
 266   client_->SendData(string(), true);
 267
 268   client_->WaitForResponse();
 269   EXPECT_EQ(kFooResponseBody, client_->response_body());
 270   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 271
 272   request.AddBody("foo", true);
 273
 274   client_->SendMessage(request);
 275   client_->SendData(string(), true);
 276   client_->WaitForResponse();
 277   EXPECT_EQ(kFooResponseBody, client_->response_body());
 278   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 279 }
 280
 281 TEST_P(EndToEndTest, MultipleRequestResponse) {
 282   // TODO(rtenneti): Delete this when NSS is supported.
 283   if (!Aes128Gcm12Encrypter::IsSupported()) {
 284     LOG(INFO) << "AES GCM not supported. Test skipped.";
 285     return;
 286   }
 287
 288   ASSERT_TRUE(Initialize());
 289
 290   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
 291   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 292   EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest("/bar"));
 293   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 294 }
 295
 296 TEST_P(EndToEndTest, MultipleClients) {
 297   // TODO(rtenneti): Delete this when NSS is supported.
 298   if (!Aes128Gcm12Encrypter::IsSupported()) {
 299     LOG(INFO) << "AES GCM not supported. Test skipped.";
 300     return;
 301   }
 302
 303   ASSERT_TRUE(Initialize());
 304   scoped_ptr<QuicTestClient> client2(CreateQuicClient());
 305
 306   HTTPMessage request(HttpConstants::HTTP_1_1,
 307                       HttpConstants::POST, "/foo");
 308   request.AddHeader("content-length", "3");
 309   request.set_has_complete_message(false);
 310
 311   client_->SendMessage(request);
 312   client2->SendMessage(request);
 313
 314   client_->SendData("bar", true);
 315   client_->WaitForResponse();
 316   EXPECT_EQ(kFooResponseBody, client_->response_body());
 317   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 318
 319   client2->SendData("eep", true);
 320   client2->WaitForResponse();
 321   EXPECT_EQ(kFooResponseBody, client2->response_body());
 322   EXPECT_EQ(200u, client2->response_headers()->parsed_response_code());
 323 }
 324
 325 TEST_P(EndToEndTest, RequestOverMultiplePackets) {
 326   // TODO(rtenneti): Delete this when NSS is supported.
 327   if (!Aes128Gcm12Encrypter::IsSupported()) {
 328     LOG(INFO) << "AES GCM not supported. Test skipped.";
 329     return;
 330   }
 331
 332   ASSERT_TRUE(Initialize());
 333   // Set things up so we have a small payload, to guarantee fragmentation.
 334   // A congestion feedback frame can't be split into multiple packets, make sure
 335   // that our packet have room for at least this amount after the normal headers
 336   // are added.
 337
 338   // TODO(rch) handle this better when we have different encryption options.
 339   const size_t kStreamDataLength = 3;
 340   const QuicStreamId kStreamId = 1u;
 341   const QuicStreamOffset kStreamOffset = 0u;
 342   size_t stream_payload_size =
 343       QuicFramer::GetMinStreamFrameSize(
 344           GetParam(), kStreamId, kStreamOffset, true) + kStreamDataLength;
 345   size_t min_payload_size =
 346       std::max(kCongestionFeedbackFrameSize, stream_payload_size);
 347   size_t ciphertext_size = NullEncrypter().GetCiphertextSize(min_payload_size);
 348   // TODO(satyashekhar): Fix this when versioning is implemented.
 349   client_->options()->max_packet_length =
 350       GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
 351                           PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP) +
 352       ciphertext_size;
 353
 354   // Make sure our request is too large to fit in one packet.
 355   EXPECT_GT(strlen(kLargeRequest), min_payload_size);
 356   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest(kLargeRequest));
 357   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 358 }
 359
 360 TEST_P(EndToEndTest, MultipleFramesRandomOrder) {
 361   // TODO(rtenneti): Delete this when NSS is supported.
 362   if (!Aes128Gcm12Encrypter::IsSupported()) {
 363     LOG(INFO) << "AES GCM not supported. Test skipped.";
 364     return;
 365   }
 366
 367   ASSERT_TRUE(Initialize());
 368   // Set things up so we have a small payload, to guarantee fragmentation.
 369   // A congestion feedback frame can't be split into multiple packets, make sure
 370   // that our packet have room for at least this amount after the normal headers
 371   // are added.
 372
 373   // TODO(rch) handle this better when we have different encryption options.
 374   const size_t kStreamDataLength = 3;
 375   const QuicStreamId kStreamId = 1u;
 376   const QuicStreamOffset kStreamOffset = 0u;
 377   size_t stream_payload_size =
 378       QuicFramer::GetMinStreamFrameSize(
 379           GetParam(), kStreamId, kStreamOffset, true) + kStreamDataLength;
 380   size_t min_payload_size =
 381       std::max(kCongestionFeedbackFrameSize, stream_payload_size);
 382   size_t ciphertext_size = NullEncrypter().GetCiphertextSize(min_payload_size);
 383   // TODO(satyashekhar): Fix this when versioning is implemented.
 384   client_->options()->max_packet_length =
 385       GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
 386                           PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP) +
 387       ciphertext_size;
 388   client_->options()->random_reorder = true;
 389
 390   // Make sure our request is too large to fit in one packet.
 391   EXPECT_GT(strlen(kLargeRequest), min_payload_size);
 392   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest(kLargeRequest));
 393   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 394 }
 395
 396 TEST_P(EndToEndTest, PostMissingBytes) {
 397   // TODO(rtenneti): Delete this when NSS is supported.
 398   if (!Aes128Gcm12Encrypter::IsSupported()) {
 399     LOG(INFO) << "AES GCM not supported. Test skipped.";
 400     return;
 401   }
 402
 403   ASSERT_TRUE(Initialize());
 404
 405   // Add a content length header with no body.
 406   HTTPMessage request(HttpConstants::HTTP_1_1,
 407                       HttpConstants::POST, "/foo");
 408   request.AddHeader("content-length", "3");
 409   request.set_skip_message_validation(true);
 410
 411   // This should be detected as stream fin without complete request,
 412   // triggering an error response.
 413   client_->SendCustomSynchronousRequest(request);
 414   EXPECT_EQ("bad", client_->response_body());
 415   EXPECT_EQ(500u, client_->response_headers()->parsed_response_code());
 416 }
 417
 418 TEST_P(EndToEndTest, LargePost) {
 419   // TODO(rtenneti): Delete this when NSS is supported.
 420   if (!Aes128Gcm12Encrypter::IsSupported()) {
 421     LOG(INFO) << "AES GCM not supported. Test skipped.";
 422     return;
 423   }
 424
 425   // Connect with lower fake packet loss than we'd like to test.  Until
 426   // b/10126687 is fixed, losing handshake packets is pretty brutal.
 427   // FLAGS_fake_packet_loss_percentage = 5;
 428   ASSERT_TRUE(Initialize());
 429
 430   // Wait for the server SHLO before upping the packet loss.
 431   client_->client()->WaitForCryptoHandshakeConfirmed();
 432   // FLAGS_fake_packet_loss_percentage = 30;
 433
 434   string body;
 435   GenerateBody(&body, 10240);
 436
 437   HTTPMessage request(HttpConstants::HTTP_1_1,
 438                       HttpConstants::POST, "/foo");
 439   request.AddBody(body, true);
 440
 441   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
 442 }
 443
 444 // TODO(ianswett): Enable once b/9295090 is fixed.
 445 TEST_P(EndToEndTest, DISABLED_LargePostFEC) {
 446   // FLAGS_fake_packet_loss_percentage = 30;
 447   ASSERT_TRUE(Initialize());
 448   client_->options()->max_packets_per_fec_group = 6;
 449
 450   // TODO(rtenneti): Delete this when NSS is supported.
 451   if (!Aes128Gcm12Encrypter::IsSupported()) {
 452     LOG(INFO) << "AES GCM not supported. Test skipped.";
 453     return;
 454   }
 455
 456   // FLAGS_fake_packet_loss_percentage = 30;
 457   ASSERT_TRUE(Initialize());
 458   client_->options()->max_packets_per_fec_group = 6;
 459
 460   string body;
 461   GenerateBody(&body, 10240);
 462
 463   HTTPMessage request(HttpConstants::HTTP_1_1,
 464                       HttpConstants::POST, "/foo");
 465   request.AddBody(body, true);
 466
 467   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
 468 }
 469
 470 /*TEST_P(EndToEndTest, PacketTooLarge) {
 471   FLAGS_quic_allow_oversized_packets_for_test = true;
 472   ASSERT_TRUE(Initialize());
 473
 474   string body;
 475   GenerateBody(&body, kMaxPacketSize);
 476
 477   HTTPMessage request(HttpConstants::HTTP_1_1,
 478                       HttpConstants::POST, "/foo");
 479   request.AddBody(body, true);
 480   client_->options()->max_packet_length = 20480;
 481
 482   EXPECT_EQ("", client_->SendCustomSynchronousRequest(request));
 483   EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
 484   EXPECT_EQ(QUIC_PACKET_TOO_LARGE, client_->connection_error());
 485 }*/
 486
 487 TEST_P(EndToEndTest, InvalidStream) {
 488   // TODO(rtenneti): Delete this when NSS is supported.
 489   if (!Aes128Gcm12Encrypter::IsSupported()) {
 490     LOG(INFO) << "AES GCM not supported. Test skipped.";
 491     return;
 492   }
 493
 494   ASSERT_TRUE(Initialize());
 495
 496   string body;
 497   GenerateBody(&body, kMaxPacketSize);
 498
 499   HTTPMessage request(HttpConstants::HTTP_1_1,
 500                       HttpConstants::POST, "/foo");
 501   request.AddBody(body, true);
 502   // Force the client to write with a stream ID belonging to a nonexistent
 503   // server-side stream.
 504   QuicSessionPeer::SetNextStreamId(client_->client()->session(), 2);
 505
 506   client_->SendCustomSynchronousRequest(request);
 507 //  EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
 508   EXPECT_EQ(QUIC_PACKET_FOR_NONEXISTENT_STREAM, client_->connection_error());
 509 }
 510
 511 // TODO(rch): this test seems to cause net_unittests timeouts :|
 512 TEST_P(EndToEndTest, DISABLED_MultipleTermination) {
 513   // TODO(rtenneti): Delete this when NSS is supported.
 514   if (!Aes128Gcm12Encrypter::IsSupported()) {
 515     LOG(INFO) << "AES GCM not supported. Test skipped.";
 516     return;
 517   }
 518
 519   ASSERT_TRUE(Initialize());
 520   scoped_ptr<QuicTestClient> client2(CreateQuicClient());
 521
 522   HTTPMessage request(HttpConstants::HTTP_1_1,
 523                       HttpConstants::POST, "/foo");
 524   request.AddHeader("content-length", "3");
 525   request.set_has_complete_message(false);
 526
 527   // Set the offset so we won't frame.  Otherwise when we pick up termination
 528   // before HTTP framing is complete, we send an error and close the stream,
 529   // and the second write is picked up as writing on a closed stream.
 530   QuicReliableClientStream* stream = client_->GetOrCreateStream();
 531   ASSERT_TRUE(stream != NULL);
 532   ReliableQuicStreamPeer::SetStreamBytesWritten(3, stream);
 533
 534   client_->SendData("bar", true);
 535
 536   // By default the stream protects itself from writes after terminte is set.
 537   // Override this to test the server handling buggy clients.
 538   ReliableQuicStreamPeer::SetWriteSideClosed(
 539       false, client_->GetOrCreateStream());
 540
 541 #if !defined(WIN32) && defined(GTEST_HAS_DEATH_TEST)
 542 #if !defined(DCHECK_ALWAYS_ON)
 543   EXPECT_DEBUG_DEATH({
 544       client_->SendData("eep", true);
 545       client_->WaitForResponse();
 546       EXPECT_EQ(QUIC_MULTIPLE_TERMINATION_OFFSETS, client_->stream_error());
 547     },
 548     "Check failed: !fin_buffered_");
 549 #else
 550   EXPECT_DEATH({
 551       client_->SendData("eep", true);
 552       client_->WaitForResponse();
 553       EXPECT_EQ(QUIC_MULTIPLE_TERMINATION_OFFSETS, client_->stream_error());
 554     },
 555     "Check failed: !fin_buffered_");
 556 #endif
 557 #endif
 558 }
 559
 560 TEST_P(EndToEndTest, Timeout) {
 561   client_config_.set_idle_connection_state_lifetime(
 562       QuicTime::Delta::FromMicroseconds(500),
 563       QuicTime::Delta::FromMicroseconds(500));
 564   // Note: we do NOT ASSERT_TRUE: we may time out during initial handshake:
 565   // that's enough to validate timeout in this case.
 566   Initialize();
 567   while (client_->client()->connected()) {
 568     client_->client()->WaitForEvents();
 569   }
 570 }
 571
 572 TEST_P(EndToEndTest, LimitMaxOpenStreams) {
 573   // Server limits the number of max streams to 2.
 574   server_config_.set_max_streams_per_connection(2, 2);
 575   // Client tries to negotiate for 10.
 576   client_config_.set_max_streams_per_connection(10, 5);
 577
 578   ASSERT_TRUE(Initialize());
 579   client_->client()->WaitForCryptoHandshakeConfirmed();
 580   QuicConfig* client_negotiated_config = client_->client()->session()->config();
 581   EXPECT_EQ(2u, client_negotiated_config->max_streams_per_connection());
 582 }
 583
 584 TEST_P(EndToEndTest, ResetConnection) {
 585   // TODO(rtenneti): Delete this when NSS is supported.
 586   if (!Aes128Gcm12Encrypter::IsSupported()) {
 587     LOG(INFO) << "AES GCM not supported. Test skipped.";
 588     return;
 589   }
 590
 591   ASSERT_TRUE(Initialize());
 592
 593   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
 594   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 595   client_->ResetConnection();
 596   EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest("/bar"));
 597   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 598 }
 599
 600 class WrongAddressWriter : public QuicPacketWriter {
 601  public:
 602   explicit WrongAddressWriter(int fd) : fd_(fd) {
 603     IPAddressNumber ip;
 604     CHECK(net::ParseIPLiteralToNumber("127.0.0.2", &ip));
 605     self_address_ = IPEndPoint(ip, 0);
 606   }
 607
 608   virtual int WritePacket(const char* buffer, size_t buf_len,
 609                           const IPAddressNumber& real_self_address,
 610                           const IPEndPoint& peer_address,
 611                           QuicBlockedWriterInterface* blocked_writer,
 612                           int* error) OVERRIDE {
 613     return QuicSocketUtils::WritePacket(fd_, buffer, buf_len,
 614                                         self_address_.address(), peer_address,
 615                                         error);
 616   }
 617
 618   IPEndPoint self_address_;
 619   int fd_;
 620 };
 621
 622 TEST_P(EndToEndTest, ConnectionMigration) {
 623   // TODO(rtenneti): Delete this when NSS is supported.
 624   if (!Aes128Gcm12Encrypter::IsSupported()) {
 625     LOG(INFO) << "AES GCM not supported. Test skipped.";
 626     return;
 627   }
 628
 629   ASSERT_TRUE(Initialize());
 630
 631   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
 632   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 633
 634   WrongAddressWriter writer(QuicClientPeer::GetFd(client_->client()));
 635   QuicEpollConnectionHelper* helper =
 636       reinterpret_cast<QuicEpollConnectionHelper*>(
 637           QuicConnectionPeer::GetHelper(
 638               client_->client()->session()->connection()));
 639   QuicEpollConnectionHelperPeer::SetWriter(helper, &writer);
 640
 641   client_->SendSynchronousRequest("/bar");
 642   QuicEpollConnectionHelperPeer::SetWriter(helper, NULL);
 643
 644   EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
 645   EXPECT_EQ(QUIC_ERROR_MIGRATING_ADDRESS, client_->connection_error());
 646 }
 647
 648 }  // namespace
 649 }  // namespace test
 650 }  // namespace tools
 651 }  // namespace net