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