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

Side by Side Diff: net/tools/quic/end_to_end_test.cc

Issue 2463093003: Landing Recent QUIC changes until Sat Oct 29 14:59:35. (Closed)
Patch Set: add change to quiartc_session_test.cc Created 4 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « net/quic/test_tools/fake_proof_source.cc ('k') | net/tools/quic/stateless_rejector.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include <stddef.h> 5 #include <stddef.h>
6 #include <sys/epoll.h> 6 #include <sys/epoll.h>
7 7
8 #include <list> 8 #include <list>
9 #include <memory> 9 #include <memory>
10 #include <string> 10 #include <string>
(...skipping 637 matching lines...) Expand 10 before | Expand all | Expand 10 after
648 sequencer = ReliableQuicStreamPeer::sequencer(crypto_stream); 648 sequencer = ReliableQuicStreamPeer::sequencer(crypto_stream);
649 EXPECT_NE(FLAGS_quic_release_crypto_stream_buffer && 649 EXPECT_NE(FLAGS_quic_release_crypto_stream_buffer &&
650 FLAGS_quic_reduce_sequencer_buffer_memory_life_time, 650 FLAGS_quic_reduce_sequencer_buffer_memory_life_time,
651 QuicStreamSequencerPeer::IsUnderlyingBufferAllocated(sequencer)); 651 QuicStreamSequencerPeer::IsUnderlyingBufferAllocated(sequencer));
652 } 652 }
653 653
654 TEST_P(EndToEndTest, SimpleRequestResponse) { 654 TEST_P(EndToEndTest, SimpleRequestResponse) {
655 ASSERT_TRUE(Initialize()); 655 ASSERT_TRUE(Initialize());
656 656
657 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo")); 657 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
658 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 658 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
659 EXPECT_EQ(2, client_->client()->GetNumSentClientHellos()); 659 EXPECT_EQ(2, client_->client()->GetNumSentClientHellos());
660 } 660 }
661 661
662 TEST_P(EndToEndTest, SimpleRequestResponseWithLargeReject) { 662 TEST_P(EndToEndTest, SimpleRequestResponseWithLargeReject) {
663 chlo_multiplier_ = 1; 663 chlo_multiplier_ = 1;
664 ASSERT_TRUE(Initialize()); 664 ASSERT_TRUE(Initialize());
665 665
666 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo")); 666 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
667 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 667 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
668 EXPECT_EQ(3, client_->client()->GetNumSentClientHellos()); 668 EXPECT_EQ(3, client_->client()->GetNumSentClientHellos());
669 } 669 }
670 670
671 // TODO(rch): figure out how to detect missing v6 support (like on the linux 671 // TODO(rch): figure out how to detect missing v6 support (like on the linux
672 // try bots) and selectively disable this test. 672 // try bots) and selectively disable this test.
673 TEST_P(EndToEndTest, DISABLED_SimpleRequestResponsev6) { 673 TEST_P(EndToEndTest, DISABLED_SimpleRequestResponsev6) {
674 server_address_ = 674 server_address_ =
675 IPEndPoint(IPAddress::IPv6Localhost(), server_address_.port()); 675 IPEndPoint(IPAddress::IPv6Localhost(), server_address_.port());
676 ASSERT_TRUE(Initialize()); 676 ASSERT_TRUE(Initialize());
677 677
678 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo")); 678 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
679 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 679 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
680 } 680 }
681 681
682 TEST_P(EndToEndTest, SeparateFinPacket) { 682 TEST_P(EndToEndTest, SeparateFinPacket) {
683 ASSERT_TRUE(Initialize()); 683 ASSERT_TRUE(Initialize());
684 684
685 HTTPMessage request(HttpConstants::HTTP_1_1, HttpConstants::POST, "/foo"); 685 HTTPMessage request(HttpConstants::HTTP_1_1, HttpConstants::POST, "/foo");
686 request.set_has_complete_message(false); 686 request.set_has_complete_message(false);
687 687
688 // Send a request in two parts: the request and then an empty packet with FIN. 688 // Send a request in two parts: the request and then an empty packet with FIN.
689 client_->SendMessage(request); 689 client_->SendMessage(request);
690 client_->SendData("", true); 690 client_->SendData("", true);
691 client_->WaitForResponse(); 691 client_->WaitForResponse();
692 EXPECT_EQ(kFooResponseBody, client_->response_body()); 692 EXPECT_EQ(kFooResponseBody, client_->response_body());
693 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 693 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
694 694
695 // Now do the same thing but with a content length. 695 // Now do the same thing but with a content length.
696 request.AddBody("foo", true); 696 request.AddBody("foo", true);
697 client_->SendMessage(request); 697 client_->SendMessage(request);
698 client_->SendData("", true); 698 client_->SendData("", true);
699 client_->WaitForResponse(); 699 client_->WaitForResponse();
700 EXPECT_EQ(kFooResponseBody, client_->response_body()); 700 EXPECT_EQ(kFooResponseBody, client_->response_body());
701 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 701 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
702 } 702 }
703 703
704 TEST_P(EndToEndTest, MultipleRequestResponse) { 704 TEST_P(EndToEndTest, MultipleRequestResponse) {
705 ASSERT_TRUE(Initialize()); 705 ASSERT_TRUE(Initialize());
706 706
707 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo")); 707 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
708 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 708 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
709 EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest("/bar")); 709 EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest("/bar"));
710 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 710 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
711 } 711 }
712 712
713 TEST_P(EndToEndTest, MultipleClients) { 713 TEST_P(EndToEndTest, MultipleClients) {
714 ASSERT_TRUE(Initialize()); 714 ASSERT_TRUE(Initialize());
715 std::unique_ptr<QuicTestClient> client2(CreateQuicClient(nullptr)); 715 std::unique_ptr<QuicTestClient> client2(CreateQuicClient(nullptr));
716 716
717 HTTPMessage request(HttpConstants::HTTP_1_1, HttpConstants::POST, "/foo"); 717 HTTPMessage request(HttpConstants::HTTP_1_1, HttpConstants::POST, "/foo");
718 request.AddHeader("content-length", "3"); 718 request.AddHeader("content-length", "3");
719 request.set_has_complete_message(false); 719 request.set_has_complete_message(false);
720 720
721 client_->SendMessage(request); 721 client_->SendMessage(request);
722 client2->SendMessage(request); 722 client2->SendMessage(request);
723 723
724 client_->SendData("bar", true); 724 client_->SendData("bar", true);
725 client_->WaitForResponse(); 725 client_->WaitForResponse();
726 EXPECT_EQ(kFooResponseBody, client_->response_body()); 726 EXPECT_EQ(kFooResponseBody, client_->response_body());
727 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 727 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
728 728
729 client2->SendData("eep", true); 729 client2->SendData("eep", true);
730 client2->WaitForResponse(); 730 client2->WaitForResponse();
731 EXPECT_EQ(kFooResponseBody, client2->response_body()); 731 EXPECT_EQ(kFooResponseBody, client2->response_body());
732 EXPECT_EQ(200u, client2->response_headers()->parsed_response_code()); 732 EXPECT_EQ("200", client2->response_headers()->find(":status")->second);
733 } 733 }
734 734
735 TEST_P(EndToEndTest, RequestOverMultiplePackets) { 735 TEST_P(EndToEndTest, RequestOverMultiplePackets) {
736 // Send a large enough request to guarantee fragmentation. 736 // Send a large enough request to guarantee fragmentation.
737 string huge_request = "/some/path?query=" + string(kMaxPacketSize, '.'); 737 string huge_request = "/some/path?query=" + string(kMaxPacketSize, '.');
738 AddToCache(huge_request, 200, kBarResponseBody); 738 AddToCache(huge_request, 200, kBarResponseBody);
739 739
740 ASSERT_TRUE(Initialize()); 740 ASSERT_TRUE(Initialize());
741 741
742 EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest(huge_request)); 742 EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest(huge_request));
743 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 743 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
744 } 744 }
745 745
746 TEST_P(EndToEndTest, MultiplePacketsRandomOrder) { 746 TEST_P(EndToEndTest, MultiplePacketsRandomOrder) {
747 // Send a large enough request to guarantee fragmentation. 747 // Send a large enough request to guarantee fragmentation.
748 string huge_request = "/some/path?query=" + string(kMaxPacketSize, '.'); 748 string huge_request = "/some/path?query=" + string(kMaxPacketSize, '.');
749 AddToCache(huge_request, 200, kBarResponseBody); 749 AddToCache(huge_request, 200, kBarResponseBody);
750 750
751 ASSERT_TRUE(Initialize()); 751 ASSERT_TRUE(Initialize());
752 SetPacketSendDelay(QuicTime::Delta::FromMilliseconds(2)); 752 SetPacketSendDelay(QuicTime::Delta::FromMilliseconds(2));
753 SetReorderPercentage(50); 753 SetReorderPercentage(50);
754 754
755 EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest(huge_request)); 755 EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest(huge_request));
756 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 756 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
757 } 757 }
758 758
759 TEST_P(EndToEndTest, PostMissingBytes) { 759 TEST_P(EndToEndTest, PostMissingBytes) {
760 ASSERT_TRUE(Initialize()); 760 ASSERT_TRUE(Initialize());
761 761
762 // Add a content length header with no body. 762 // Add a content length header with no body.
763 HTTPMessage request(HttpConstants::HTTP_1_1, HttpConstants::POST, "/foo"); 763 HTTPMessage request(HttpConstants::HTTP_1_1, HttpConstants::POST, "/foo");
764 request.AddHeader("content-length", "3"); 764 request.AddHeader("content-length", "3");
765 request.set_skip_message_validation(true); 765 request.set_skip_message_validation(true);
766 766
767 // This should be detected as stream fin without complete request, 767 // This should be detected as stream fin without complete request,
768 // triggering an error response. 768 // triggering an error response.
769 client_->SendCustomSynchronousRequest(request); 769 client_->SendCustomSynchronousRequest(request);
770 EXPECT_EQ(QuicSimpleServerStream::kErrorResponseBody, 770 EXPECT_EQ(QuicSimpleServerStream::kErrorResponseBody,
771 client_->response_body()); 771 client_->response_body());
772 EXPECT_EQ(500u, client_->response_headers()->parsed_response_code()); 772 EXPECT_EQ("500", client_->response_headers()->find(":status")->second);
773 } 773 }
774 774
775 TEST_P(EndToEndTest, LargePostNoPacketLoss) { 775 TEST_P(EndToEndTest, LargePostNoPacketLoss) {
776 ASSERT_TRUE(Initialize()); 776 ASSERT_TRUE(Initialize());
777 777
778 client_->client()->WaitForCryptoHandshakeConfirmed(); 778 client_->client()->WaitForCryptoHandshakeConfirmed();
779 779
780 // 1 MB body. 780 // 1 MB body.
781 string body; 781 string body;
782 GenerateBody(&body, 1024 * 1024); 782 GenerateBody(&body, 1024 * 1024);
(...skipping 412 matching lines...) Expand 10 before | Expand all | Expand 10 after
1195 request.AddHeader("key2", string(15 * 1024, 'a')); 1195 request.AddHeader("key2", string(15 * 1024, 'a'));
1196 request.AddHeader("key3", string(15 * 1024, 'a')); 1196 request.AddHeader("key3", string(15 * 1024, 'a'));
1197 request.AddBody(body, true); 1197 request.AddBody(body, true);
1198 1198
1199 client_->SendCustomSynchronousRequest(request); 1199 client_->SendCustomSynchronousRequest(request);
1200 if (FLAGS_quic_limit_uncompressed_headers) { 1200 if (FLAGS_quic_limit_uncompressed_headers) {
1201 EXPECT_EQ(QUIC_HEADERS_TOO_LARGE, client_->stream_error()); 1201 EXPECT_EQ(QUIC_HEADERS_TOO_LARGE, client_->stream_error());
1202 } else { 1202 } else {
1203 EXPECT_EQ(QUIC_STREAM_NO_ERROR, client_->stream_error()); 1203 EXPECT_EQ(QUIC_STREAM_NO_ERROR, client_->stream_error());
1204 EXPECT_EQ(kFooResponseBody, client_->response_body()); 1204 EXPECT_EQ(kFooResponseBody, client_->response_body());
1205 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 1205 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
1206 } 1206 }
1207 EXPECT_EQ(QUIC_NO_ERROR, client_->connection_error()); 1207 EXPECT_EQ(QUIC_NO_ERROR, client_->connection_error());
1208 } 1208 }
1209 1209
1210 TEST_P(EndToEndTest, EarlyResponseWithQuicStreamNoError) { 1210 TEST_P(EndToEndTest, EarlyResponseWithQuicStreamNoError) {
1211 ASSERT_TRUE(Initialize()); 1211 ASSERT_TRUE(Initialize());
1212 client_->client()->WaitForCryptoHandshakeConfirmed(); 1212 client_->client()->WaitForCryptoHandshakeConfirmed();
1213 1213
1214 string large_body; 1214 string large_body;
1215 GenerateBody(&large_body, 1024 * 1024); 1215 GenerateBody(&large_body, 1024 * 1024);
1216 1216
1217 HTTPMessage request(HttpConstants::HTTP_1_1, HttpConstants::POST, "/foo"); 1217 HTTPMessage request(HttpConstants::HTTP_1_1, HttpConstants::POST, "/foo");
1218 request.AddBody(large_body, false); 1218 request.AddBody(large_body, false);
1219 1219
1220 // Insert an invalid content_length field in request to trigger an early 1220 // Insert an invalid content_length field in request to trigger an early
1221 // response from server. 1221 // response from server.
1222 request.AddHeader("content-length", "-3"); 1222 request.AddHeader("content-length", "-3");
1223 1223
1224 request.set_skip_message_validation(true); 1224 request.set_skip_message_validation(true);
1225 client_->SendCustomSynchronousRequest(request); 1225 client_->SendCustomSynchronousRequest(request);
1226 EXPECT_EQ("bad", client_->response_body()); 1226 EXPECT_EQ("bad", client_->response_body());
1227 EXPECT_EQ(500u, client_->response_headers()->parsed_response_code()); 1227 EXPECT_EQ("500", client_->response_headers()->find(":status")->second);
1228 EXPECT_EQ(QUIC_STREAM_NO_ERROR, client_->stream_error()); 1228 EXPECT_EQ(QUIC_STREAM_NO_ERROR, client_->stream_error());
1229 EXPECT_EQ(QUIC_NO_ERROR, client_->connection_error()); 1229 EXPECT_EQ(QUIC_NO_ERROR, client_->connection_error());
1230 } 1230 }
1231 1231
1232 // TODO(rch): this test seems to cause net_unittests timeouts :| 1232 // TODO(rch): this test seems to cause net_unittests timeouts :|
1233 TEST_P(EndToEndTest, DISABLED_MultipleTermination) { 1233 TEST_P(EndToEndTest, DISABLED_MultipleTermination) {
1234 ASSERT_TRUE(Initialize()); 1234 ASSERT_TRUE(Initialize());
1235 1235
1236 HTTPMessage request(HttpConstants::HTTP_1_1, HttpConstants::POST, "/foo"); 1236 HTTPMessage request(HttpConstants::HTTP_1_1, HttpConstants::POST, "/foo");
1237 request.AddHeader("content-length", "3"); 1237 request.AddHeader("content-length", "3");
(...skipping 261 matching lines...) Expand 10 before | Expand all | Expand 10 after
1499 client_sent_packet_manager.BandwidthEstimate(); 1499 client_sent_packet_manager.BandwidthEstimate();
1500 server_sent_packet_manager.BandwidthEstimate(); 1500 server_sent_packet_manager.BandwidthEstimate();
1501 server_thread_->Resume(); 1501 server_thread_->Resume();
1502 } 1502 }
1503 1503
1504 TEST_P(EndToEndTest, 0ByteConnectionId) { 1504 TEST_P(EndToEndTest, 0ByteConnectionId) {
1505 client_config_.SetBytesForConnectionIdToSend(0); 1505 client_config_.SetBytesForConnectionIdToSend(0);
1506 ASSERT_TRUE(Initialize()); 1506 ASSERT_TRUE(Initialize());
1507 1507
1508 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo")); 1508 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
1509 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 1509 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
1510 1510
1511 QuicPacketHeader* header = QuicConnectionPeer::GetLastHeader( 1511 QuicPacketHeader* header = QuicConnectionPeer::GetLastHeader(
1512 client_->client()->session()->connection()); 1512 client_->client()->session()->connection());
1513 EXPECT_EQ(PACKET_0BYTE_CONNECTION_ID, 1513 EXPECT_EQ(PACKET_0BYTE_CONNECTION_ID,
1514 header->public_header.connection_id_length); 1514 header->public_header.connection_id_length);
1515 } 1515 }
1516 1516
1517 TEST_P(EndToEndTest, 8ByteConnectionId) { 1517 TEST_P(EndToEndTest, 8ByteConnectionId) {
1518 client_config_.SetBytesForConnectionIdToSend(8); 1518 client_config_.SetBytesForConnectionIdToSend(8);
1519 ASSERT_TRUE(Initialize()); 1519 ASSERT_TRUE(Initialize());
1520 1520
1521 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo")); 1521 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
1522 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 1522 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
1523 QuicPacketHeader* header = QuicConnectionPeer::GetLastHeader( 1523 QuicPacketHeader* header = QuicConnectionPeer::GetLastHeader(
1524 client_->client()->session()->connection()); 1524 client_->client()->session()->connection());
1525 EXPECT_EQ(PACKET_8BYTE_CONNECTION_ID, 1525 EXPECT_EQ(PACKET_8BYTE_CONNECTION_ID,
1526 header->public_header.connection_id_length); 1526 header->public_header.connection_id_length);
1527 } 1527 }
1528 1528
1529 TEST_P(EndToEndTest, 15ByteConnectionId) { 1529 TEST_P(EndToEndTest, 15ByteConnectionId) {
1530 client_config_.SetBytesForConnectionIdToSend(15); 1530 client_config_.SetBytesForConnectionIdToSend(15);
1531 ASSERT_TRUE(Initialize()); 1531 ASSERT_TRUE(Initialize());
1532 1532
1533 // Our server is permissive and allows for out of bounds values. 1533 // Our server is permissive and allows for out of bounds values.
1534 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo")); 1534 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
1535 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 1535 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
1536 QuicPacketHeader* header = QuicConnectionPeer::GetLastHeader( 1536 QuicPacketHeader* header = QuicConnectionPeer::GetLastHeader(
1537 client_->client()->session()->connection()); 1537 client_->client()->session()->connection());
1538 EXPECT_EQ(PACKET_8BYTE_CONNECTION_ID, 1538 EXPECT_EQ(PACKET_8BYTE_CONNECTION_ID,
1539 header->public_header.connection_id_length); 1539 header->public_header.connection_id_length);
1540 } 1540 }
1541 1541
1542 TEST_P(EndToEndTest, ResetConnection) { 1542 TEST_P(EndToEndTest, ResetConnection) {
1543 ASSERT_TRUE(Initialize()); 1543 ASSERT_TRUE(Initialize());
1544 client_->client()->WaitForCryptoHandshakeConfirmed(); 1544 client_->client()->WaitForCryptoHandshakeConfirmed();
1545 1545
1546 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo")); 1546 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
1547 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 1547 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
1548 client_->ResetConnection(); 1548 client_->ResetConnection();
1549 EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest("/bar")); 1549 EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest("/bar"));
1550 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 1550 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
1551 } 1551 }
1552 1552
1553 TEST_P(EndToEndTest, MaxStreamsUberTest) { 1553 TEST_P(EndToEndTest, MaxStreamsUberTest) {
1554 if (!BothSidesSupportStatelessRejects()) { 1554 if (!BothSidesSupportStatelessRejects()) {
1555 // Connect with lower fake packet loss than we'd like to test. Until 1555 // Connect with lower fake packet loss than we'd like to test. Until
1556 // b/10126687 is fixed, losing handshake packets is pretty brutal. 1556 // b/10126687 is fixed, losing handshake packets is pretty brutal.
1557 // TODO(jokulik): Until we support redundant SREJ packets, don't 1557 // TODO(jokulik): Until we support redundant SREJ packets, don't
1558 // drop handshake packets for stateless rejects. 1558 // drop handshake packets for stateless rejects.
1559 SetPacketLossPercentage(1); 1559 SetPacketLossPercentage(1);
1560 } 1560 }
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after
1624 1624
1625 bool IsWriteBlockedDataBuffered() const override { return false; } 1625 bool IsWriteBlockedDataBuffered() const override { return false; }
1626 1626
1627 IPEndPoint self_address_; 1627 IPEndPoint self_address_;
1628 }; 1628 };
1629 1629
1630 TEST_P(EndToEndTest, ConnectionMigrationClientIPChanged) { 1630 TEST_P(EndToEndTest, ConnectionMigrationClientIPChanged) {
1631 ASSERT_TRUE(Initialize()); 1631 ASSERT_TRUE(Initialize());
1632 1632
1633 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo")); 1633 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
1634 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 1634 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
1635 1635
1636 // Store the client IP address which was used to send the first request. 1636 // Store the client IP address which was used to send the first request.
1637 IPAddress old_host = client_->client()->GetLatestClientAddress().address(); 1637 IPAddress old_host = client_->client()->GetLatestClientAddress().address();
1638 1638
1639 // Migrate socket to the new IP address. 1639 // Migrate socket to the new IP address.
1640 IPAddress new_host(127, 0, 0, 2); 1640 IPAddress new_host(127, 0, 0, 2);
1641 EXPECT_NE(old_host, new_host); 1641 EXPECT_NE(old_host, new_host);
1642 ASSERT_TRUE(client_->client()->MigrateSocket(new_host)); 1642 ASSERT_TRUE(client_->client()->MigrateSocket(new_host));
1643 1643
1644 // Send a request using the new socket. 1644 // Send a request using the new socket.
1645 EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest("/bar")); 1645 EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest("/bar"));
1646 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 1646 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
1647 } 1647 }
1648 1648
1649 TEST_P(EndToEndTest, ConnectionMigrationClientPortChanged) { 1649 TEST_P(EndToEndTest, ConnectionMigrationClientPortChanged) {
1650 // Tests that the client's port can change during an established QUIC 1650 // Tests that the client's port can change during an established QUIC
1651 // connection, and that doing so does not result in the connection being 1651 // connection, and that doing so does not result in the connection being
1652 // closed by the server. 1652 // closed by the server.
1653 ASSERT_TRUE(Initialize()); 1653 ASSERT_TRUE(Initialize());
1654 1654
1655 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo")); 1655 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
1656 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 1656 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
1657 1657
1658 // Store the client address which was used to send the first request. 1658 // Store the client address which was used to send the first request.
1659 IPEndPoint old_address = client_->client()->GetLatestClientAddress(); 1659 IPEndPoint old_address = client_->client()->GetLatestClientAddress();
1660 int old_fd = client_->client()->GetLatestFD(); 1660 int old_fd = client_->client()->GetLatestFD();
1661 1661
1662 // Create a new socket before closing the old one, which will result in a new 1662 // Create a new socket before closing the old one, which will result in a new
1663 // ephemeral port. 1663 // ephemeral port.
1664 QuicClientPeer::CreateUDPSocketAndBind(client_->client()); 1664 QuicClientPeer::CreateUDPSocketAndBind(client_->client());
1665 1665
1666 // Stop listening and close the old FD. 1666 // Stop listening and close the old FD.
(...skipping 15 matching lines...) Expand all
1682 client_->client()->session()->connection()->self_address().address(), 1682 client_->client()->session()->connection()->self_address().address(),
1683 new_port)); 1683 new_port));
1684 1684
1685 // Register the new FD for epoll events. 1685 // Register the new FD for epoll events.
1686 int new_fd = client_->client()->GetLatestFD(); 1686 int new_fd = client_->client()->GetLatestFD();
1687 EpollServer* eps = client_->epoll_server(); 1687 EpollServer* eps = client_->epoll_server();
1688 eps->RegisterFD(new_fd, client_->client(), EPOLLIN | EPOLLOUT | EPOLLET); 1688 eps->RegisterFD(new_fd, client_->client(), EPOLLIN | EPOLLOUT | EPOLLET);
1689 1689
1690 // Send a second request, using the new FD. 1690 // Send a second request, using the new FD.
1691 EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest("/bar")); 1691 EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest("/bar"));
1692 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 1692 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
1693 1693
1694 // Verify that the client's ephemeral port is different. 1694 // Verify that the client's ephemeral port is different.
1695 IPEndPoint new_address = client_->client()->GetLatestClientAddress(); 1695 IPEndPoint new_address = client_->client()->GetLatestClientAddress();
1696 EXPECT_EQ(old_address.address(), new_address.address()); 1696 EXPECT_EQ(old_address.address(), new_address.address());
1697 EXPECT_NE(old_address.port(), new_address.port()); 1697 EXPECT_NE(old_address.port(), new_address.port());
1698 } 1698 }
1699 1699
1700 TEST_P(EndToEndTest, DifferentFlowControlWindows) { 1700 TEST_P(EndToEndTest, DifferentFlowControlWindows) {
1701 // Client and server can set different initial flow control receive windows. 1701 // Client and server can set different initial flow control receive windows.
1702 // These are sent in CHLO/SHLO. Tests that these values are exchanged properly 1702 // These are sent in CHLO/SHLO. Tests that these values are exchanged properly
(...skipping 139 matching lines...) Expand 10 before | Expand all | Expand 10 after
1842 } 1842 }
1843 1843
1844 TEST_P(EndToEndTest, RequestWithNoBodyWillNeverSendStreamFrameWithFIN) { 1844 TEST_P(EndToEndTest, RequestWithNoBodyWillNeverSendStreamFrameWithFIN) {
1845 // A stream created on receipt of a simple request with no body will never get 1845 // A stream created on receipt of a simple request with no body will never get
1846 // a stream frame with a FIN. Verify that we don't keep track of the stream in 1846 // a stream frame with a FIN. Verify that we don't keep track of the stream in
1847 // the locally closed streams map: it will never be removed if so. 1847 // the locally closed streams map: it will never be removed if so.
1848 ASSERT_TRUE(Initialize()); 1848 ASSERT_TRUE(Initialize());
1849 1849
1850 // Send a simple headers only request, and receive response. 1850 // Send a simple headers only request, and receive response.
1851 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo")); 1851 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
1852 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 1852 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
1853 1853
1854 // Now verify that the server is not waiting for a final FIN or RST. 1854 // Now verify that the server is not waiting for a final FIN or RST.
1855 server_thread_->Pause(); 1855 server_thread_->Pause();
1856 QuicDispatcher* dispatcher = 1856 QuicDispatcher* dispatcher =
1857 QuicServerPeer::GetDispatcher(server_thread_->server()); 1857 QuicServerPeer::GetDispatcher(server_thread_->server());
1858 QuicSession* session = dispatcher->session_map().begin()->second.get(); 1858 QuicSession* session = dispatcher->session_map().begin()->second.get();
1859 EXPECT_EQ( 1859 EXPECT_EQ(
1860 0u, 1860 0u,
1861 QuicSessionPeer::GetLocallyClosedStreamsHighestOffset(session).size()); 1861 QuicSessionPeer::GetLocallyClosedStreamsHighestOffset(session).size());
1862 server_thread_->Resume(); 1862 server_thread_->Resume();
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after
1924 1924
1925 // Test the AckNotifier's ability to track multiple packets by making the 1925 // Test the AckNotifier's ability to track multiple packets by making the
1926 // request body exceed the size of a single packet. 1926 // request body exceed the size of a single packet.
1927 string request_string = 1927 string request_string =
1928 "a request body bigger than one packet" + string(kMaxPacketSize, '.'); 1928 "a request body bigger than one packet" + string(kMaxPacketSize, '.');
1929 1929
1930 // Send the request, and register the delegate for ACKs. 1930 // Send the request, and register the delegate for ACKs.
1931 client_->SendData(request_string, true, delegate.get()); 1931 client_->SendData(request_string, true, delegate.get());
1932 client_->WaitForResponse(); 1932 client_->WaitForResponse();
1933 EXPECT_EQ(kFooResponseBody, client_->response_body()); 1933 EXPECT_EQ(kFooResponseBody, client_->response_body());
1934 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 1934 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
1935 1935
1936 // Send another request to flush out any pending ACKs on the server. 1936 // Send another request to flush out any pending ACKs on the server.
1937 client_->SendSynchronousRequest("/bar"); 1937 client_->SendSynchronousRequest("/bar");
1938 1938
1939 // Pause the server to avoid races. 1939 // Pause the server to avoid races.
1940 server_thread_->Pause(); 1940 server_thread_->Pause();
1941 // Make sure the delegate does get the notification it expects. 1941 // Make sure the delegate does get the notification it expects.
1942 while (!delegate->has_been_notified()) { 1942 while (!delegate->has_been_notified()) {
1943 // Waits for up to 50 ms. 1943 // Waits for up to 50 ms.
1944 client_->client()->WaitForEvents(); 1944 client_->client()->WaitForEvents();
(...skipping 20 matching lines...) Expand all
1965 // We must pause the server's thread in order to call WritePacket without 1965 // We must pause the server's thread in order to call WritePacket without
1966 // race conditions. 1966 // race conditions.
1967 server_thread_->Pause(); 1967 server_thread_->Pause();
1968 server_writer_->WritePacket( 1968 server_writer_->WritePacket(
1969 packet->data(), packet->length(), server_address_.address(), 1969 packet->data(), packet->length(), server_address_.address(),
1970 client_->client()->GetLatestClientAddress(), nullptr); 1970 client_->client()->GetLatestClientAddress(), nullptr);
1971 server_thread_->Resume(); 1971 server_thread_->Resume();
1972 1972
1973 // The request should fail. 1973 // The request should fail.
1974 EXPECT_EQ("", client_->SendSynchronousRequest("/foo")); 1974 EXPECT_EQ("", client_->SendSynchronousRequest("/foo"));
1975 EXPECT_EQ(0u, client_->response_headers()->parsed_response_code()); 1975 EXPECT_TRUE(client_->response_headers()->empty());
1976 EXPECT_EQ(QUIC_PUBLIC_RESET, client_->connection_error()); 1976 EXPECT_EQ(QUIC_PUBLIC_RESET, client_->connection_error());
1977 } 1977 }
1978 1978
1979 // Send a public reset from the server for a different connection ID. 1979 // Send a public reset from the server for a different connection ID.
1980 // It should be ignored. 1980 // It should be ignored.
1981 TEST_P(EndToEndTest, ServerSendPublicResetWithDifferentConnectionId) { 1981 TEST_P(EndToEndTest, ServerSendPublicResetWithDifferentConnectionId) {
1982 ASSERT_TRUE(Initialize()); 1982 ASSERT_TRUE(Initialize());
1983 1983
1984 client_->client()->WaitForCryptoHandshakeConfirmed(); 1984 client_->client()->WaitForCryptoHandshakeConfirmed();
1985 1985
(...skipping 16 matching lines...) Expand all
2002 // We must pause the server's thread in order to call WritePacket without 2002 // We must pause the server's thread in order to call WritePacket without
2003 // race conditions. 2003 // race conditions.
2004 server_thread_->Pause(); 2004 server_thread_->Pause();
2005 server_writer_->WritePacket( 2005 server_writer_->WritePacket(
2006 packet->data(), packet->length(), server_address_.address(), 2006 packet->data(), packet->length(), server_address_.address(),
2007 client_->client()->GetLatestClientAddress(), nullptr); 2007 client_->client()->GetLatestClientAddress(), nullptr);
2008 server_thread_->Resume(); 2008 server_thread_->Resume();
2009 2009
2010 // The connection should be unaffected. 2010 // The connection should be unaffected.
2011 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo")); 2011 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
2012 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 2012 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
2013 2013
2014 client_->client()->session()->connection()->set_debug_visitor(nullptr); 2014 client_->client()->session()->connection()->set_debug_visitor(nullptr);
2015 } 2015 }
2016 2016
2017 // Send a public reset from the client for a different connection ID. 2017 // Send a public reset from the client for a different connection ID.
2018 // It should be ignored. 2018 // It should be ignored.
2019 TEST_P(EndToEndTest, ClientSendPublicResetWithDifferentConnectionId) { 2019 TEST_P(EndToEndTest, ClientSendPublicResetWithDifferentConnectionId) {
2020 ASSERT_TRUE(Initialize()); 2020 ASSERT_TRUE(Initialize());
2021 2021
2022 // Send the public reset. 2022 // Send the public reset.
2023 QuicConnectionId incorrect_connection_id = 2023 QuicConnectionId incorrect_connection_id =
2024 client_->client()->session()->connection()->connection_id() + 1; 2024 client_->client()->session()->connection()->connection_id() + 1;
2025 QuicPublicResetPacket header; 2025 QuicPublicResetPacket header;
2026 header.public_header.connection_id = incorrect_connection_id; 2026 header.public_header.connection_id = incorrect_connection_id;
2027 header.public_header.reset_flag = true; 2027 header.public_header.reset_flag = true;
2028 header.public_header.version_flag = false; 2028 header.public_header.version_flag = false;
2029 header.rejected_packet_number = 10101; 2029 header.rejected_packet_number = 10101;
2030 QuicFramer framer(server_supported_versions_, QuicTime::Zero(), 2030 QuicFramer framer(server_supported_versions_, QuicTime::Zero(),
2031 Perspective::IS_CLIENT); 2031 Perspective::IS_CLIENT);
2032 std::unique_ptr<QuicEncryptedPacket> packet( 2032 std::unique_ptr<QuicEncryptedPacket> packet(
2033 framer.BuildPublicResetPacket(header)); 2033 framer.BuildPublicResetPacket(header));
2034 client_writer_->WritePacket( 2034 client_writer_->WritePacket(
2035 packet->data(), packet->length(), 2035 packet->data(), packet->length(),
2036 client_->client()->GetLatestClientAddress().address(), server_address_, 2036 client_->client()->GetLatestClientAddress().address(), server_address_,
2037 nullptr); 2037 nullptr);
2038 2038
2039 // The connection should be unaffected. 2039 // The connection should be unaffected.
2040 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo")); 2040 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
2041 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 2041 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
2042 } 2042 }
2043 2043
2044 // Send a version negotiation packet from the server for a different 2044 // Send a version negotiation packet from the server for a different
2045 // connection ID. It should be ignored. 2045 // connection ID. It should be ignored.
2046 TEST_P(EndToEndTest, ServerSendVersionNegotiationWithDifferentConnectionId) { 2046 TEST_P(EndToEndTest, ServerSendVersionNegotiationWithDifferentConnectionId) {
2047 ASSERT_TRUE(Initialize()); 2047 ASSERT_TRUE(Initialize());
2048 2048
2049 client_->client()->WaitForCryptoHandshakeConfirmed(); 2049 client_->client()->WaitForCryptoHandshakeConfirmed();
2050 2050
2051 // Send the version negotiation packet. 2051 // Send the version negotiation packet.
2052 QuicConnectionId incorrect_connection_id = 2052 QuicConnectionId incorrect_connection_id =
2053 client_->client()->session()->connection()->connection_id() + 1; 2053 client_->client()->session()->connection()->connection_id() + 1;
2054 std::unique_ptr<QuicEncryptedPacket> packet( 2054 std::unique_ptr<QuicEncryptedPacket> packet(
2055 QuicFramer::BuildVersionNegotiationPacket(incorrect_connection_id, 2055 QuicFramer::BuildVersionNegotiationPacket(incorrect_connection_id,
2056 server_supported_versions_)); 2056 server_supported_versions_));
2057 testing::NiceMock<MockQuicConnectionDebugVisitor> visitor; 2057 testing::NiceMock<MockQuicConnectionDebugVisitor> visitor;
2058 client_->client()->session()->connection()->set_debug_visitor(&visitor); 2058 client_->client()->session()->connection()->set_debug_visitor(&visitor);
2059 EXPECT_CALL(visitor, OnIncorrectConnectionId(incorrect_connection_id)) 2059 EXPECT_CALL(visitor, OnIncorrectConnectionId(incorrect_connection_id))
2060 .Times(1); 2060 .Times(1);
2061 // We must pause the server's thread in order to call WritePacket without 2061 // We must pause the server's thread in order to call WritePacket without
2062 // race conditions. 2062 // race conditions.
2063 server_thread_->Pause(); 2063 server_thread_->Pause();
2064 server_writer_->WritePacket( 2064 server_writer_->WritePacket(
2065 packet->data(), packet->length(), server_address_.address(), 2065 packet->data(), packet->length(), server_address_.address(),
2066 client_->client()->GetLatestClientAddress(), nullptr); 2066 client_->client()->GetLatestClientAddress(), nullptr);
2067 server_thread_->Resume(); 2067 server_thread_->Resume();
2068 2068
2069 // The connection should be unaffected. 2069 // The connection should be unaffected.
2070 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo")); 2070 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
2071 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 2071 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
2072 2072
2073 client_->client()->session()->connection()->set_debug_visitor(nullptr); 2073 client_->client()->session()->connection()->set_debug_visitor(nullptr);
2074 } 2074 }
2075 2075
2076 // A bad header shouldn't tear down the connection, because the receiver can't 2076 // A bad header shouldn't tear down the connection, because the receiver can't
2077 // tell the connection ID. 2077 // tell the connection ID.
2078 TEST_P(EndToEndTest, BadPacketHeaderTruncated) { 2078 TEST_P(EndToEndTest, BadPacketHeaderTruncated) {
2079 ASSERT_TRUE(Initialize()); 2079 ASSERT_TRUE(Initialize());
2080 2080
2081 // Start the connection. 2081 // Start the connection.
2082 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo")); 2082 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
2083 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 2083 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
2084 2084
2085 // Packet with invalid public flags. 2085 // Packet with invalid public flags.
2086 char packet[] = {// public flags (8 byte connection_id) 2086 char packet[] = {// public flags (8 byte connection_id)
2087 0x3C, 2087 0x3C,
2088 // truncated connection ID 2088 // truncated connection ID
2089 0x11}; 2089 0x11};
2090 client_writer_->WritePacket( 2090 client_writer_->WritePacket(
2091 &packet[0], sizeof(packet), 2091 &packet[0], sizeof(packet),
2092 client_->client()->GetLatestClientAddress().address(), server_address_, 2092 client_->client()->GetLatestClientAddress().address(), server_address_,
2093 nullptr); 2093 nullptr);
2094 // Give the server time to process the packet. 2094 // Give the server time to process the packet.
2095 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100)); 2095 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
2096 // Pause the server so we can access the server's internals without races. 2096 // Pause the server so we can access the server's internals without races.
2097 server_thread_->Pause(); 2097 server_thread_->Pause();
2098 QuicDispatcher* dispatcher = 2098 QuicDispatcher* dispatcher =
2099 QuicServerPeer::GetDispatcher(server_thread_->server()); 2099 QuicServerPeer::GetDispatcher(server_thread_->server());
2100 EXPECT_EQ(QUIC_INVALID_PACKET_HEADER, 2100 EXPECT_EQ(QUIC_INVALID_PACKET_HEADER,
2101 QuicDispatcherPeer::GetAndClearLastError(dispatcher)); 2101 QuicDispatcherPeer::GetAndClearLastError(dispatcher));
2102 server_thread_->Resume(); 2102 server_thread_->Resume();
2103 2103
2104 // The connection should not be terminated. 2104 // The connection should not be terminated.
2105 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo")); 2105 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
2106 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 2106 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
2107 } 2107 }
2108 2108
2109 // A bad header shouldn't tear down the connection, because the receiver can't 2109 // A bad header shouldn't tear down the connection, because the receiver can't
2110 // tell the connection ID. 2110 // tell the connection ID.
2111 TEST_P(EndToEndTest, BadPacketHeaderFlags) { 2111 TEST_P(EndToEndTest, BadPacketHeaderFlags) {
2112 ASSERT_TRUE(Initialize()); 2112 ASSERT_TRUE(Initialize());
2113 2113
2114 // Start the connection. 2114 // Start the connection.
2115 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo")); 2115 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
2116 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 2116 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
2117 2117
2118 // Packet with invalid public flags. 2118 // Packet with invalid public flags.
2119 char packet[] = { 2119 char packet[] = {
2120 // invalid public flags 2120 // invalid public flags
2121 0xFF, 2121 0xFF,
2122 // connection_id 2122 // connection_id
2123 0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE, 2123 0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
2124 // packet sequence number 2124 // packet sequence number
2125 0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12, 2125 0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12,
2126 // private flags 2126 // private flags
2127 0x00, 2127 0x00,
2128 }; 2128 };
2129 client_writer_->WritePacket( 2129 client_writer_->WritePacket(
2130 &packet[0], sizeof(packet), 2130 &packet[0], sizeof(packet),
2131 client_->client()->GetLatestClientAddress().address(), server_address_, 2131 client_->client()->GetLatestClientAddress().address(), server_address_,
2132 nullptr); 2132 nullptr);
2133 // Give the server time to process the packet. 2133 // Give the server time to process the packet.
2134 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100)); 2134 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
2135 // Pause the server so we can access the server's internals without races. 2135 // Pause the server so we can access the server's internals without races.
2136 server_thread_->Pause(); 2136 server_thread_->Pause();
2137 QuicDispatcher* dispatcher = 2137 QuicDispatcher* dispatcher =
2138 QuicServerPeer::GetDispatcher(server_thread_->server()); 2138 QuicServerPeer::GetDispatcher(server_thread_->server());
2139 EXPECT_EQ(QUIC_INVALID_PACKET_HEADER, 2139 EXPECT_EQ(QUIC_INVALID_PACKET_HEADER,
2140 QuicDispatcherPeer::GetAndClearLastError(dispatcher)); 2140 QuicDispatcherPeer::GetAndClearLastError(dispatcher));
2141 server_thread_->Resume(); 2141 server_thread_->Resume();
2142 2142
2143 // The connection should not be terminated. 2143 // The connection should not be terminated.
2144 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo")); 2144 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
2145 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 2145 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
2146 } 2146 }
2147 2147
2148 // Send a packet from the client with bad encrypted data. The server should not 2148 // Send a packet from the client with bad encrypted data. The server should not
2149 // tear down the connection. 2149 // tear down the connection.
2150 TEST_P(EndToEndTest, BadEncryptedData) { 2150 TEST_P(EndToEndTest, BadEncryptedData) {
2151 ASSERT_TRUE(Initialize()); 2151 ASSERT_TRUE(Initialize());
2152 2152
2153 // Start the connection. 2153 // Start the connection.
2154 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo")); 2154 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
2155 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 2155 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
2156 2156
2157 std::unique_ptr<QuicEncryptedPacket> packet(ConstructEncryptedPacket( 2157 std::unique_ptr<QuicEncryptedPacket> packet(ConstructEncryptedPacket(
2158 client_->client()->session()->connection()->connection_id(), false, false, 2158 client_->client()->session()->connection()->connection_id(), false, false,
2159 false, kDefaultPathId, 1, "At least 20 characters.", 2159 false, kDefaultPathId, 1, "At least 20 characters.",
2160 PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER)); 2160 PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER));
2161 // Damage the encrypted data. 2161 // Damage the encrypted data.
2162 string damaged_packet(packet->data(), packet->length()); 2162 string damaged_packet(packet->data(), packet->length());
2163 damaged_packet[30] ^= 0x01; 2163 damaged_packet[30] ^= 0x01;
2164 DVLOG(1) << "Sending bad packet."; 2164 DVLOG(1) << "Sending bad packet.";
2165 client_writer_->WritePacket( 2165 client_writer_->WritePacket(
2166 damaged_packet.data(), damaged_packet.length(), 2166 damaged_packet.data(), damaged_packet.length(),
2167 client_->client()->GetLatestClientAddress().address(), server_address_, 2167 client_->client()->GetLatestClientAddress().address(), server_address_,
2168 nullptr); 2168 nullptr);
2169 // Give the server time to process the packet. 2169 // Give the server time to process the packet.
2170 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100)); 2170 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
2171 // This error is sent to the connection's OnError (which ignores it), so the 2171 // This error is sent to the connection's OnError (which ignores it), so the
2172 // dispatcher doesn't see it. 2172 // dispatcher doesn't see it.
2173 // Pause the server so we can access the server's internals without races. 2173 // Pause the server so we can access the server's internals without races.
2174 server_thread_->Pause(); 2174 server_thread_->Pause();
2175 QuicDispatcher* dispatcher = 2175 QuicDispatcher* dispatcher =
2176 QuicServerPeer::GetDispatcher(server_thread_->server()); 2176 QuicServerPeer::GetDispatcher(server_thread_->server());
2177 EXPECT_EQ(QUIC_NO_ERROR, 2177 EXPECT_EQ(QUIC_NO_ERROR,
2178 QuicDispatcherPeer::GetAndClearLastError(dispatcher)); 2178 QuicDispatcherPeer::GetAndClearLastError(dispatcher));
2179 server_thread_->Resume(); 2179 server_thread_->Resume();
2180 2180
2181 // The connection should not be terminated. 2181 // The connection should not be terminated.
2182 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo")); 2182 EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
2183 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 2183 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
2184 } 2184 }
2185 2185
2186 // A test stream that gives |response_body_| as an error response body. 2186 // A test stream that gives |response_body_| as an error response body.
2187 class ServerStreamWithErrorResponseBody : public QuicSimpleServerStream { 2187 class ServerStreamWithErrorResponseBody : public QuicSimpleServerStream {
2188 public: 2188 public:
2189 ServerStreamWithErrorResponseBody(QuicStreamId id, 2189 ServerStreamWithErrorResponseBody(QuicStreamId id,
2190 QuicSpdySession* session, 2190 QuicSpdySession* session,
2191 string response_body) 2191 string response_body)
2192 : QuicSimpleServerStream(id, session), 2192 : QuicSimpleServerStream(id, session),
2193 response_body_(std::move(response_body)) {} 2193 response_body_(std::move(response_body)) {}
(...skipping 247 matching lines...) Expand 10 before | Expand all | Expand 10 after
2441 GenerateBody(&request_body, kRequestBodySize); 2441 GenerateBody(&request_body, kRequestBodySize);
2442 request.AddBody(request_body, false); 2442 request.AddBody(request_body, false);
2443 // Set an invalid content-length, so the request will receive an early 500 2443 // Set an invalid content-length, so the request will receive an early 500
2444 // response. Must be done after AddBody, which also sets content-length. 2444 // response. Must be done after AddBody, which also sets content-length.
2445 request.AddHeader("content-length", "-1"); 2445 request.AddHeader("content-length", "-1");
2446 request.set_skip_message_validation(true); 2446 request.set_skip_message_validation(true);
2447 2447
2448 // Send the request. 2448 // Send the request.
2449 client_->SendMessage(request); 2449 client_->SendMessage(request);
2450 client_->WaitForResponse(); 2450 client_->WaitForResponse();
2451 EXPECT_EQ(500u, client_->response_headers()->parsed_response_code()); 2451 EXPECT_EQ("500", client_->response_headers()->find(":status")->second);
2452 2452
2453 // Pause the server so we can access the server's internals without races. 2453 // Pause the server so we can access the server's internals without races.
2454 server_thread_->Pause(); 2454 server_thread_->Pause();
2455 2455
2456 QuicDispatcher* dispatcher = 2456 QuicDispatcher* dispatcher =
2457 QuicServerPeer::GetDispatcher(server_thread_->server()); 2457 QuicServerPeer::GetDispatcher(server_thread_->server());
2458 QuicDispatcher::SessionMap const& map = 2458 QuicDispatcher::SessionMap const& map =
2459 QuicDispatcherPeer::session_map(dispatcher); 2459 QuicDispatcherPeer::session_map(dispatcher);
2460 QuicDispatcher::SessionMap::const_iterator it = map.begin(); 2460 QuicDispatcher::SessionMap::const_iterator it = map.begin();
2461 EXPECT_TRUE(it != map.end()); 2461 EXPECT_TRUE(it != map.end());
(...skipping 25 matching lines...) Expand all
2487 request.AddHeader("content-length", "-1"); 2487 request.AddHeader("content-length", "-1");
2488 request.set_skip_message_validation(true); 2488 request.set_skip_message_validation(true);
2489 request.set_has_complete_message(false); 2489 request.set_has_complete_message(false);
2490 2490
2491 // Tell the client to not close the stream if it receives an early response. 2491 // Tell the client to not close the stream if it receives an early response.
2492 client_->set_allow_bidirectional_data(true); 2492 client_->set_allow_bidirectional_data(true);
2493 // Send the headers. 2493 // Send the headers.
2494 client_->SendMessage(request); 2494 client_->SendMessage(request);
2495 // Receive the response and let the server close writing. 2495 // Receive the response and let the server close writing.
2496 client_->WaitForInitialResponse(); 2496 client_->WaitForInitialResponse();
2497 EXPECT_EQ(500u, client_->response_headers()->parsed_response_code()); 2497 EXPECT_EQ("500", client_->response_headers()->find(":status")->second);
2498 2498
2499 // Receive the reset stream from server on early response. 2499 // Receive the reset stream from server on early response.
2500 ReliableQuicStream* stream = 2500 ReliableQuicStream* stream =
2501 client_->client()->session()->GetOrCreateStream(kClientDataStreamId1); 2501 client_->client()->session()->GetOrCreateStream(kClientDataStreamId1);
2502 // The stream is reset by server's reset stream. 2502 // The stream is reset by server's reset stream.
2503 EXPECT_EQ(stream, nullptr); 2503 EXPECT_EQ(stream, nullptr);
2504 } 2504 }
2505 2505
2506 TEST_P(EndToEndTest, Trailers) { 2506 TEST_P(EndToEndTest, Trailers) {
2507 // Test sending and receiving HTTP/2 Trailers (trailing HEADERS frames). 2507 // Test sending and receiving HTTP/2 Trailers (trailing HEADERS frames).
(...skipping 13 matching lines...) Expand all
2521 headers["content-length"] = IntToString(kBody.size()); 2521 headers["content-length"] = IntToString(kBody.size());
2522 2522
2523 SpdyHeaderBlock trailers; 2523 SpdyHeaderBlock trailers;
2524 trailers["some-trailing-header"] = "trailing-header-value"; 2524 trailers["some-trailing-header"] = "trailing-header-value";
2525 2525
2526 QuicInMemoryCache::GetInstance()->AddResponse( 2526 QuicInMemoryCache::GetInstance()->AddResponse(
2527 server_hostname_, "/trailer_url", std::move(headers), kBody, 2527 server_hostname_, "/trailer_url", std::move(headers), kBody,
2528 trailers.Clone()); 2528 trailers.Clone());
2529 2529
2530 EXPECT_EQ(kBody, client_->SendSynchronousRequest("/trailer_url")); 2530 EXPECT_EQ(kBody, client_->SendSynchronousRequest("/trailer_url"));
2531 EXPECT_EQ(200u, client_->response_headers()->parsed_response_code()); 2531 EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
2532 EXPECT_EQ(trailers, client_->response_trailers()); 2532 EXPECT_EQ(trailers, client_->response_trailers());
2533 } 2533 }
2534 2534
2535 class EndToEndTestServerPush : public EndToEndTest { 2535 class EndToEndTestServerPush : public EndToEndTest {
2536 protected: 2536 protected:
2537 const size_t kNumMaxStreams = 10; 2537 const size_t kNumMaxStreams = 10;
2538 2538
2539 EndToEndTestServerPush() : EndToEndTest() { 2539 EndToEndTestServerPush() : EndToEndTest() {
2540 client_config_.SetMaxStreamsPerConnection(kNumMaxStreams, kNumMaxStreams); 2540 client_config_.SetMaxStreamsPerConnection(kNumMaxStreams, kNumMaxStreams);
2541 client_config_.SetMaxIncomingDynamicStreamsToSend(kNumMaxStreams); 2541 client_config_.SetMaxIncomingDynamicStreamsToSend(kNumMaxStreams);
(...skipping 441 matching lines...) Expand 10 before | Expand all | Expand 10 after
2983 client_->WaitForResponse(); 2983 client_->WaitForResponse();
2984 EXPECT_EQ(kBarResponseBody, client_->response_body()); 2984 EXPECT_EQ(kBarResponseBody, client_->response_body());
2985 QuicConnectionStats client_stats = 2985 QuicConnectionStats client_stats =
2986 client_->client()->session()->connection()->GetStats(); 2986 client_->client()->session()->connection()->GetStats();
2987 EXPECT_EQ(0u, client_stats.packets_lost); 2987 EXPECT_EQ(0u, client_stats.packets_lost);
2988 EXPECT_EQ(1, client_->client()->GetNumSentClientHellos()); 2988 EXPECT_EQ(1, client_->client()->GetNumSentClientHellos());
2989 } 2989 }
2990 } // namespace 2990 } // namespace
2991 } // namespace test 2991 } // namespace test
2992 } // namespace net 2992 } // namespace net
OLDNEW
« no previous file with comments | « net/quic/test_tools/fake_proof_source.cc ('k') | net/tools/quic/stateless_rejector.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698