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 #include <sys/epoll.h>
   8 #include <vector>
   9
  10 #include "base/basictypes.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/memory/singleton.h"
  13 #include "base/strings/string_number_conversions.h"
  14 #include "base/synchronization/waitable_event.h"
  15 #include "base/threading/platform_thread.h"
  16 #include "base/time/time.h"
  17 #include "net/base/ip_endpoint.h"
  18 #include "net/quic/congestion_control/tcp_cubic_sender.h"
  19 #include "net/quic/crypto/aes_128_gcm_12_encrypter.h"
  20 #include "net/quic/crypto/null_encrypter.h"
  21 #include "net/quic/quic_flags.h"
  22 #include "net/quic/quic_framer.h"
  23 #include "net/quic/quic_packet_creator.h"
  24 #include "net/quic/quic_protocol.h"
  25 #include "net/quic/quic_server_id.h"
  26 #include "net/quic/quic_utils.h"
  27 #include "net/quic/test_tools/quic_connection_peer.h"
  28 #include "net/quic/test_tools/quic_flow_controller_peer.h"
  29 #include "net/quic/test_tools/quic_sent_packet_manager_peer.h"
  30 #include "net/quic/test_tools/quic_session_peer.h"
  31 #include "net/quic/test_tools/quic_spdy_session_peer.h"
  32 #include "net/quic/test_tools/quic_test_utils.h"
  33 #include "net/quic/test_tools/reliable_quic_stream_peer.h"
  34 #include "net/test/gtest_util.h"
  35 #include "net/tools/epoll_server/epoll_server.h"
  36 #include "net/tools/quic/quic_epoll_connection_helper.h"
  37 #include "net/tools/quic/quic_in_memory_cache.h"
  38 #include "net/tools/quic/quic_packet_writer_wrapper.h"
  39 #include "net/tools/quic/quic_server.h"
  40 #include "net/tools/quic/quic_socket_utils.h"
  41 #include "net/tools/quic/quic_spdy_client_stream.h"
  42 #include "net/tools/quic/test_tools/http_message.h"
  43 #include "net/tools/quic/test_tools/packet_dropping_test_writer.h"
  44 #include "net/tools/quic/test_tools/quic_client_peer.h"
  45 #include "net/tools/quic/test_tools/quic_dispatcher_peer.h"
  46 #include "net/tools/quic/test_tools/quic_in_memory_cache_peer.h"
  47 #include "net/tools/quic/test_tools/quic_server_peer.h"
  48 #include "net/tools/quic/test_tools/quic_test_client.h"
  49 #include "net/tools/quic/test_tools/server_thread.h"
  50 #include "testing/gtest/include/gtest/gtest.h"
  51
  52 using base::StringPiece;
  53 using base::WaitableEvent;
  54 using net::EpollServer;
  55 using net::test::ConstructEncryptedPacket;
  56 using net::test::GenerateBody;
  57 using net::test::MockQuicConnectionDebugVisitor;
  58 using net::test::QuicConnectionPeer;
  59 using net::test::QuicFlowControllerPeer;
  60 using net::test::QuicSentPacketManagerPeer;
  61 using net::test::QuicSessionPeer;
  62 using net::test::QuicSpdySessionPeer;
  63 using net::test::ReliableQuicStreamPeer;
  64 using net::test::ValueRestore;
  65 using net::test::kClientDataStreamId1;
  66 using net::tools::test::PacketDroppingTestWriter;
  67 using net::tools::test::QuicDispatcherPeer;
  68 using net::tools::test::QuicServerPeer;
  69 using std::ostream;
  70 using std::string;
  71 using std::vector;
  72
  73 namespace net {
  74 namespace tools {
  75 namespace test {
  76 namespace {
  77
  78 const char kFooResponseBody[] = "Artichoke hearts make me happy.";
  79 const char kBarResponseBody[] = "Palm hearts are pretty delicious, also.";
  80
  81 // Run all tests with the cross products of all versions.
  82 struct TestParams {
  83   TestParams(const QuicVersionVector& client_supported_versions,
  84              const QuicVersionVector& server_supported_versions,
  85              QuicVersion negotiated_version,
  86              bool use_fec,
  87              QuicTag congestion_control_tag)
  88       : client_supported_versions(client_supported_versions),
  89         server_supported_versions(server_supported_versions),
  90         negotiated_version(negotiated_version),
  91         use_fec(use_fec),
  92         congestion_control_tag(congestion_control_tag) {
  93   }
  94
  95   friend ostream& operator<<(ostream& os, const TestParams& p) {
  96     os << "{ server_supported_versions: "
  97        << QuicVersionVectorToString(p.server_supported_versions);
  98     os << " client_supported_versions: "
  99        << QuicVersionVectorToString(p.client_supported_versions);
 100     os << " negotiated_version: " << QuicVersionToString(p.negotiated_version);
 101     os << " use_fec: " << p.use_fec;
 102     os << " congestion_control_tag: "
 103        << QuicUtils::TagToString(p.congestion_control_tag) << " }";
 104     return os;
 105   }
 106
 107   QuicVersionVector client_supported_versions;
 108   QuicVersionVector server_supported_versions;
 109   QuicVersion negotiated_version;
 110   bool use_fec;
 111   QuicTag congestion_control_tag;
 112 };
 113
 114 // Constructs various test permutations.
 115 vector<TestParams> GetTestParams() {
 116   // Divide the versions into buckets in which the intra-frame format
 117   // is compatible. When clients encounter QUIC version negotiation
 118   // they simply retransmit all packets using the new version's
 119   // QUIC framing. However, they are unable to change the intra-frame
 120   // layout (for example to change SPDY/4 headers to SPDY/3). So
 121   // these tests need to ensure that clients are never attempting
 122   // to do 0-RTT across incompatible versions. Chromium only supports
 123   // a single version at a time anyway. :)
 124   QuicVersionVector all_supported_versions = QuicSupportedVersions();
 125   QuicVersionVector client_version_buckets[2];
 126   for (const QuicVersion version : all_supported_versions) {
 127     if (version <= QUIC_VERSION_24) {
 128       // SPDY/4 compression but SPDY/3 headers
 129       client_version_buckets[0].push_back(version);
 130     } else {
 131       // SPDY/4
 132       client_version_buckets[1].push_back(version);
 133     }
 134   }
 135
 136   vector<TestParams> params;
 137   // TODO(rtenneti): Add kTBBR after BBR code is checked in.
 138   // for (const QuicTag congestion_control_tag : {kRENO, kTBBR, kQBIC}) {
 139   for (const QuicTag congestion_control_tag : {kRENO, kQBIC}) {
 140     for (const bool use_fec : {false, true}) {
 141       for (const QuicVersionVector& client_versions : client_version_buckets) {
 142         CHECK(!client_versions.empty());
 143         // Add an entry for server and client supporting all versions.
 144         params.push_back(TestParams(client_versions, all_supported_versions,
 145                                     client_versions.front(), use_fec != 0,
 146                                     congestion_control_tag));
 147
 148         // Test client supporting all versions and server supporting 1
 149         // version. Simulate an old server and exercise version downgrade in
 150         // the client. Protocol negotiation should occur. Skip the i = 0 case
 151         // because it is essentially the same as the default case.
 152         for (const QuicVersion version : client_versions) {
 153           QuicVersionVector server_supported_versions;
 154           server_supported_versions.push_back(version);
 155           params.push_back(TestParams(client_versions,
 156                                       server_supported_versions,
 157                                       server_supported_versions.front(),
 158                                       use_fec != 0, congestion_control_tag));
 159         }
 160       }
 161     }
 162   }
 163   return params;
 164 }
 165
 166 class ServerDelegate : public PacketDroppingTestWriter::Delegate {
 167  public:
 168   ServerDelegate(TestWriterFactory* writer_factory,
 169                  QuicDispatcher* dispatcher)
 170       : writer_factory_(writer_factory),
 171         dispatcher_(dispatcher) {}
 172   ~ServerDelegate() override {}
 173   void OnPacketSent(WriteResult result) override {
 174     writer_factory_->OnPacketSent(result);
 175   }
 176   void OnCanWrite() override { dispatcher_->OnCanWrite(); }
 177
 178  private:
 179   TestWriterFactory* writer_factory_;
 180   QuicDispatcher* dispatcher_;
 181 };
 182
 183 class ClientDelegate : public PacketDroppingTestWriter::Delegate {
 184  public:
 185   explicit ClientDelegate(QuicClient* client) : client_(client) {}
 186   ~ClientDelegate() override {}
 187   void OnPacketSent(WriteResult result) override {}
 188   void OnCanWrite() override {
 189     EpollEvent event(EPOLLOUT, false);
 190     client_->OnEvent(client_->fd(), &event);
 191   }
 192
 193  private:
 194   QuicClient* client_;
 195 };
 196
 197 class EndToEndTest : public ::testing::TestWithParam<TestParams> {
 198  protected:
 199   EndToEndTest()
 200       : server_hostname_("example.com"),
 201         server_started_(false),
 202         strike_register_no_startup_period_(false) {
 203     net::IPAddressNumber ip;
 204     CHECK(net::ParseIPLiteralToNumber("127.0.0.1", &ip));
 205     server_address_ = IPEndPoint(ip, 0);
 206
 207     client_supported_versions_ = GetParam().client_supported_versions;
 208     server_supported_versions_ = GetParam().server_supported_versions;
 209     negotiated_version_ = GetParam().negotiated_version;
 210     FLAGS_enable_quic_fec = GetParam().use_fec;
 211
 212     VLOG(1) << "Using Configuration: " << GetParam();
 213
 214     // Use different flow control windows for client/server.
 215     client_config_.SetInitialStreamFlowControlWindowToSend(
 216         2 * kInitialStreamFlowControlWindowForTest);
 217     client_config_.SetInitialSessionFlowControlWindowToSend(
 218         2 * kInitialSessionFlowControlWindowForTest);
 219     server_config_.SetInitialStreamFlowControlWindowToSend(
 220         3 * kInitialStreamFlowControlWindowForTest);
 221     server_config_.SetInitialSessionFlowControlWindowToSend(
 222         3 * kInitialSessionFlowControlWindowForTest);
 223
 224     QuicInMemoryCachePeer::ResetForTests();
 225     AddToCache("/foo", 200, "OK", kFooResponseBody);
 226     AddToCache("/bar", 200, "OK", kBarResponseBody);
 227   }
 228
 229   ~EndToEndTest() override {
 230     // TODO(rtenneti): port RecycleUnusedPort if needed.
 231     // RecycleUnusedPort(server_address_.port());
 232     QuicInMemoryCachePeer::ResetForTests();
 233   }
 234
 235   QuicTestClient* CreateQuicClient(QuicPacketWriterWrapper* writer) {
 236     QuicTestClient* client = new QuicTestClient(
 237         server_address_,
 238         server_hostname_,
 239         false,  // not secure
 240         client_config_,
 241         client_supported_versions_);
 242     client->UseWriter(writer);
 243     client->Connect();
 244     return client;
 245   }
 246
 247   void set_client_initial_stream_flow_control_receive_window(uint32 window) {
 248     CHECK(client_.get() == nullptr);
 249     DVLOG(1) << "Setting client initial stream flow control window: " << window;
 250     client_config_.SetInitialStreamFlowControlWindowToSend(window);
 251   }
 252
 253   void set_client_initial_session_flow_control_receive_window(uint32 window) {
 254     CHECK(client_.get() == nullptr);
 255     DVLOG(1) << "Setting client initial session flow control window: "
 256              << window;
 257     client_config_.SetInitialSessionFlowControlWindowToSend(window);
 258   }
 259
 260   void set_server_initial_stream_flow_control_receive_window(uint32 window) {
 261     CHECK(server_thread_.get() == nullptr);
 262     DVLOG(1) << "Setting server initial stream flow control window: "
 263              << window;
 264     server_config_.SetInitialStreamFlowControlWindowToSend(window);
 265   }
 266
 267   void set_server_initial_session_flow_control_receive_window(uint32 window) {
 268     CHECK(server_thread_.get() == nullptr);
 269     DVLOG(1) << "Setting server initial session flow control window: "
 270              << window;
 271     server_config_.SetInitialSessionFlowControlWindowToSend(window);
 272   }
 273
 274   const QuicSentPacketManager *
 275   GetSentPacketManagerFromFirstServerSession() const {
 276     QuicDispatcher* dispatcher =
 277         QuicServerPeer::GetDispatcher(server_thread_->server());
 278     QuicSession* session = dispatcher->session_map().begin()->second;
 279     return &session->connection()->sent_packet_manager();
 280   }
 281
 282   bool Initialize() {
 283     QuicTagVector copt;
 284     server_config_.SetConnectionOptionsToSend(copt);
 285
 286     // TODO(nimia): Consider setting the congestion control algorithm for the
 287     // client as well according to the test parameter.
 288     copt.push_back(GetParam().congestion_control_tag);
 289
 290     if (GetParam().use_fec) {
 291       // Set FEC config in client's connection options and in client session.
 292       copt.push_back(kFHDR);
 293     }
 294
 295     client_config_.SetConnectionOptionsToSend(copt);
 296
 297     // Start the server first, because CreateQuicClient() attempts
 298     // to connect to the server.
 299     StartServer();
 300     client_.reset(CreateQuicClient(client_writer_));
 301     if (GetParam().use_fec) {
 302       // Set FecPolicy to always protect data on all streams.
 303       client_->SetFecPolicy(FEC_PROTECT_ALWAYS);
 304     }
 305     static EpollEvent event(EPOLLOUT, false);
 306     client_writer_->Initialize(
 307         reinterpret_cast<QuicEpollConnectionHelper*>(
 308             QuicConnectionPeer::GetHelper(
 309                 client_->client()->session()->connection())),
 310         new ClientDelegate(client_->client()));
 311     return client_->client()->connected();
 312   }
 313
 314   void SetUp() override {
 315     // The ownership of these gets transferred to the QuicPacketWriterWrapper
 316     // and TestWriterFactory when Initialize() is executed.
 317     client_writer_ = new PacketDroppingTestWriter();
 318     server_writer_ = new PacketDroppingTestWriter();
 319   }
 320
 321   void TearDown() override { StopServer(); }
 322
 323   void StartServer() {
 324     server_thread_.reset(
 325         new ServerThread(
 326             new QuicServer(server_config_, server_supported_versions_),
 327             server_address_,
 328             strike_register_no_startup_period_));
 329     server_thread_->Initialize();
 330     server_address_ = IPEndPoint(server_address_.address(),
 331                                  server_thread_->GetPort());
 332     QuicDispatcher* dispatcher =
 333         QuicServerPeer::GetDispatcher(server_thread_->server());
 334     TestWriterFactory* packet_writer_factory = new TestWriterFactory();
 335     QuicDispatcherPeer::SetPacketWriterFactory(dispatcher,
 336                                                packet_writer_factory);
 337     QuicDispatcherPeer::UseWriter(dispatcher, server_writer_);
 338     server_writer_->Initialize(
 339         QuicDispatcherPeer::GetHelper(dispatcher),
 340         new ServerDelegate(packet_writer_factory, dispatcher));
 341     server_thread_->Start();
 342     server_started_ = true;
 343   }
 344
 345   void StopServer() {
 346     if (!server_started_)
 347       return;
 348     if (server_thread_.get()) {
 349       server_thread_->Quit();
 350       server_thread_->Join();
 351     }
 352   }
 353
 354   void AddToCache(StringPiece path,
 355                   int response_code,
 356                   StringPiece response_detail,
 357                   StringPiece body) {
 358     QuicInMemoryCache::GetInstance()->AddSimpleResponse(
 359         "www.google.com", path, response_code, response_detail, body);
 360   }
 361
 362   void SetPacketLossPercentage(int32 loss) {
 363     // TODO(rtenneti): enable when we can do random packet loss tests in
 364     // chrome's tree.
 365     if (loss != 0 && loss != 100)
 366       return;
 367     client_writer_->set_fake_packet_loss_percentage(loss);
 368     server_writer_->set_fake_packet_loss_percentage(loss);
 369   }
 370
 371   void SetPacketSendDelay(QuicTime::Delta delay) {
 372     // TODO(rtenneti): enable when we can do random packet send delay tests in
 373     // chrome's tree.
 374     // client_writer_->set_fake_packet_delay(delay);
 375     // server_writer_->set_fake_packet_delay(delay);
 376   }
 377
 378   void SetReorderPercentage(int32 reorder) {
 379     // TODO(rtenneti): enable when we can do random packet reorder tests in
 380     // chrome's tree.
 381     // client_writer_->set_fake_reorder_percentage(reorder);
 382     // server_writer_->set_fake_reorder_percentage(reorder);
 383   }
 384
 385   // Verifies that the client and server connections were both free of packets
 386   // being discarded, based on connection stats.
 387   // Calls server_thread_ Pause() and Resume(), which may only be called once
 388   // per test.
 389   void VerifyCleanConnection(bool had_packet_loss) {
 390     QuicConnectionStats client_stats =
 391         client_->client()->session()->connection()->GetStats();
 392     // TODO(ianswett): Re-enable this check once b/19572432 is fixed.
 393     // if (!had_packet_loss) {
 394     //   EXPECT_EQ(0u, client_stats.packets_lost);
 395     // }
 396     EXPECT_EQ(0u, client_stats.packets_discarded);
 397     EXPECT_EQ(0u, client_stats.packets_dropped);
 398     EXPECT_EQ(client_stats.packets_received, client_stats.packets_processed);
 399
 400     server_thread_->Pause();
 401     QuicDispatcher* dispatcher =
 402         QuicServerPeer::GetDispatcher(server_thread_->server());
 403     ASSERT_EQ(1u, dispatcher->session_map().size());
 404     QuicSession* session = dispatcher->session_map().begin()->second;
 405     QuicConnectionStats server_stats = session->connection()->GetStats();
 406     // TODO(ianswett): Re-enable this check once b/19572432 is fixed.
 407     // if (!had_packet_loss) {
 408     //   EXPECT_EQ(0u, server_stats.packets_lost);
 409     // }
 410     EXPECT_EQ(0u, server_stats.packets_discarded);
 411     // TODO(ianswett): Restore the check for packets_dropped equals 0.
 412     // The expect for packets received is equal to packets processed fails
 413     // due to version negotiation packets.
 414     server_thread_->Resume();
 415   }
 416
 417   IPEndPoint server_address_;
 418   string server_hostname_;
 419   scoped_ptr<ServerThread> server_thread_;
 420   scoped_ptr<QuicTestClient> client_;
 421   PacketDroppingTestWriter* client_writer_;
 422   PacketDroppingTestWriter* server_writer_;
 423   bool server_started_;
 424   QuicConfig client_config_;
 425   QuicConfig server_config_;
 426   QuicVersionVector client_supported_versions_;
 427   QuicVersionVector server_supported_versions_;
 428   QuicVersion negotiated_version_;
 429   bool strike_register_no_startup_period_;
 430 };
 431
 432 // Run all end to end tests with all supported versions.
 433 INSTANTIATE_TEST_CASE_P(EndToEndTests,
 434                         EndToEndTest,
 435                         ::testing::ValuesIn(GetTestParams()));
 436
 437 TEST_P(EndToEndTest, SimpleRequestResponse) {
 438   ASSERT_TRUE(Initialize());
 439
 440   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
 441   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 442 }
 443
 444 // TODO(rch): figure out how to detect missing v6 supprt (like on the linux
 445 // try bots) and selectively disable this test.
 446 TEST_P(EndToEndTest, DISABLED_SimpleRequestResponsev6) {
 447   IPAddressNumber ip;
 448   CHECK(net::ParseIPLiteralToNumber("::1", &ip));
 449   server_address_ = IPEndPoint(ip, server_address_.port());
 450   ASSERT_TRUE(Initialize());
 451
 452   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
 453   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 454 }
 455
 456 TEST_P(EndToEndTest, SeparateFinPacket) {
 457   ASSERT_TRUE(Initialize());
 458
 459   HTTPMessage request(HttpConstants::HTTP_1_1,
 460                       HttpConstants::POST, "/foo");
 461   request.set_has_complete_message(false);
 462
 463   // Send a request in two parts: the request and then an empty packet with FIN.
 464   client_->SendMessage(request);
 465   client_->SendData("", true);
 466   client_->WaitForResponse();
 467   EXPECT_EQ(kFooResponseBody, client_->response_body());
 468   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 469
 470   // Now do the same thing but with a content length.
 471   request.AddBody("foo", true);
 472   client_->SendMessage(request);
 473   client_->SendData("", true);
 474   client_->WaitForResponse();
 475   EXPECT_EQ(kFooResponseBody, client_->response_body());
 476   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 477 }
 478
 479 TEST_P(EndToEndTest, MultipleRequestResponse) {
 480   ASSERT_TRUE(Initialize());
 481
 482   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
 483   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 484   EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest("/bar"));
 485   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 486 }
 487
 488 TEST_P(EndToEndTest, MultipleClients) {
 489   ASSERT_TRUE(Initialize());
 490   scoped_ptr<QuicTestClient> client2(CreateQuicClient(nullptr));
 491
 492   HTTPMessage request(HttpConstants::HTTP_1_1,
 493                       HttpConstants::POST, "/foo");
 494   request.AddHeader("content-length", "3");
 495   request.set_has_complete_message(false);
 496
 497   client_->SendMessage(request);
 498   client2->SendMessage(request);
 499
 500   client_->SendData("bar", true);
 501   client_->WaitForResponse();
 502   EXPECT_EQ(kFooResponseBody, client_->response_body());
 503   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 504
 505   client2->SendData("eep", true);
 506   client2->WaitForResponse();
 507   EXPECT_EQ(kFooResponseBody, client2->response_body());
 508   EXPECT_EQ(200u, client2->response_headers()->parsed_response_code());
 509 }
 510
 511 TEST_P(EndToEndTest, RequestOverMultiplePackets) {
 512   // Send a large enough request to guarantee fragmentation.
 513   string huge_request = "/some/path?query=" + string(kMaxPacketSize, '.');
 514   AddToCache(huge_request, 200, "OK", kBarResponseBody);
 515
 516   ASSERT_TRUE(Initialize());
 517
 518   EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest(huge_request));
 519   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 520 }
 521
 522 TEST_P(EndToEndTest, MultiplePacketsRandomOrder) {
 523   // Send a large enough request to guarantee fragmentation.
 524   string huge_request = "/some/path?query=" + string(kMaxPacketSize, '.');
 525   AddToCache(huge_request, 200, "OK", kBarResponseBody);
 526
 527   ASSERT_TRUE(Initialize());
 528   SetPacketSendDelay(QuicTime::Delta::FromMilliseconds(2));
 529   SetReorderPercentage(50);
 530
 531   EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest(huge_request));
 532   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 533 }
 534
 535 TEST_P(EndToEndTest, PostMissingBytes) {
 536   ASSERT_TRUE(Initialize());
 537
 538   // Add a content length header with no body.
 539   HTTPMessage request(HttpConstants::HTTP_1_1,
 540                       HttpConstants::POST, "/foo");
 541   request.AddHeader("content-length", "3");
 542   request.set_skip_message_validation(true);
 543
 544   // This should be detected as stream fin without complete request,
 545   // triggering an error response.
 546   client_->SendCustomSynchronousRequest(request);
 547   EXPECT_EQ("bad", client_->response_body());
 548   EXPECT_EQ(500u, client_->response_headers()->parsed_response_code());
 549 }
 550
 551 // TODO(rtenneti): DISABLED_LargePostNoPacketLoss seems to be flaky.
 552 // http://crbug.com/297040.
 553 TEST_P(EndToEndTest, DISABLED_LargePostNoPacketLoss) {
 554   ASSERT_TRUE(Initialize());
 555
 556   client_->client()->WaitForCryptoHandshakeConfirmed();
 557
 558   // 1 MB body.
 559   string body;
 560   GenerateBody(&body, 1024 * 1024);
 561
 562   HTTPMessage request(HttpConstants::HTTP_1_1,
 563                       HttpConstants::POST, "/foo");
 564   request.AddBody(body, true);
 565
 566   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
 567   VerifyCleanConnection(false);
 568 }
 569
 570 TEST_P(EndToEndTest, LargePostNoPacketLoss1sRTT) {
 571   ASSERT_TRUE(Initialize());
 572   SetPacketSendDelay(QuicTime::Delta::FromMilliseconds(1000));
 573
 574   client_->client()->WaitForCryptoHandshakeConfirmed();
 575
 576   // 100 KB body.
 577   string body;
 578   GenerateBody(&body, 100 * 1024);
 579
 580   HTTPMessage request(HttpConstants::HTTP_1_1,
 581                       HttpConstants::POST, "/foo");
 582   request.AddBody(body, true);
 583
 584   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
 585   VerifyCleanConnection(false);
 586 }
 587
 588 TEST_P(EndToEndTest, LargePostWithPacketLoss) {
 589   // Connect with lower fake packet loss than we'd like to test.  Until
 590   // b/10126687 is fixed, losing handshake packets is pretty brutal.
 591   SetPacketLossPercentage(5);
 592   ASSERT_TRUE(Initialize());
 593
 594   // Wait for the server SHLO before upping the packet loss.
 595   client_->client()->WaitForCryptoHandshakeConfirmed();
 596   SetPacketLossPercentage(30);
 597
 598   // 10 KB body.
 599   string body;
 600   GenerateBody(&body, 1024 * 10);
 601
 602   HTTPMessage request(HttpConstants::HTTP_1_1,
 603                       HttpConstants::POST, "/foo");
 604   request.AddBody(body, true);
 605
 606   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
 607   VerifyCleanConnection(true);
 608 }
 609
 610 TEST_P(EndToEndTest, LargePostWithPacketLossAndBlockedSocket) {
 611   // Connect with lower fake packet loss than we'd like to test.  Until
 612   // b/10126687 is fixed, losing handshake packets is pretty brutal.
 613   SetPacketLossPercentage(5);
 614   ASSERT_TRUE(Initialize());
 615
 616   // Wait for the server SHLO before upping the packet loss.
 617   client_->client()->WaitForCryptoHandshakeConfirmed();
 618   SetPacketLossPercentage(10);
 619   client_writer_->set_fake_blocked_socket_percentage(10);
 620
 621   // 10 KB body.
 622   string body;
 623   GenerateBody(&body, 1024 * 10);
 624
 625   HTTPMessage request(HttpConstants::HTTP_1_1,
 626                       HttpConstants::POST, "/foo");
 627   request.AddBody(body, true);
 628
 629   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
 630 }
 631
 632 TEST_P(EndToEndTest, LargePostNoPacketLossWithDelayAndReordering) {
 633   ASSERT_TRUE(Initialize());
 634
 635   client_->client()->WaitForCryptoHandshakeConfirmed();
 636   // Both of these must be called when the writer is not actively used.
 637   SetPacketSendDelay(QuicTime::Delta::FromMilliseconds(2));
 638   SetReorderPercentage(30);
 639
 640   // 1 MB body.
 641   string body;
 642   GenerateBody(&body, 1024 * 1024);
 643
 644   HTTPMessage request(HttpConstants::HTTP_1_1,
 645                       HttpConstants::POST, "/foo");
 646   request.AddBody(body, true);
 647
 648   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
 649 }
 650
 651 TEST_P(EndToEndTest, LargePostZeroRTTFailure) {
 652   // Have the server accept 0-RTT without waiting a startup period.
 653   strike_register_no_startup_period_ = true;
 654
 655   // Send a request and then disconnect. This prepares the client to attempt
 656   // a 0-RTT handshake for the next request.
 657   ASSERT_TRUE(Initialize());
 658
 659   string body;
 660   GenerateBody(&body, 20480);
 661
 662   HTTPMessage request(HttpConstants::HTTP_1_1, HttpConstants::POST, "/foo");
 663   request.AddBody(body, true);
 664
 665   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
 666   EXPECT_EQ(2, client_->client()->session()->GetNumSentClientHellos());
 667
 668   client_->Disconnect();
 669
 670   // The 0-RTT handshake should succeed.
 671   client_->Connect();
 672   client_->WaitForResponseForMs(-1);
 673   ASSERT_TRUE(client_->client()->connected());
 674   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
 675   EXPECT_EQ(1, client_->client()->session()->GetNumSentClientHellos());
 676
 677   client_->Disconnect();
 678
 679   // Restart the server so that the 0-RTT handshake will take 1 RTT.
 680   StopServer();
 681   server_writer_ = new PacketDroppingTestWriter();
 682   StartServer();
 683
 684   client_->Connect();
 685   ASSERT_TRUE(client_->client()->connected());
 686   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
 687   EXPECT_EQ(2, client_->client()->session()->GetNumSentClientHellos());
 688   VerifyCleanConnection(false);
 689 }
 690
 691 TEST_P(EndToEndTest, CorrectlyConfiguredFec) {
 692   ASSERT_TRUE(Initialize());
 693   client_->client()->WaitForCryptoHandshakeConfirmed();
 694   server_thread_->WaitForCryptoHandshakeConfirmed();
 695
 696   FecPolicy expected_policy =
 697       GetParam().use_fec ? FEC_PROTECT_ALWAYS : FEC_PROTECT_OPTIONAL;
 698
 699   // Verify that server's FEC configuration is correct.
 700   server_thread_->Pause();
 701   QuicDispatcher* dispatcher =
 702       QuicServerPeer::GetDispatcher(server_thread_->server());
 703   ASSERT_EQ(1u, dispatcher->session_map().size());
 704   QuicSpdySession* session = dispatcher->session_map().begin()->second;
 705   EXPECT_EQ(expected_policy,
 706             QuicSpdySessionPeer::GetHeadersStream(session)->fec_policy());
 707   server_thread_->Resume();
 708
 709   // Verify that client's FEC configuration is correct.
 710   EXPECT_EQ(expected_policy, QuicSpdySessionPeer::GetHeadersStream(
 711                                  client_->client()->session())->fec_policy());
 712   EXPECT_EQ(expected_policy,
 713             client_->GetOrCreateStream()->fec_policy());
 714 }
 715
 716 TEST_P(EndToEndTest, LargePostSmallBandwidthLargeBuffer) {
 717   ASSERT_TRUE(Initialize());
 718   SetPacketSendDelay(QuicTime::Delta::FromMicroseconds(1));
 719   // 256KB per second with a 256KB buffer from server to client.  Wireless
 720   // clients commonly have larger buffers, but our max CWND is 200.
 721   server_writer_->set_max_bandwidth_and_buffer_size(
 722       QuicBandwidth::FromBytesPerSecond(256 * 1024), 256 * 1024);
 723
 724   client_->client()->WaitForCryptoHandshakeConfirmed();
 725
 726   // 1 MB body.
 727   string body;
 728   GenerateBody(&body, 1024 * 1024);
 729
 730   HTTPMessage request(HttpConstants::HTTP_1_1, HttpConstants::POST, "/foo");
 731   request.AddBody(body, true);
 732
 733   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
 734   // This connection will not drop packets, because the buffer size is larger
 735   // than the default receive window.
 736   VerifyCleanConnection(false);
 737 }
 738
 739 TEST_P(EndToEndTest, DoNotSetResumeWriteAlarmIfConnectionFlowControlBlocked) {
 740   // Regression test for b/14677858.
 741   // Test that the resume write alarm is not set in QuicConnection::OnCanWrite
 742   // if currently connection level flow control blocked. If set, this results in
 743   // an infinite loop in the EpollServer, as the alarm fires and is immediately
 744   // rescheduled.
 745   ASSERT_TRUE(Initialize());
 746   client_->client()->WaitForCryptoHandshakeConfirmed();
 747
 748   // Ensure both stream and connection level are flow control blocked by setting
 749   // the send window offset to 0.
 750   const uint64 flow_control_window =
 751       server_config_.GetInitialStreamFlowControlWindowToSend();
 752   QuicSpdyClientStream* stream = client_->GetOrCreateStream();
 753   QuicSession* session = client_->client()->session();
 754   QuicFlowControllerPeer::SetSendWindowOffset(stream->flow_controller(), 0);
 755   QuicFlowControllerPeer::SetSendWindowOffset(session->flow_controller(), 0);
 756   EXPECT_TRUE(stream->flow_controller()->IsBlocked());
 757   EXPECT_TRUE(session->flow_controller()->IsBlocked());
 758
 759   // Make sure that the stream has data pending so that it will be marked as
 760   // write blocked when it receives a stream level WINDOW_UPDATE.
 761   stream->SendBody("hello", false);
 762
 763   // The stream now attempts to write, fails because it is still connection
 764   // level flow control blocked, and is added to the write blocked list.
 765   QuicWindowUpdateFrame window_update(stream->id(), 2 * flow_control_window);
 766   stream->OnWindowUpdateFrame(window_update);
 767
 768   // Prior to fixing b/14677858 this call would result in an infinite loop in
 769   // Chromium. As a proxy for detecting this, we now check whether the
 770   // resume_writes_alarm is set after OnCanWrite. It should not be, as the
 771   // connection is still flow control blocked.
 772   session->connection()->OnCanWrite();
 773
 774   QuicAlarm* resume_writes_alarm =
 775       QuicConnectionPeer::GetResumeWritesAlarm(session->connection());
 776   EXPECT_FALSE(resume_writes_alarm->IsSet());
 777 }
 778
 779 TEST_P(EndToEndTest, InvalidStream) {
 780   ASSERT_TRUE(Initialize());
 781   client_->client()->WaitForCryptoHandshakeConfirmed();
 782
 783   string body;
 784   GenerateBody(&body, kMaxPacketSize);
 785
 786   HTTPMessage request(HttpConstants::HTTP_1_1, HttpConstants::POST, "/foo");
 787   request.AddBody(body, true);
 788   // Force the client to write with a stream ID belonging to a nonexistent
 789   // server-side stream.
 790   QuicSessionPeer::SetNextStreamId(client_->client()->session(), 2);
 791
 792   client_->SendCustomSynchronousRequest(request);
 793   // EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
 794   EXPECT_EQ(QUIC_PACKET_FOR_NONEXISTENT_STREAM, client_->connection_error());
 795 }
 796
 797 // TODO(rch): this test seems to cause net_unittests timeouts :|
 798 TEST_P(EndToEndTest, DISABLED_MultipleTermination) {
 799   ASSERT_TRUE(Initialize());
 800
 801   HTTPMessage request(HttpConstants::HTTP_1_1,
 802                       HttpConstants::POST, "/foo");
 803   request.AddHeader("content-length", "3");
 804   request.set_has_complete_message(false);
 805
 806   // Set the offset so we won't frame.  Otherwise when we pick up termination
 807   // before HTTP framing is complete, we send an error and close the stream,
 808   // and the second write is picked up as writing on a closed stream.
 809   QuicSpdyClientStream* stream = client_->GetOrCreateStream();
 810   ASSERT_TRUE(stream != nullptr);
 811   ReliableQuicStreamPeer::SetStreamBytesWritten(3, stream);
 812
 813   client_->SendData("bar", true);
 814   client_->WaitForWriteToFlush();
 815
 816   // By default the stream protects itself from writes after terminte is set.
 817   // Override this to test the server handling buggy clients.
 818   ReliableQuicStreamPeer::SetWriteSideClosed(
 819       false, client_->GetOrCreateStream());
 820
 821   EXPECT_DFATAL(client_->SendData("eep", true), "Fin already buffered");
 822 }
 823
 824 TEST_P(EndToEndTest, Timeout) {
 825   client_config_.SetIdleConnectionStateLifetime(
 826       QuicTime::Delta::FromMicroseconds(500),
 827       QuicTime::Delta::FromMicroseconds(500));
 828   // Note: we do NOT ASSERT_TRUE: we may time out during initial handshake:
 829   // that's enough to validate timeout in this case.
 830   Initialize();
 831   while (client_->client()->connected()) {
 832     client_->client()->WaitForEvents();
 833   }
 834 }
 835
 836 TEST_P(EndToEndTest, NegotiateMaxOpenStreams) {
 837   // Negotiate 1 max open stream.
 838   client_config_.SetMaxStreamsPerConnection(1, 1);
 839   ASSERT_TRUE(Initialize());
 840   client_->client()->WaitForCryptoHandshakeConfirmed();
 841
 842   // Make the client misbehave after negotiation.
 843   const int kServerMaxStreams = kMaxStreamsMinimumIncrement + 1;
 844   QuicSessionPeer::SetMaxOpenStreams(client_->client()->session(),
 845                                      kServerMaxStreams + 1);
 846
 847   HTTPMessage request(HttpConstants::HTTP_1_1, HttpConstants::POST, "/foo");
 848   request.AddHeader("content-length", "3");
 849   request.set_has_complete_message(false);
 850
 851   // The server supports a small number of additional streams beyond the
 852   // negotiated limit. Open enough streams to go beyond that limit.
 853   for (int i = 0; i < kServerMaxStreams + 1; ++i) {
 854     client_->SendMessage(request);
 855   }
 856   client_->WaitForResponse();
 857
 858   EXPECT_FALSE(client_->connected());
 859   EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
 860   EXPECT_EQ(QUIC_TOO_MANY_OPEN_STREAMS, client_->connection_error());
 861 }
 862
 863 TEST_P(EndToEndTest, NegotiateCongestionControl) {
 864   ValueRestore<bool> old_flag(&FLAGS_quic_allow_bbr, true);
 865   ASSERT_TRUE(Initialize());
 866   client_->client()->WaitForCryptoHandshakeConfirmed();
 867
 868   CongestionControlType expected_congestion_control_type = kReno;
 869   switch (GetParam().congestion_control_tag) {
 870     case kRENO:
 871       expected_congestion_control_type = kReno;
 872       break;
 873     case kTBBR:
 874       expected_congestion_control_type = kBBR;
 875       break;
 876     case kQBIC:
 877       expected_congestion_control_type = kCubic;
 878       break;
 879     default:
 880       DLOG(FATAL) << "Unexpected congestion control tag";
 881   }
 882
 883   EXPECT_EQ(expected_congestion_control_type,
 884             QuicSentPacketManagerPeer::GetSendAlgorithm(
 885                 *GetSentPacketManagerFromFirstServerSession())
 886             ->GetCongestionControlType());
 887 }
 888
 889 TEST_P(EndToEndTest, LimitMaxOpenStreams) {
 890   // Server limits the number of max streams to 2.
 891   server_config_.SetMaxStreamsPerConnection(2, 2);
 892   // Client tries to negotiate for 10.
 893   client_config_.SetMaxStreamsPerConnection(10, 5);
 894
 895   ASSERT_TRUE(Initialize());
 896   client_->client()->WaitForCryptoHandshakeConfirmed();
 897   QuicConfig* client_negotiated_config = client_->client()->session()->config();
 898   EXPECT_EQ(2u, client_negotiated_config->MaxStreamsPerConnection());
 899 }
 900
 901 TEST_P(EndToEndTest, ClientSuggestsRTT) {
 902   // Client suggests initial RTT, verify it is used.
 903   const uint32 kInitialRTT = 20000;
 904   client_config_.SetInitialRoundTripTimeUsToSend(kInitialRTT);
 905
 906   ASSERT_TRUE(Initialize());
 907   client_->client()->WaitForCryptoHandshakeConfirmed();
 908   server_thread_->WaitForCryptoHandshakeConfirmed();
 909
 910   // Pause the server so we can access the server's internals without races.
 911   server_thread_->Pause();
 912   QuicDispatcher* dispatcher =
 913       QuicServerPeer::GetDispatcher(server_thread_->server());
 914   ASSERT_EQ(1u, dispatcher->session_map().size());
 915   const QuicSentPacketManager& client_sent_packet_manager =
 916       client_->client()->session()->connection()->sent_packet_manager();
 917   const QuicSentPacketManager& server_sent_packet_manager =
 918       *GetSentPacketManagerFromFirstServerSession();
 919
 920   EXPECT_EQ(kInitialRTT,
 921             client_sent_packet_manager.GetRttStats()->initial_rtt_us());
 922   EXPECT_EQ(kInitialRTT,
 923             server_sent_packet_manager.GetRttStats()->initial_rtt_us());
 924   server_thread_->Resume();
 925 }
 926
 927 TEST_P(EndToEndTest, MaxInitialRTT) {
 928   // Client tries to suggest twice the server's max initial rtt and the server
 929   // uses the max.
 930   client_config_.SetInitialRoundTripTimeUsToSend(
 931       2 * kMaxInitialRoundTripTimeUs);
 932
 933   ASSERT_TRUE(Initialize());
 934   client_->client()->WaitForCryptoHandshakeConfirmed();
 935   server_thread_->WaitForCryptoHandshakeConfirmed();
 936
 937   // Pause the server so we can access the server's internals without races.
 938   server_thread_->Pause();
 939   QuicDispatcher* dispatcher =
 940       QuicServerPeer::GetDispatcher(server_thread_->server());
 941   ASSERT_EQ(1u, dispatcher->session_map().size());
 942   QuicSession* session = dispatcher->session_map().begin()->second;
 943   const QuicSentPacketManager& client_sent_packet_manager =
 944       client_->client()->session()->connection()->sent_packet_manager();
 945
 946   // Now that acks have been exchanged, the RTT estimate has decreased on the
 947   // server and is not infinite on the client.
 948   EXPECT_FALSE(
 949       client_sent_packet_manager.GetRttStats()->smoothed_rtt().IsInfinite());
 950   const RttStats& server_rtt_stats =
 951       *session->connection()->sent_packet_manager().GetRttStats();
 952   EXPECT_EQ(static_cast<int64>(kMaxInitialRoundTripTimeUs),
 953             server_rtt_stats.initial_rtt_us());
 954   EXPECT_GE(static_cast<int64>(kMaxInitialRoundTripTimeUs),
 955             server_rtt_stats.smoothed_rtt().ToMicroseconds());
 956   server_thread_->Resume();
 957 }
 958
 959 TEST_P(EndToEndTest, MinInitialRTT) {
 960   // Client tries to suggest 0 and the server uses the default.
 961   client_config_.SetInitialRoundTripTimeUsToSend(0);
 962
 963   ASSERT_TRUE(Initialize());
 964   client_->client()->WaitForCryptoHandshakeConfirmed();
 965   server_thread_->WaitForCryptoHandshakeConfirmed();
 966
 967   // Pause the server so we can access the server's internals without races.
 968   server_thread_->Pause();
 969   QuicDispatcher* dispatcher =
 970       QuicServerPeer::GetDispatcher(server_thread_->server());
 971   ASSERT_EQ(1u, dispatcher->session_map().size());
 972   QuicSession* session = dispatcher->session_map().begin()->second;
 973   const QuicSentPacketManager& client_sent_packet_manager =
 974       client_->client()->session()->connection()->sent_packet_manager();
 975   const QuicSentPacketManager& server_sent_packet_manager =
 976       session->connection()->sent_packet_manager();
 977
 978   // Now that acks have been exchanged, the RTT estimate has decreased on the
 979   // server and is not infinite on the client.
 980   EXPECT_FALSE(
 981       client_sent_packet_manager.GetRttStats()->smoothed_rtt().IsInfinite());
 982   // Expect the default rtt of 100ms.
 983   EXPECT_EQ(static_cast<int64>(100 * kNumMicrosPerMilli),
 984             server_sent_packet_manager.GetRttStats()->initial_rtt_us());
 985   // Ensure the bandwidth is valid.
 986   client_sent_packet_manager.BandwidthEstimate();
 987   server_sent_packet_manager.BandwidthEstimate();
 988   server_thread_->Resume();
 989 }
 990
 991 TEST_P(EndToEndTest, 0ByteConnectionId) {
 992   client_config_.SetBytesForConnectionIdToSend(0);
 993   ASSERT_TRUE(Initialize());
 994
 995   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
 996   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 997
 998   QuicPacketHeader* header = QuicConnectionPeer::GetLastHeader(
 999       client_->client()->session()->connection());
1000   EXPECT_EQ(PACKET_0BYTE_CONNECTION_ID,
1001             header->public_header.connection_id_length);
1002 }
1003
1004 TEST_P(EndToEndTest, 1ByteConnectionId) {
1005   client_config_.SetBytesForConnectionIdToSend(1);
1006   ASSERT_TRUE(Initialize());
1007
1008   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
1009   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
1010   QuicPacketHeader* header = QuicConnectionPeer::GetLastHeader(
1011       client_->client()->session()->connection());
1012   EXPECT_EQ(PACKET_1BYTE_CONNECTION_ID,
1013             header->public_header.connection_id_length);
1014 }
1015
1016 TEST_P(EndToEndTest, 4ByteConnectionId) {
1017   client_config_.SetBytesForConnectionIdToSend(4);
1018   ASSERT_TRUE(Initialize());
1019
1020   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
1021   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
1022   QuicPacketHeader* header = QuicConnectionPeer::GetLastHeader(
1023       client_->client()->session()->connection());
1024   EXPECT_EQ(PACKET_4BYTE_CONNECTION_ID,
1025             header->public_header.connection_id_length);
1026 }
1027
1028 TEST_P(EndToEndTest, 8ByteConnectionId) {
1029   client_config_.SetBytesForConnectionIdToSend(8);
1030   ASSERT_TRUE(Initialize());
1031
1032   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
1033   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
1034   QuicPacketHeader* header = QuicConnectionPeer::GetLastHeader(
1035       client_->client()->session()->connection());
1036   EXPECT_EQ(PACKET_8BYTE_CONNECTION_ID,
1037             header->public_header.connection_id_length);
1038 }
1039
1040 TEST_P(EndToEndTest, 15ByteConnectionId) {
1041   client_config_.SetBytesForConnectionIdToSend(15);
1042   ASSERT_TRUE(Initialize());
1043
1044   // Our server is permissive and allows for out of bounds values.
1045   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
1046   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
1047   QuicPacketHeader* header = QuicConnectionPeer::GetLastHeader(
1048       client_->client()->session()->connection());
1049   EXPECT_EQ(PACKET_8BYTE_CONNECTION_ID,
1050             header->public_header.connection_id_length);
1051 }
1052
1053 TEST_P(EndToEndTest, ResetConnection) {
1054   ASSERT_TRUE(Initialize());
1055   client_->client()->WaitForCryptoHandshakeConfirmed();
1056
1057   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
1058   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
1059   client_->ResetConnection();
1060   EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest("/bar"));
1061   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
1062 }
1063
1064 TEST_P(EndToEndTest, MaxStreamsUberTest) {
1065   SetPacketLossPercentage(1);
1066   ASSERT_TRUE(Initialize());
1067   string large_body;
1068   GenerateBody(&large_body, 10240);
1069   int max_streams = 100;
1070
1071   AddToCache("/large_response", 200, "OK", large_body);;
1072
1073   client_->client()->WaitForCryptoHandshakeConfirmed();
1074   SetPacketLossPercentage(10);
1075
1076   for (int i = 0; i < max_streams; ++i) {
1077     EXPECT_LT(0, client_->SendRequest("/large_response"));
1078   }
1079
1080   // WaitForEvents waits 50ms and returns true if there are outstanding
1081   // requests.
1082   while (client_->client()->WaitForEvents() == true) {
1083   }
1084 }
1085
1086 TEST_P(EndToEndTest, StreamCancelErrorTest) {
1087   ASSERT_TRUE(Initialize());
1088   string small_body;
1089   GenerateBody(&small_body, 256);
1090
1091   AddToCache("/small_response", 200, "OK", small_body);
1092
1093   client_->client()->WaitForCryptoHandshakeConfirmed();
1094
1095   QuicSession* session = client_->client()->session();
1096   // Lose the request.
1097   SetPacketLossPercentage(100);
1098   EXPECT_LT(0, client_->SendRequest("/small_response"));
1099   client_->client()->WaitForEvents();
1100   // Transmit the cancel, and ensure the connection is torn down properly.
1101   SetPacketLossPercentage(0);
1102   QuicStreamId stream_id = kClientDataStreamId1;
1103   session->SendRstStream(stream_id, QUIC_STREAM_CANCELLED, 0);
1104
1105   // WaitForEvents waits 50ms and returns true if there are outstanding
1106   // requests.
1107   while (client_->client()->WaitForEvents() == true) {
1108   }
1109   // It should be completely fine to RST a stream before any data has been
1110   // received for that stream.
1111   EXPECT_EQ(QUIC_NO_ERROR, client_->connection_error());
1112 }
1113
1114 class WrongAddressWriter : public QuicPacketWriterWrapper {
1115  public:
1116   WrongAddressWriter() {
1117     IPAddressNumber ip;
1118     CHECK(net::ParseIPLiteralToNumber("127.0.0.2", &ip));
1119     self_address_ = IPEndPoint(ip, 0);
1120   }
1121
1122   WriteResult WritePacket(const char* buffer,
1123                           size_t buf_len,
1124                           const IPAddressNumber& real_self_address,
1125                           const IPEndPoint& peer_address) override {
1126     // Use wrong address!
1127     return QuicPacketWriterWrapper::WritePacket(
1128         buffer, buf_len, self_address_.address(), peer_address);
1129   }
1130
1131   bool IsWriteBlockedDataBuffered() const override { return false; }
1132
1133   IPEndPoint self_address_;
1134 };
1135
1136 TEST_P(EndToEndTest, ConnectionMigrationClientIPChanged) {
1137   // Tests that the client's IP can not change during an established QUIC
1138   // connection. If it changes, the connection is closed by the server as we do
1139   // not yet support IP migration.
1140   ASSERT_TRUE(Initialize());
1141
1142   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
1143   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
1144
1145   WrongAddressWriter* writer = new WrongAddressWriter();
1146
1147   writer->set_writer(new QuicDefaultPacketWriter(client_->client()->fd()));
1148   QuicConnectionPeer::SetWriter(client_->client()->session()->connection(),
1149                                 writer,
1150                                 /* owns_writer= */ true);
1151
1152   client_->SendSynchronousRequest("/bar");
1153
1154   EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
1155   EXPECT_EQ(QUIC_ERROR_MIGRATING_ADDRESS, client_->connection_error());
1156 }
1157
1158 TEST_P(EndToEndTest, ConnectionMigrationClientPortChanged) {
1159   // Tests that the client's port can change during an established QUIC
1160   // connection, and that doing so does not result in the connection being
1161   // closed by the server.
1162   ASSERT_TRUE(Initialize());
1163
1164   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
1165   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
1166
1167   // Store the client address which was used to send the first request.
1168   IPEndPoint old_address = client_->client()->client_address();
1169
1170   // Stop listening on the old FD.
1171   EpollServer* eps = client_->epoll_server();
1172   int old_fd = client_->client()->fd();
1173   eps->UnregisterFD(old_fd);
1174   // Create a new socket before closing the old one, which will result in a new
1175   // ephemeral port.
1176   QuicClientPeer::CreateUDPSocket(client_->client());
1177   close(old_fd);
1178
1179   // The packet writer needs to be updated to use the new FD.
1180   client_->client()->CreateQuicPacketWriter();
1181
1182   // Change the internal state of the client and connection to use the new port,
1183   // this is done because in a real NAT rebinding the client wouldn't see any
1184   // port change, and so expects no change to incoming port.
1185   // This is kind of ugly, but needed as we are simply swapping out the client
1186   // FD rather than any more complex NAT rebinding simulation.
1187   int new_port = client_->client()->client_address().port();
1188   QuicClientPeer::SetClientPort(client_->client(), new_port);
1189   QuicConnectionPeer::SetSelfAddress(
1190       client_->client()->session()->connection(),
1191       IPEndPoint(
1192           client_->client()->session()->connection()->self_address().address(),
1193           new_port));
1194
1195   // Register the new FD for epoll events.
1196   int new_fd = client_->client()->fd();
1197   eps->RegisterFD(new_fd, client_->client(), EPOLLIN | EPOLLOUT | EPOLLET);
1198
1199   // Send a second request, using the new FD.
1200   EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest("/bar"));
1201   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
1202
1203   // Verify that the client's ephemeral port is different.
1204   IPEndPoint new_address = client_->client()->client_address();
1205   EXPECT_EQ(old_address.address(), new_address.address());
1206   EXPECT_NE(old_address.port(), new_address.port());
1207 }
1208
1209 TEST_P(EndToEndTest, DifferentFlowControlWindows) {
1210   // Client and server can set different initial flow control receive windows.
1211   // These are sent in CHLO/SHLO. Tests that these values are exchanged properly
1212   // in the crypto handshake.
1213   const uint32 kClientStreamIFCW = 123456;
1214   const uint32 kClientSessionIFCW = 234567;
1215   set_client_initial_stream_flow_control_receive_window(kClientStreamIFCW);
1216   set_client_initial_session_flow_control_receive_window(kClientSessionIFCW);
1217
1218   const uint32 kServerStreamIFCW = 654321;
1219   const uint32 kServerSessionIFCW = 765432;
1220   set_server_initial_stream_flow_control_receive_window(kServerStreamIFCW);
1221   set_server_initial_session_flow_control_receive_window(kServerSessionIFCW);
1222
1223   ASSERT_TRUE(Initialize());
1224
1225   // Values are exchanged during crypto handshake, so wait for that to finish.
1226   client_->client()->WaitForCryptoHandshakeConfirmed();
1227   server_thread_->WaitForCryptoHandshakeConfirmed();
1228
1229   // Open a data stream to make sure the stream level flow control is updated.
1230   QuicSpdyClientStream* stream = client_->GetOrCreateStream();
1231   stream->SendBody("hello", false);
1232
1233   // Client should have the right values for server's receive window.
1234   EXPECT_EQ(kServerStreamIFCW,
1235             client_->client()
1236                 ->session()
1237                 ->config()
1238                 ->ReceivedInitialStreamFlowControlWindowBytes());
1239   EXPECT_EQ(kServerSessionIFCW,
1240             client_->client()
1241                 ->session()
1242                 ->config()
1243                 ->ReceivedInitialSessionFlowControlWindowBytes());
1244   EXPECT_EQ(kServerStreamIFCW, QuicFlowControllerPeer::SendWindowOffset(
1245                                    stream->flow_controller()));
1246   EXPECT_EQ(kServerSessionIFCW,
1247             QuicFlowControllerPeer::SendWindowOffset(
1248                 client_->client()->session()->flow_controller()));
1249
1250   // Server should have the right values for client's receive window.
1251   server_thread_->Pause();
1252   QuicDispatcher* dispatcher =
1253       QuicServerPeer::GetDispatcher(server_thread_->server());
1254   QuicSession* session = dispatcher->session_map().begin()->second;
1255   EXPECT_EQ(kClientStreamIFCW,
1256             session->config()->ReceivedInitialStreamFlowControlWindowBytes());
1257   EXPECT_EQ(kClientSessionIFCW,
1258             session->config()->ReceivedInitialSessionFlowControlWindowBytes());
1259   EXPECT_EQ(kClientSessionIFCW, QuicFlowControllerPeer::SendWindowOffset(
1260                                     session->flow_controller()));
1261   server_thread_->Resume();
1262 }
1263
1264 TEST_P(EndToEndTest, HeadersAndCryptoStreamsNoConnectionFlowControl) {
1265   // The special headers and crypto streams should be subject to per-stream flow
1266   // control limits, but should not be subject to connection level flow control.
1267   const uint32 kStreamIFCW = 123456;
1268   const uint32 kSessionIFCW = 234567;
1269   set_client_initial_stream_flow_control_receive_window(kStreamIFCW);
1270   set_client_initial_session_flow_control_receive_window(kSessionIFCW);
1271   set_server_initial_stream_flow_control_receive_window(kStreamIFCW);
1272   set_server_initial_session_flow_control_receive_window(kSessionIFCW);
1273
1274   ASSERT_TRUE(Initialize());
1275
1276   // Wait for crypto handshake to finish. This should have contributed to the
1277   // crypto stream flow control window, but not affected the session flow
1278   // control window.
1279   client_->client()->WaitForCryptoHandshakeConfirmed();
1280   server_thread_->WaitForCryptoHandshakeConfirmed();
1281
1282   QuicCryptoStream* crypto_stream =
1283       QuicSessionPeer::GetCryptoStream(client_->client()->session());
1284   EXPECT_LT(
1285       QuicFlowControllerPeer::SendWindowSize(crypto_stream->flow_controller()),
1286       kStreamIFCW);
1287   EXPECT_EQ(kSessionIFCW, QuicFlowControllerPeer::SendWindowSize(
1288                               client_->client()->session()->flow_controller()));
1289
1290   // Send a request with no body, and verify that the connection level window
1291   // has not been affected.
1292   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
1293
1294   QuicHeadersStream* headers_stream =
1295       QuicSpdySessionPeer::GetHeadersStream(client_->client()->session());
1296   EXPECT_LT(
1297       QuicFlowControllerPeer::SendWindowSize(headers_stream->flow_controller()),
1298       kStreamIFCW);
1299   EXPECT_EQ(kSessionIFCW, QuicFlowControllerPeer::SendWindowSize(
1300                               client_->client()->session()->flow_controller()));
1301
1302   // Server should be in a similar state: connection flow control window should
1303   // not have any bytes marked as received.
1304   server_thread_->Pause();
1305   QuicDispatcher* dispatcher =
1306       QuicServerPeer::GetDispatcher(server_thread_->server());
1307   QuicSession* session = dispatcher->session_map().begin()->second;
1308   QuicFlowController* server_connection_flow_controller =
1309       session->flow_controller();
1310   EXPECT_EQ(kSessionIFCW, QuicFlowControllerPeer::ReceiveWindowSize(
1311       server_connection_flow_controller));
1312   server_thread_->Resume();
1313 }
1314
1315 TEST_P(EndToEndTest, RequestWithNoBodyWillNeverSendStreamFrameWithFIN) {
1316   // A stream created on receipt of a simple request with no body will never get
1317   // a stream frame with a FIN. Verify that we don't keep track of the stream in
1318   // the locally closed streams map: it will never be removed if so.
1319   ASSERT_TRUE(Initialize());
1320
1321   // Send a simple headers only request, and receive response.
1322   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
1323   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
1324
1325   // Now verify that the server is not waiting for a final FIN or RST.
1326   server_thread_->Pause();
1327   QuicDispatcher* dispatcher =
1328       QuicServerPeer::GetDispatcher(server_thread_->server());
1329   QuicSession* session = dispatcher->session_map().begin()->second;
1330   EXPECT_EQ(0u, QuicSessionPeer::GetLocallyClosedStreamsHighestOffset(
1331       session).size());
1332   server_thread_->Resume();
1333 }
1334
1335 // A TestAckNotifierDelegate verifies that its OnAckNotification method has been
1336 // called exactly once on destruction.
1337 class TestAckNotifierDelegate : public QuicAckNotifier::DelegateInterface {
1338  public:
1339   TestAckNotifierDelegate() {}
1340
1341   void OnAckNotification(int /*num_retransmitted_packets*/,
1342                          int /*num_retransmitted_bytes*/,
1343                          QuicTime::Delta /*delta_largest_observed*/) override {
1344     ASSERT_FALSE(has_been_notified_);
1345     has_been_notified_ = true;
1346   }
1347
1348   bool has_been_notified() const { return has_been_notified_; }
1349
1350  protected:
1351   // Object is ref counted.
1352   ~TestAckNotifierDelegate() override { EXPECT_TRUE(has_been_notified_); }
1353
1354  private:
1355   bool has_been_notified_ = false;
1356 };
1357
1358 TEST_P(EndToEndTest, AckNotifierWithPacketLossAndBlockedSocket) {
1359   // Verify that even in the presence of packet loss and occasionally blocked
1360   // socket,  an AckNotifierDelegate will get informed that the data it is
1361   // interested in has been ACKed. This tests end-to-end ACK notification, and
1362   // demonstrates that retransmissions do not break this functionality.
1363   SetPacketLossPercentage(5);
1364   ASSERT_TRUE(Initialize());
1365
1366   // Wait for the server SHLO before upping the packet loss.
1367   client_->client()->WaitForCryptoHandshakeConfirmed();
1368   SetPacketLossPercentage(30);
1369   client_writer_->set_fake_blocked_socket_percentage(10);
1370
1371   // Create a POST request and send the headers only.
1372   HTTPMessage request(HttpConstants::HTTP_1_1, HttpConstants::POST, "/foo");
1373   request.set_has_complete_message(false);
1374   client_->SendMessage(request);
1375
1376   // The TestAckNotifierDelegate will cause a failure if not notified.
1377   scoped_refptr<TestAckNotifierDelegate> delegate(new TestAckNotifierDelegate);
1378
1379   // Test the AckNotifier's ability to track multiple packets by making the
1380   // request body exceed the size of a single packet.
1381   string request_string =
1382       "a request body bigger than one packet" + string(kMaxPacketSize, '.');
1383
1384   // Send the request, and register the delegate for ACKs.
1385   client_->SendData(request_string, true, delegate.get());
1386   client_->WaitForResponse();
1387   EXPECT_EQ(kFooResponseBody, client_->response_body());
1388   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
1389
1390   // Send another request to flush out any pending ACKs on the server.
1391   client_->SendSynchronousRequest(request_string);
1392
1393   // Pause the server to avoid races.
1394   server_thread_->Pause();
1395   // Make sure the delegate does get the notification it expects.
1396   while (!delegate->has_been_notified()) {
1397     // Waits for up to 50 ms.
1398     client_->client()->WaitForEvents();
1399   }
1400   server_thread_->Resume();
1401 }
1402
1403 // Send a public reset from the server for a different connection ID.
1404 // It should be ignored.
1405 TEST_P(EndToEndTest, ServerSendPublicResetWithDifferentConnectionId) {
1406   ASSERT_TRUE(Initialize());
1407
1408   // Send the public reset.
1409   QuicConnectionId incorrect_connection_id =
1410       client_->client()->session()->connection()->connection_id() + 1;
1411   QuicPublicResetPacket header;
1412   header.public_header.connection_id = incorrect_connection_id;
1413   header.public_header.reset_flag = true;
1414   header.public_header.version_flag = false;
1415   header.rejected_sequence_number = 10101;
1416   QuicFramer framer(server_supported_versions_, QuicTime::Zero(),
1417                     Perspective::IS_SERVER);
1418   scoped_ptr<QuicEncryptedPacket> packet(framer.BuildPublicResetPacket(header));
1419   testing::NiceMock<MockQuicConnectionDebugVisitor> visitor;
1420   client_->client()->session()->connection()->set_debug_visitor(&visitor);
1421   EXPECT_CALL(visitor, OnIncorrectConnectionId(incorrect_connection_id))
1422       .Times(1);
1423   // We must pause the server's thread in order to call WritePacket without
1424   // race conditions.
1425   server_thread_->Pause();
1426   server_writer_->WritePacket(packet->data(), packet->length(),
1427                               server_address_.address(),
1428                               client_->client()->client_address());
1429   server_thread_->Resume();
1430
1431   // The connection should be unaffected.
1432   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
1433   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
1434
1435   client_->client()->session()->connection()->set_debug_visitor(nullptr);
1436 }
1437
1438 // Send a public reset from the client for a different connection ID.
1439 // It should be ignored.
1440 TEST_P(EndToEndTest, ClientSendPublicResetWithDifferentConnectionId) {
1441   ASSERT_TRUE(Initialize());
1442
1443   // Send the public reset.
1444   QuicConnectionId incorrect_connection_id =
1445       client_->client()->session()->connection()->connection_id() + 1;
1446   QuicPublicResetPacket header;
1447   header.public_header.connection_id = incorrect_connection_id;
1448   header.public_header.reset_flag = true;
1449   header.public_header.version_flag = false;
1450   header.rejected_sequence_number = 10101;
1451   QuicFramer framer(server_supported_versions_, QuicTime::Zero(),
1452                     Perspective::IS_CLIENT);
1453   scoped_ptr<QuicEncryptedPacket> packet(framer.BuildPublicResetPacket(header));
1454   client_writer_->WritePacket(packet->data(), packet->length(),
1455                               client_->client()->client_address().address(),
1456                               server_address_);
1457
1458   // The connection should be unaffected.
1459   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
1460   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
1461 }
1462
1463 // Send a version negotiation packet from the server for a different
1464 // connection ID.  It should be ignored.
1465 TEST_P(EndToEndTest, ServerSendVersionNegotiationWithDifferentConnectionId) {
1466   ASSERT_TRUE(Initialize());
1467
1468   // Send the version negotiation packet.
1469   QuicConnectionId incorrect_connection_id =
1470       client_->client()->session()->connection()->connection_id() + 1;
1471   QuicVersionNegotiationPacket header;
1472   header.connection_id = incorrect_connection_id;
1473   header.reset_flag = true;
1474   header.version_flag = true;
1475   QuicFramer framer(server_supported_versions_, QuicTime::Zero(),
1476                     Perspective::IS_SERVER);
1477   scoped_ptr<QuicEncryptedPacket> packet(
1478       framer.BuildVersionNegotiationPacket(header, server_supported_versions_));
1479   testing::NiceMock<MockQuicConnectionDebugVisitor> visitor;
1480   client_->client()->session()->connection()->set_debug_visitor(&visitor);
1481   EXPECT_CALL(visitor, OnIncorrectConnectionId(incorrect_connection_id))
1482       .Times(1);
1483   // We must pause the server's thread in order to call WritePacket without
1484   // race conditions.
1485   server_thread_->Pause();
1486   server_writer_->WritePacket(packet->data(), packet->length(),
1487                               server_address_.address(),
1488                               client_->client()->client_address());
1489   server_thread_->Resume();
1490
1491   // The connection should be unaffected.
1492   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
1493   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
1494
1495   client_->client()->session()->connection()->set_debug_visitor(nullptr);
1496 }
1497
1498 // A bad header shouldn't tear down the connection, because the receiver can't
1499 // tell the connection ID.
1500 TEST_P(EndToEndTest, BadPacketHeaderTruncated) {
1501   ASSERT_TRUE(Initialize());
1502
1503   // Start the connection.
1504   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
1505   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
1506
1507   // Packet with invalid public flags.
1508   char packet[] = {// public flags (8 byte connection_id)
1509                    0x3C,
1510                    // truncated connection ID
1511                    0x11};
1512   client_writer_->WritePacket(&packet[0], sizeof(packet),
1513                               client_->client()->client_address().address(),
1514                               server_address_);
1515   // Give the server time to process the packet.
1516   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
1517   // Pause the server so we can access the server's internals without races.
1518   server_thread_->Pause();
1519   QuicDispatcher* dispatcher =
1520       QuicServerPeer::GetDispatcher(server_thread_->server());
1521   EXPECT_EQ(QUIC_INVALID_PACKET_HEADER,
1522             QuicDispatcherPeer::GetAndClearLastError(dispatcher));
1523   server_thread_->Resume();
1524
1525   // The connection should not be terminated.
1526   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
1527   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
1528 }
1529
1530 // A bad header shouldn't tear down the connection, because the receiver can't
1531 // tell the connection ID.
1532 TEST_P(EndToEndTest, BadPacketHeaderFlags) {
1533   ASSERT_TRUE(Initialize());
1534
1535   // Start the connection.
1536   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
1537   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
1538
1539   // Packet with invalid public flags.
1540   char packet[] = {
1541       // invalid public flags
1542       0xFF,
1543       // connection_id
1544       0x10,
1545       0x32,
1546       0x54,
1547       0x76,
1548       0x98,
1549       0xBA,
1550       0xDC,
1551       0xFE,
1552       // packet sequence number
1553       0xBC,
1554       0x9A,
1555       0x78,
1556       0x56,
1557       0x34,
1558       0x12,
1559       // private flags
1560       0x00,
1561   };
1562   client_writer_->WritePacket(&packet[0], sizeof(packet),
1563                               client_->client()->client_address().address(),
1564                               server_address_);
1565   // Give the server time to process the packet.
1566   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
1567   // Pause the server so we can access the server's internals without races.
1568   server_thread_->Pause();
1569   QuicDispatcher* dispatcher =
1570       QuicServerPeer::GetDispatcher(server_thread_->server());
1571   EXPECT_EQ(QUIC_INVALID_PACKET_HEADER,
1572             QuicDispatcherPeer::GetAndClearLastError(dispatcher));
1573   server_thread_->Resume();
1574
1575   // The connection should not be terminated.
1576   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
1577   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
1578 }
1579
1580 // Send a packet from the client with bad encrypted data.  The server should not
1581 // tear down the connection.
1582 TEST_P(EndToEndTest, BadEncryptedData) {
1583   ASSERT_TRUE(Initialize());
1584
1585   // Start the connection.
1586   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
1587   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
1588
1589   scoped_ptr<QuicEncryptedPacket> packet(ConstructEncryptedPacket(
1590       client_->client()->session()->connection()->connection_id(), false, false,
1591       1, "At least 20 characters.", PACKET_8BYTE_CONNECTION_ID,
1592       PACKET_6BYTE_SEQUENCE_NUMBER));
1593   // Damage the encrypted data.
1594   string damaged_packet(packet->data(), packet->length());
1595   damaged_packet[30] ^= 0x01;
1596   DVLOG(1) << "Sending bad packet.";
1597   client_writer_->WritePacket(damaged_packet.data(), damaged_packet.length(),
1598                               client_->client()->client_address().address(),
1599                               server_address_);
1600   // Give the server time to process the packet.
1601   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
1602   // This error is sent to the connection's OnError (which ignores it), so the
1603   // dispatcher doesn't see it.
1604   // Pause the server so we can access the server's internals without races.
1605   server_thread_->Pause();
1606   QuicDispatcher* dispatcher =
1607       QuicServerPeer::GetDispatcher(server_thread_->server());
1608   EXPECT_EQ(QUIC_NO_ERROR,
1609             QuicDispatcherPeer::GetAndClearLastError(dispatcher));
1610   server_thread_->Resume();
1611
1612   // The connection should not be terminated.
1613   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
1614   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
1615 }
1616
1617 }  // namespace
1618 }  // namespace test
1619 }  // namespace tools
1620 }  // namespace net