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

Unified Diff: net/quic/quic_connection_test.cc

Issue 2193073003: Move shared files in net/quic/ into net/quic/core/ (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: io_thread_unittest.cc Created 4 years, 5 months 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 side-by-side diff with in-line comments
Download patch
« no previous file with comments | « net/quic/quic_connection_stats.cc ('k') | net/quic/quic_crypto_client_stream.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/quic/quic_connection_test.cc
diff --git a/net/quic/quic_connection_test.cc b/net/quic/quic_connection_test.cc
deleted file mode 100644
index 38ec8f6d25da8ce9fecbc2a06951e0c0bac965f9..0000000000000000000000000000000000000000
--- a/net/quic/quic_connection_test.cc
+++ /dev/null
@@ -1,4949 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "net/quic/quic_connection.h"
-
-#include <errno.h>
-#include <memory>
-#include <ostream>
-#include <utility>
-
-#include "base/bind.h"
-#include "base/macros.h"
-#include "base/stl_util.h"
-#include "net/base/ip_address.h"
-#include "net/base/net_errors.h"
-#include "net/quic/congestion_control/loss_detection_interface.h"
-#include "net/quic/congestion_control/send_algorithm_interface.h"
-#include "net/quic/crypto/null_encrypter.h"
-#include "net/quic/crypto/quic_decrypter.h"
-#include "net/quic/crypto/quic_encrypter.h"
-#include "net/quic/quic_flags.h"
-#include "net/quic/quic_protocol.h"
-#include "net/quic/quic_simple_buffer_allocator.h"
-#include "net/quic/quic_utils.h"
-#include "net/quic/test_tools/mock_clock.h"
-#include "net/quic/test_tools/mock_random.h"
-#include "net/quic/test_tools/quic_config_peer.h"
-#include "net/quic/test_tools/quic_connection_peer.h"
-#include "net/quic/test_tools/quic_framer_peer.h"
-#include "net/quic/test_tools/quic_packet_creator_peer.h"
-#include "net/quic/test_tools/quic_packet_generator_peer.h"
-#include "net/quic/test_tools/quic_sent_packet_manager_peer.h"
-#include "net/quic/test_tools/quic_test_utils.h"
-#include "net/quic/test_tools/simple_quic_framer.h"
-#include "net/test/gtest_util.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using base::StringPiece;
-using std::map;
-using std::ostream;
-using std::string;
-using std::vector;
-using testing::AnyNumber;
-using testing::AtLeast;
-using testing::Contains;
-using testing::DoAll;
-using testing::InSequence;
-using testing::InvokeWithoutArgs;
-using testing::NiceMock;
-using testing::Ref;
-using testing::Return;
-using testing::SaveArg;
-using testing::SetArgPointee;
-using testing::StrictMock;
-using testing::_;
-
-namespace net {
-namespace test {
-namespace {
-
-const char data1[] = "foo";
-const char data2[] = "bar";
-
-const bool kFin = true;
-const bool kEntropyFlag = true;
-const bool kHasStopWaiting = true;
-
-const QuicPacketEntropyHash kTestEntropyHash = 76;
-
-const int kDefaultRetransmissionTimeMs = 500;
-
-const IPEndPoint kPeerAddress = IPEndPoint(Loopback6(), /*port=*/12345);
-const IPEndPoint kSelfAddress = IPEndPoint(Loopback6(), /*port=*/443);
-
-Perspective InvertPerspective(Perspective perspective) {
- return perspective == Perspective::IS_CLIENT ? Perspective::IS_SERVER
- : Perspective::IS_CLIENT;
-}
-
-// TaggingEncrypter appends kTagSize bytes of |tag| to the end of each message.
-class TaggingEncrypter : public QuicEncrypter {
- public:
- explicit TaggingEncrypter(uint8_t tag) : tag_(tag) {}
-
- ~TaggingEncrypter() override {}
-
- // QuicEncrypter interface.
- bool SetKey(StringPiece key) override { return true; }
-
- bool SetNoncePrefix(StringPiece nonce_prefix) override { return true; }
-
- bool EncryptPacket(QuicPathId path_id,
- QuicPacketNumber packet_number,
- StringPiece associated_data,
- StringPiece plaintext,
- char* output,
- size_t* output_length,
- size_t max_output_length) override {
- const size_t len = plaintext.size() + kTagSize;
- if (max_output_length < len) {
- return false;
- }
- // Memmove is safe for inplace encryption.
- memmove(output, plaintext.data(), plaintext.size());
- output += plaintext.size();
- memset(output, tag_, kTagSize);
- *output_length = len;
- return true;
- }
-
- size_t GetKeySize() const override { return 0; }
- size_t GetNoncePrefixSize() const override { return 0; }
-
- size_t GetMaxPlaintextSize(size_t ciphertext_size) const override {
- return ciphertext_size - kTagSize;
- }
-
- size_t GetCiphertextSize(size_t plaintext_size) const override {
- return plaintext_size + kTagSize;
- }
-
- StringPiece GetKey() const override { return StringPiece(); }
-
- StringPiece GetNoncePrefix() const override { return StringPiece(); }
-
- private:
- enum {
- kTagSize = 12,
- };
-
- const uint8_t tag_;
-
- DISALLOW_COPY_AND_ASSIGN(TaggingEncrypter);
-};
-
-// TaggingDecrypter ensures that the final kTagSize bytes of the message all
-// have the same value and then removes them.
-class TaggingDecrypter : public QuicDecrypter {
- public:
- ~TaggingDecrypter() override {}
-
- // QuicDecrypter interface
- bool SetKey(StringPiece key) override { return true; }
-
- bool SetNoncePrefix(StringPiece nonce_prefix) override { return true; }
-
- bool SetPreliminaryKey(StringPiece key) override {
- QUIC_BUG << "should not be called";
- return false;
- }
-
- bool SetDiversificationNonce(DiversificationNonce key) override {
- return true;
- }
-
- bool DecryptPacket(QuicPathId path_id,
- QuicPacketNumber packet_number,
- StringPiece associated_data,
- StringPiece ciphertext,
- char* output,
- size_t* output_length,
- size_t max_output_length) override {
- if (ciphertext.size() < kTagSize) {
- return false;
- }
- if (!CheckTag(ciphertext, GetTag(ciphertext))) {
- return false;
- }
- *output_length = ciphertext.size() - kTagSize;
- memcpy(output, ciphertext.data(), *output_length);
- return true;
- }
-
- StringPiece GetKey() const override { return StringPiece(); }
- StringPiece GetNoncePrefix() const override { return StringPiece(); }
- const char* cipher_name() const override { return "Tagging"; }
- // Use a distinct value starting with 0xFFFFFF, which is never used by TLS.
- uint32_t cipher_id() const override { return 0xFFFFFFF0; }
-
- protected:
- virtual uint8_t GetTag(StringPiece ciphertext) {
- return ciphertext.data()[ciphertext.size() - 1];
- }
-
- private:
- enum {
- kTagSize = 12,
- };
-
- bool CheckTag(StringPiece ciphertext, uint8_t tag) {
- for (size_t i = ciphertext.size() - kTagSize; i < ciphertext.size(); i++) {
- if (ciphertext.data()[i] != tag) {
- return false;
- }
- }
-
- return true;
- }
-};
-
-// StringTaggingDecrypter ensures that the final kTagSize bytes of the message
-// match the expected value.
-class StrictTaggingDecrypter : public TaggingDecrypter {
- public:
- explicit StrictTaggingDecrypter(uint8_t tag) : tag_(tag) {}
- ~StrictTaggingDecrypter() override {}
-
- // TaggingQuicDecrypter
- uint8_t GetTag(StringPiece ciphertext) override { return tag_; }
-
- const char* cipher_name() const override { return "StrictTagging"; }
- // Use a distinct value starting with 0xFFFFFF, which is never used by TLS.
- uint32_t cipher_id() const override { return 0xFFFFFFF1; }
-
- private:
- const uint8_t tag_;
-};
-
-class TestConnectionHelper : public QuicConnectionHelperInterface {
- public:
- TestConnectionHelper(MockClock* clock, MockRandom* random_generator)
- : clock_(clock), random_generator_(random_generator) {
- clock_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
- }
-
- // QuicConnectionHelperInterface
- const QuicClock* GetClock() const override { return clock_; }
-
- QuicRandom* GetRandomGenerator() override { return random_generator_; }
-
- QuicBufferAllocator* GetBufferAllocator() override {
- return &buffer_allocator_;
- }
-
- private:
- MockClock* clock_;
- MockRandom* random_generator_;
- SimpleBufferAllocator buffer_allocator_;
-
- DISALLOW_COPY_AND_ASSIGN(TestConnectionHelper);
-};
-
-class TestAlarmFactory : public QuicAlarmFactory {
- public:
- class TestAlarm : public QuicAlarm {
- public:
- explicit TestAlarm(QuicArenaScopedPtr<QuicAlarm::Delegate> delegate)
- : QuicAlarm(std::move(delegate)) {}
-
- void SetImpl() override {}
- void CancelImpl() override {}
- using QuicAlarm::Fire;
- };
-
- TestAlarmFactory() {}
-
- QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) override {
- return new TestAlarm(QuicArenaScopedPtr<QuicAlarm::Delegate>(delegate));
- }
-
- QuicArenaScopedPtr<QuicAlarm> CreateAlarm(
- QuicArenaScopedPtr<QuicAlarm::Delegate> delegate,
- QuicConnectionArena* arena) override {
- return arena->New<TestAlarm>(std::move(delegate));
- }
-
- private:
- DISALLOW_COPY_AND_ASSIGN(TestAlarmFactory);
-};
-
-class TestPacketWriter : public QuicPacketWriter {
- public:
- TestPacketWriter(QuicVersion version, MockClock* clock)
- : version_(version),
- framer_(SupportedVersions(version_)),
- last_packet_size_(0),
- write_blocked_(false),
- write_should_fail_(false),
- block_on_next_write_(false),
- is_write_blocked_data_buffered_(false),
- final_bytes_of_last_packet_(0),
- final_bytes_of_previous_packet_(0),
- use_tagging_decrypter_(false),
- packets_write_attempts_(0),
- clock_(clock),
- write_pause_time_delta_(QuicTime::Delta::Zero()),
- max_packet_size_(kMaxPacketSize) {}
-
- // QuicPacketWriter interface
- WriteResult WritePacket(const char* buffer,
- size_t buf_len,
- const IPAddress& self_address,
- const IPEndPoint& peer_address,
- PerPacketOptions* options) override {
- QuicEncryptedPacket packet(buffer, buf_len);
- ++packets_write_attempts_;
-
- if (packet.length() >= sizeof(final_bytes_of_last_packet_)) {
- final_bytes_of_previous_packet_ = final_bytes_of_last_packet_;
- memcpy(&final_bytes_of_last_packet_, packet.data() + packet.length() - 4,
- sizeof(final_bytes_of_last_packet_));
- }
-
- if (use_tagging_decrypter_) {
- framer_.framer()->SetDecrypter(ENCRYPTION_NONE, new TaggingDecrypter);
- }
- EXPECT_TRUE(framer_.ProcessPacket(packet));
- if (block_on_next_write_) {
- write_blocked_ = true;
- block_on_next_write_ = false;
- }
- if (IsWriteBlocked()) {
- return WriteResult(WRITE_STATUS_BLOCKED, -1);
- }
-
- if (ShouldWriteFail()) {
- return WriteResult(WRITE_STATUS_ERROR, 0);
- }
-
- last_packet_size_ = packet.length();
-
- if (!write_pause_time_delta_.IsZero()) {
- clock_->AdvanceTime(write_pause_time_delta_);
- }
- return WriteResult(WRITE_STATUS_OK, last_packet_size_);
- }
-
- bool IsWriteBlockedDataBuffered() const override {
- return is_write_blocked_data_buffered_;
- }
-
- bool ShouldWriteFail() { return write_should_fail_; }
-
- bool IsWriteBlocked() const override { return write_blocked_; }
-
- void SetWritable() override { write_blocked_ = false; }
-
- void SetShouldWriteFail() { write_should_fail_ = true; }
-
- QuicByteCount GetMaxPacketSize(
- const IPEndPoint& /*peer_address*/) const override {
- return max_packet_size_;
- }
-
- void BlockOnNextWrite() { block_on_next_write_ = true; }
-
- // Sets the amount of time that the writer should before the actual write.
- void SetWritePauseTimeDelta(QuicTime::Delta delta) {
- write_pause_time_delta_ = delta;
- }
-
- const QuicPacketHeader& header() { return framer_.header(); }
-
- size_t frame_count() const { return framer_.num_frames(); }
-
- const vector<QuicAckFrame>& ack_frames() const {
- return framer_.ack_frames();
- }
-
- const vector<QuicStopWaitingFrame>& stop_waiting_frames() const {
- return framer_.stop_waiting_frames();
- }
-
- const vector<QuicConnectionCloseFrame>& connection_close_frames() const {
- return framer_.connection_close_frames();
- }
-
- const vector<QuicRstStreamFrame>& rst_stream_frames() const {
- return framer_.rst_stream_frames();
- }
-
- const vector<QuicStreamFrame*>& stream_frames() const {
- return framer_.stream_frames();
- }
-
- const vector<QuicPingFrame>& ping_frames() const {
- return framer_.ping_frames();
- }
-
- size_t last_packet_size() { return last_packet_size_; }
-
- const QuicVersionNegotiationPacket* version_negotiation_packet() {
- return framer_.version_negotiation_packet();
- }
-
- void set_is_write_blocked_data_buffered(bool buffered) {
- is_write_blocked_data_buffered_ = buffered;
- }
-
- void set_perspective(Perspective perspective) {
- // We invert perspective here, because the framer needs to parse packets
- // we send.
- QuicFramerPeer::SetPerspective(framer_.framer(),
- InvertPerspective(perspective));
- }
-
- // final_bytes_of_last_packet_ returns the last four bytes of the previous
- // packet as a little-endian, uint32_t. This is intended to be used with a
- // TaggingEncrypter so that tests can determine which encrypter was used for
- // a given packet.
- uint32_t final_bytes_of_last_packet() { return final_bytes_of_last_packet_; }
-
- // Returns the final bytes of the second to last packet.
- uint32_t final_bytes_of_previous_packet() {
- return final_bytes_of_previous_packet_;
- }
-
- void use_tagging_decrypter() { use_tagging_decrypter_ = true; }
-
- uint32_t packets_write_attempts() { return packets_write_attempts_; }
-
- void Reset() { framer_.Reset(); }
-
- void SetSupportedVersions(const QuicVersionVector& versions) {
- framer_.SetSupportedVersions(versions);
- }
-
- void set_max_packet_size(QuicByteCount max_packet_size) {
- max_packet_size_ = max_packet_size;
- }
-
- private:
- QuicVersion version_;
- SimpleQuicFramer framer_;
- size_t last_packet_size_;
- bool write_blocked_;
- bool write_should_fail_;
- bool block_on_next_write_;
- bool is_write_blocked_data_buffered_;
- uint32_t final_bytes_of_last_packet_;
- uint32_t final_bytes_of_previous_packet_;
- bool use_tagging_decrypter_;
- uint32_t packets_write_attempts_;
- MockClock* clock_;
- // If non-zero, the clock will pause during WritePacket for this amount of
- // time.
- QuicTime::Delta write_pause_time_delta_;
- QuicByteCount max_packet_size_;
-
- DISALLOW_COPY_AND_ASSIGN(TestPacketWriter);
-};
-
-class TestConnection : public QuicConnection {
- public:
- TestConnection(QuicConnectionId connection_id,
- IPEndPoint address,
- TestConnectionHelper* helper,
- TestAlarmFactory* alarm_factory,
- TestPacketWriter* writer,
- Perspective perspective,
- QuicVersion version)
- : QuicConnection(connection_id,
- address,
- helper,
- alarm_factory,
- writer,
- /* owns_writer= */ false,
- perspective,
- SupportedVersions(version)) {
- writer->set_perspective(perspective);
- }
-
- void SendAck() { QuicConnectionPeer::SendAck(this); }
-
- void SetSendAlgorithm(QuicPathId path_id,
- SendAlgorithmInterface* send_algorithm) {
- QuicConnectionPeer::SetSendAlgorithm(this, path_id, send_algorithm);
- }
-
- void SetLossAlgorithm(QuicPathId path_id,
- LossDetectionInterface* loss_algorithm) {
- QuicConnectionPeer::SetLossAlgorithm(this, path_id, loss_algorithm);
- }
-
- void SendPacket(EncryptionLevel level,
- QuicPathId path_id,
- QuicPacketNumber packet_number,
- QuicPacket* packet,
- QuicPacketEntropyHash entropy_hash,
- HasRetransmittableData retransmittable,
- bool has_ack,
- bool has_pending_frames) {
- char buffer[kMaxPacketSize];
- size_t encrypted_length =
- QuicConnectionPeer::GetFramer(this)->EncryptPayload(
- ENCRYPTION_NONE, path_id, packet_number, *packet, buffer,
- kMaxPacketSize);
- delete packet;
- SerializedPacket serialized_packet(
- kDefaultPathId, packet_number, PACKET_6BYTE_PACKET_NUMBER, buffer,
- encrypted_length, entropy_hash, has_ack, has_pending_frames);
- if (retransmittable == HAS_RETRANSMITTABLE_DATA) {
- serialized_packet.retransmittable_frames.push_back(
- QuicFrame(new QuicStreamFrame()));
- }
- OnSerializedPacket(&serialized_packet);
- }
-
- QuicConsumedData SendStreamDataWithString(
- QuicStreamId id,
- StringPiece data,
- QuicStreamOffset offset,
- bool fin,
- QuicAckListenerInterface* listener) {
- struct iovec iov;
- QuicIOVector data_iov(MakeIOVector(data, &iov));
- return QuicConnection::SendStreamData(id, data_iov, offset, fin, listener);
- }
-
- QuicConsumedData SendStreamData3() {
- return SendStreamDataWithString(kClientDataStreamId1, "food", 0, !kFin,
- nullptr);
- }
-
- QuicConsumedData SendStreamData5() {
- return SendStreamDataWithString(kClientDataStreamId2, "food2", 0, !kFin,
- nullptr);
- }
-
- // Ensures the connection can write stream data before writing.
- QuicConsumedData EnsureWritableAndSendStreamData5() {
- EXPECT_TRUE(CanWriteStreamData());
- return SendStreamData5();
- }
-
- // The crypto stream has special semantics so that it is not blocked by a
- // congestion window limitation, and also so that it gets put into a separate
- // packet (so that it is easier to reason about a crypto frame not being
- // split needlessly across packet boundaries). As a result, we have separate
- // tests for some cases for this stream.
- QuicConsumedData SendCryptoStreamData() {
- return SendStreamDataWithString(kCryptoStreamId, "chlo", 0, !kFin, nullptr);
- }
-
- void set_version(QuicVersion version) {
- QuicConnectionPeer::GetFramer(this)->set_version(version);
- }
-
- void SetSupportedVersions(const QuicVersionVector& versions) {
- QuicConnectionPeer::GetFramer(this)->SetSupportedVersions(versions);
- writer()->SetSupportedVersions(versions);
- }
-
- void set_perspective(Perspective perspective) {
- writer()->set_perspective(perspective);
- QuicConnectionPeer::SetPerspective(this, perspective);
- }
-
- // Enable path MTU discovery. Assumes that the test is performed from the
- // client perspective and the higher value of MTU target is used.
- void EnablePathMtuDiscovery(MockSendAlgorithm* send_algorithm) {
- ASSERT_EQ(Perspective::IS_CLIENT, perspective());
-
- QuicConfig config;
- QuicTagVector connection_options;
- connection_options.push_back(kMTUH);
- config.SetConnectionOptionsToSend(connection_options);
- EXPECT_CALL(*send_algorithm, SetFromConfig(_, _));
- SetFromConfig(config);
-
- // Normally, the pacing would be disabled in the test, but calling
- // SetFromConfig enables it. Set nearly-infinite bandwidth to make the
- // pacing algorithm work.
- EXPECT_CALL(*send_algorithm, PacingRate(_))
- .WillRepeatedly(Return(QuicBandwidth::FromKBytesPerSecond(10000)));
- }
-
- TestAlarmFactory::TestAlarm* GetAckAlarm() {
- return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- QuicConnectionPeer::GetAckAlarm(this));
- }
-
- TestAlarmFactory::TestAlarm* GetPingAlarm() {
- return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- QuicConnectionPeer::GetPingAlarm(this));
- }
-
- TestAlarmFactory::TestAlarm* GetResumeWritesAlarm() {
- return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- QuicConnectionPeer::GetResumeWritesAlarm(this));
- }
-
- TestAlarmFactory::TestAlarm* GetRetransmissionAlarm() {
- return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- QuicConnectionPeer::GetRetransmissionAlarm(this));
- }
-
- TestAlarmFactory::TestAlarm* GetSendAlarm() {
- return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- QuicConnectionPeer::GetSendAlarm(this));
- }
-
- TestAlarmFactory::TestAlarm* GetTimeoutAlarm() {
- return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- QuicConnectionPeer::GetTimeoutAlarm(this));
- }
-
- TestAlarmFactory::TestAlarm* GetMtuDiscoveryAlarm() {
- return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- QuicConnectionPeer::GetMtuDiscoveryAlarm(this));
- }
-
- void SetMaxTailLossProbes(QuicPathId path_id, size_t max_tail_loss_probes) {
- QuicSentPacketManagerPeer::SetMaxTailLossProbes(
- QuicConnectionPeer::GetSentPacketManager(this, path_id),
- max_tail_loss_probes);
- }
-
- QuicByteCount GetBytesInFlight(QuicPathId path_id) {
- return QuicSentPacketManagerPeer::GetBytesInFlight(
- QuicConnectionPeer::GetSentPacketManager(this, path_id));
- }
-
- using QuicConnection::SelectMutualVersion;
- using QuicConnection::set_defer_send_in_response_to_packets;
-
- private:
- TestPacketWriter* writer() {
- return static_cast<TestPacketWriter*>(QuicConnection::writer());
- }
-
- DISALLOW_COPY_AND_ASSIGN(TestConnection);
-};
-
-enum class AckResponse { kDefer, kImmediate };
-
-// Run tests with combinations of {QuicVersion, AckResponse}.
-struct TestParams {
- TestParams(QuicVersion version, AckResponse ack_response)
- : version(version), ack_response(ack_response) {}
-
- friend ostream& operator<<(ostream& os, const TestParams& p) {
- os << "{ client_version: " << QuicVersionToString(p.version)
- << " ack_response: "
- << (p.ack_response == AckResponse::kDefer ? "defer" : "immediate")
- << " }";
- return os;
- }
-
- QuicVersion version;
- AckResponse ack_response;
-};
-
-// Constructs various test permutations.
-vector<TestParams> GetTestParams() {
- vector<TestParams> params;
- QuicVersionVector all_supported_versions = QuicSupportedVersions();
- for (size_t i = 0; i < all_supported_versions.size(); ++i) {
- for (AckResponse ack_response :
- {AckResponse::kDefer, AckResponse::kImmediate}) {
- params.push_back(TestParams(all_supported_versions[i], ack_response));
- }
- }
- return params;
-}
-
-class QuicConnectionTest : public ::testing::TestWithParam<TestParams> {
- protected:
- QuicConnectionTest()
- : connection_id_(42),
- framer_(SupportedVersions(version()),
- QuicTime::Zero(),
- Perspective::IS_CLIENT),
- send_algorithm_(new StrictMock<MockSendAlgorithm>),
- loss_algorithm_(new MockLossAlgorithm()),
- helper_(new TestConnectionHelper(&clock_, &random_generator_)),
- alarm_factory_(new TestAlarmFactory()),
- peer_framer_(SupportedVersions(version()),
- QuicTime::Zero(),
- Perspective::IS_SERVER),
- peer_creator_(connection_id_,
- &peer_framer_,
- &random_generator_,
- &buffer_allocator_,
- /*delegate=*/nullptr),
- writer_(new TestPacketWriter(version(), &clock_)),
- connection_(connection_id_,
- kPeerAddress,
- helper_.get(),
- alarm_factory_.get(),
- writer_.get(),
- Perspective::IS_CLIENT,
- version()),
- creator_(QuicConnectionPeer::GetPacketCreator(&connection_)),
- generator_(QuicConnectionPeer::GetPacketGenerator(&connection_)),
- manager_(QuicConnectionPeer::GetSentPacketManager(&connection_,
- kDefaultPathId)),
- frame1_(1, false, 0, StringPiece(data1)),
- frame2_(1, false, 3, StringPiece(data2)),
- packet_number_length_(PACKET_6BYTE_PACKET_NUMBER),
- connection_id_length_(PACKET_8BYTE_CONNECTION_ID) {
- connection_.set_defer_send_in_response_to_packets(GetParam().ack_response ==
- AckResponse::kDefer);
- FLAGS_quic_always_log_bugs_for_tests = true;
- connection_.set_visitor(&visitor_);
- connection_.SetSendAlgorithm(kDefaultPathId, send_algorithm_);
- connection_.SetLossAlgorithm(kDefaultPathId, loss_algorithm_);
- framer_.set_received_entropy_calculator(&entropy_calculator_);
- peer_framer_.set_received_entropy_calculator(&peer_entropy_calculator_);
- EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _))
- .WillRepeatedly(Return(QuicTime::Delta::Zero()));
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
- .Times(AnyNumber());
- EXPECT_CALL(*send_algorithm_, RetransmissionDelay())
- .WillRepeatedly(Return(QuicTime::Delta::Zero()));
- EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
- .WillRepeatedly(Return(kDefaultTCPMSS));
- EXPECT_CALL(*send_algorithm_, PacingRate(_))
- .WillRepeatedly(Return(QuicBandwidth::Zero()));
- ON_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
- .WillByDefault(Return(true));
- EXPECT_CALL(*send_algorithm_, HasReliableBandwidthEstimate())
- .Times(AnyNumber());
- EXPECT_CALL(*send_algorithm_, BandwidthEstimate())
- .Times(AnyNumber())
- .WillRepeatedly(Return(QuicBandwidth::Zero()));
- EXPECT_CALL(*send_algorithm_, InSlowStart()).Times(AnyNumber());
- EXPECT_CALL(*send_algorithm_, InRecovery()).Times(AnyNumber());
- EXPECT_CALL(visitor_, WillingAndAbleToWrite()).Times(AnyNumber());
- EXPECT_CALL(visitor_, HasPendingHandshake()).Times(AnyNumber());
- EXPECT_CALL(visitor_, OnCanWrite()).Times(AnyNumber());
- EXPECT_CALL(visitor_, PostProcessAfterData()).Times(AnyNumber());
- EXPECT_CALL(visitor_, HasOpenDynamicStreams())
- .WillRepeatedly(Return(false));
- EXPECT_CALL(visitor_, OnCongestionWindowChange(_)).Times(AnyNumber());
-
- EXPECT_CALL(*loss_algorithm_, GetLossTimeout())
- .WillRepeatedly(Return(QuicTime::Zero()));
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _))
- .Times(AnyNumber());
- // TODO(ianswett): Fix QuicConnectionTests so they don't attempt to write
- // non-crypto stream data at ENCRYPTION_NONE.
- FLAGS_quic_never_write_unencrypted_data = false;
- }
-
- QuicVersion version() { return GetParam().version; }
-
- QuicAckFrame* outgoing_ack() {
- QuicFrame ack_frame = QuicConnectionPeer::GetUpdatedAckFrame(&connection_);
- ack_ = *ack_frame.ack_frame;
- return &ack_;
- }
-
- QuicStopWaitingFrame* stop_waiting() {
- QuicConnectionPeer::PopulateStopWaitingFrame(&connection_, &stop_waiting_);
- return &stop_waiting_;
- }
-
- QuicPacketNumber least_unacked() {
- if (writer_->stop_waiting_frames().empty()) {
- return 0;
- }
- return writer_->stop_waiting_frames()[0].least_unacked;
- }
-
- void use_tagging_decrypter() { writer_->use_tagging_decrypter(); }
-
- void ProcessPacket(QuicPathId path_id, QuicPacketNumber number) {
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacket(path_id, number, !kEntropyFlag);
- if (connection_.GetSendAlarm()->IsSet()) {
- connection_.GetSendAlarm()->Fire();
- }
- }
-
- QuicPacketEntropyHash ProcessFramePacket(QuicFrame frame) {
- return ProcessFramePacketWithAddresses(frame, kSelfAddress, kPeerAddress);
- }
-
- QuicPacketEntropyHash ProcessFramePacketWithAddresses(
- QuicFrame frame,
- IPEndPoint self_address,
- IPEndPoint peer_address) {
- QuicFrames frames;
- frames.push_back(QuicFrame(frame));
- QuicPacketCreatorPeer::SetSendVersionInPacket(
- &peer_creator_, connection_.perspective() == Perspective::IS_SERVER);
-
- char buffer[kMaxPacketSize];
- SerializedPacket serialized_packet =
- QuicPacketCreatorPeer::SerializeAllFrames(&peer_creator_, frames,
- buffer, kMaxPacketSize);
- connection_.ProcessUdpPacket(
- self_address, peer_address,
- QuicReceivedPacket(serialized_packet.encrypted_buffer,
- serialized_packet.encrypted_length, clock_.Now()));
- if (connection_.GetSendAlarm()->IsSet()) {
- connection_.GetSendAlarm()->Fire();
- }
- return serialized_packet.entropy_hash;
- }
-
- QuicPacketEntropyHash ProcessFramePacketAtLevel(QuicPathId path_id,
- QuicPacketNumber number,
- QuicFrame frame,
- EncryptionLevel level) {
- QuicPacketHeader header;
- header.public_header.connection_id = connection_id_;
- header.public_header.packet_number_length = packet_number_length_;
- header.public_header.connection_id_length = connection_id_length_;
- header.public_header.multipath_flag = path_id != kDefaultPathId;
- header.path_id = path_id;
- header.packet_number = number;
- QuicFrames frames;
- frames.push_back(frame);
- std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
-
- char buffer[kMaxPacketSize];
- size_t encrypted_length = framer_.EncryptPayload(
- level, path_id, number, *packet, buffer, kMaxPacketSize);
- connection_.ProcessUdpPacket(
- kSelfAddress, kPeerAddress,
- QuicReceivedPacket(buffer, encrypted_length, QuicTime::Zero(), false));
- return base::checked_cast<QuicPacketEntropyHash>(encrypted_length);
- }
-
- size_t ProcessDataPacket(QuicPathId path_id,
- QuicPacketNumber number,
- bool entropy_flag) {
- return ProcessDataPacketAtLevel(path_id, number, entropy_flag, false,
- ENCRYPTION_NONE);
- }
-
- size_t ProcessDataPacketAtLevel(QuicPathId path_id,
- QuicPacketNumber number,
- bool entropy_flag,
- bool has_stop_waiting,
- EncryptionLevel level) {
- std::unique_ptr<QuicPacket> packet(
- ConstructDataPacket(path_id, number, entropy_flag, has_stop_waiting));
- char buffer[kMaxPacketSize];
- size_t encrypted_length = framer_.EncryptPayload(
- level, path_id, number, *packet, buffer, kMaxPacketSize);
- connection_.ProcessUdpPacket(
- kSelfAddress, kPeerAddress,
- QuicReceivedPacket(buffer, encrypted_length, QuicTime::Zero(), false));
- if (connection_.GetSendAlarm()->IsSet()) {
- connection_.GetSendAlarm()->Fire();
- }
- return encrypted_length;
- }
-
- void ProcessClosePacket(QuicPathId path_id, QuicPacketNumber number) {
- std::unique_ptr<QuicPacket> packet(ConstructClosePacket(number));
- char buffer[kMaxPacketSize];
- size_t encrypted_length = framer_.EncryptPayload(
- ENCRYPTION_NONE, path_id, number, *packet, buffer, kMaxPacketSize);
- connection_.ProcessUdpPacket(
- kSelfAddress, kPeerAddress,
- QuicReceivedPacket(buffer, encrypted_length, QuicTime::Zero(), false));
- }
-
- QuicByteCount SendStreamDataToPeer(QuicStreamId id,
- StringPiece data,
- QuicStreamOffset offset,
- bool fin,
- QuicPacketNumber* last_packet) {
- QuicByteCount packet_size;
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
- .WillOnce(DoAll(SaveArg<3>(&packet_size), Return(true)));
- connection_.SendStreamDataWithString(id, data, offset, fin, nullptr);
- if (last_packet != nullptr) {
- *last_packet = creator_->packet_number();
- }
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
- .Times(AnyNumber());
- return packet_size;
- }
-
- void SendAckPacketToPeer() {
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
- connection_.SendAck();
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
- .Times(AnyNumber());
- }
-
- void ProcessAckPacket(QuicPacketNumber packet_number, QuicAckFrame* frame) {
- QuicPacketCreatorPeer::SetPacketNumber(&peer_creator_, packet_number - 1);
- ProcessFramePacket(QuicFrame(frame));
- }
-
- QuicPacketEntropyHash ProcessAckPacket(QuicAckFrame* frame) {
- return ProcessFramePacket(QuicFrame(frame));
- }
-
- QuicPacketEntropyHash ProcessStopWaitingPacket(QuicStopWaitingFrame* frame) {
- return ProcessFramePacket(QuicFrame(frame));
- }
-
- QuicPacketEntropyHash ProcessStopWaitingPacketAtLevel(
- QuicPathId path_id,
- QuicPacketNumber number,
- QuicStopWaitingFrame* frame,
- EncryptionLevel level) {
- return ProcessFramePacketAtLevel(path_id, number, QuicFrame(frame),
- ENCRYPTION_INITIAL);
- }
-
- QuicPacketEntropyHash ProcessGoAwayPacket(QuicGoAwayFrame* frame) {
- return ProcessFramePacket(QuicFrame(frame));
- }
-
- QuicPacketEntropyHash ProcessPathClosePacket(QuicPathCloseFrame* frame) {
- return ProcessFramePacket(QuicFrame(frame));
- }
-
- bool IsMissing(QuicPacketNumber number) {
- return IsAwaitingPacket(*outgoing_ack(), number, 0);
- }
-
- QuicPacket* ConstructPacket(QuicPacketHeader header, QuicFrames frames) {
- QuicPacket* packet = BuildUnsizedDataPacket(&peer_framer_, header, frames);
- EXPECT_NE(nullptr, packet);
- return packet;
- }
-
- QuicPacket* ConstructDataPacket(QuicPathId path_id,
- QuicPacketNumber number,
- bool entropy_flag,
- bool has_stop_waiting) {
- QuicPacketHeader header;
- header.public_header.connection_id = connection_id_;
- header.public_header.packet_number_length = packet_number_length_;
- header.public_header.connection_id_length = connection_id_length_;
- header.public_header.multipath_flag = path_id != kDefaultPathId;
- header.entropy_flag = entropy_flag;
- header.path_id = path_id;
- header.packet_number = number;
-
- QuicFrames frames;
- frames.push_back(QuicFrame(&frame1_));
- if (has_stop_waiting) {
- frames.push_back(QuicFrame(&stop_waiting_));
- }
- return ConstructPacket(header, frames);
- }
-
- QuicPacket* ConstructClosePacket(QuicPacketNumber number) {
- QuicPacketHeader header;
- header.public_header.connection_id = connection_id_;
- header.packet_number = number;
-
- QuicConnectionCloseFrame qccf;
- qccf.error_code = QUIC_PEER_GOING_AWAY;
-
- QuicFrames frames;
- frames.push_back(QuicFrame(&qccf));
- return ConstructPacket(header, frames);
- }
-
- QuicTime::Delta DefaultRetransmissionTime() {
- return QuicTime::Delta::FromMilliseconds(kDefaultRetransmissionTimeMs);
- }
-
- QuicTime::Delta DefaultDelayedAckTime() {
- return QuicTime::Delta::FromMilliseconds(kMaxDelayedAckTimeMs);
- }
-
- // Initialize a frame acknowledging all packets up to largest_observed.
- const QuicAckFrame InitAckFrame(QuicPacketNumber largest_observed) {
- QuicAckFrame frame(MakeAckFrame(largest_observed));
- if (GetParam().version <= QUIC_VERSION_33) {
- if (largest_observed > 0) {
- frame.entropy_hash = QuicConnectionPeer::GetSentEntropyHash(
- &connection_, largest_observed);
- }
- } else {
- frame.missing = false;
- if (largest_observed > 0) {
- frame.packets.Add(1, largest_observed + 1);
- }
- }
- return frame;
- }
-
- const QuicStopWaitingFrame InitStopWaitingFrame(
- QuicPacketNumber least_unacked) {
- QuicStopWaitingFrame frame;
- frame.least_unacked = least_unacked;
- return frame;
- }
-
- // Explicitly nack a packet.
- void NackPacket(QuicPacketNumber missing, QuicAckFrame* frame) {
- if (frame->missing) {
- frame->packets.Add(missing);
- frame->entropy_hash ^=
- QuicConnectionPeer::PacketEntropy(&connection_, missing);
- } else {
- frame->packets.Remove(missing);
- }
- }
-
- // Undo nacking a packet within the frame.
- void AckPacket(QuicPacketNumber arrived, QuicAckFrame* frame) {
- if (frame->missing) {
- EXPECT_TRUE(frame->packets.Contains(arrived));
- frame->packets.Remove(arrived);
- frame->entropy_hash ^=
- QuicConnectionPeer::PacketEntropy(&connection_, arrived);
- } else {
- EXPECT_FALSE(frame->packets.Contains(arrived));
- frame->packets.Add(arrived);
- }
- }
-
- void TriggerConnectionClose() {
- // Send an erroneous packet to close the connection.
- EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_INVALID_PACKET_HEADER, _,
- ConnectionCloseSource::FROM_SELF));
- // Call ProcessDataPacket rather than ProcessPacket, as we should not get a
- // packet call to the visitor.
- ProcessDataPacket(kDefaultPathId, 6000, !kEntropyFlag);
- EXPECT_FALSE(QuicConnectionPeer::GetConnectionClosePacket(&connection_) ==
- nullptr);
- }
-
- void BlockOnNextWrite() {
- writer_->BlockOnNextWrite();
- EXPECT_CALL(visitor_, OnWriteBlocked()).Times(AtLeast(1));
- }
-
- void SetWritePauseTimeDelta(QuicTime::Delta delta) {
- writer_->SetWritePauseTimeDelta(delta);
- }
-
- void CongestionBlockWrites() {
- EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _))
- .WillRepeatedly(testing::Return(QuicTime::Delta::FromSeconds(1)));
- }
-
- void CongestionUnblockWrites() {
- EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _))
- .WillRepeatedly(testing::Return(QuicTime::Delta::Zero()));
- }
-
- void set_perspective(Perspective perspective) {
- connection_.set_perspective(perspective);
- QuicFramerPeer::SetPerspective(&peer_framer_,
- InvertPerspective(perspective));
- }
-
- QuicConnectionId connection_id_;
- QuicFramer framer_;
- MockEntropyCalculator entropy_calculator_;
- MockEntropyCalculator peer_entropy_calculator_;
-
- MockSendAlgorithm* send_algorithm_;
- MockLossAlgorithm* loss_algorithm_;
- MockClock clock_;
- MockRandom random_generator_;
- SimpleBufferAllocator buffer_allocator_;
- std::unique_ptr<TestConnectionHelper> helper_;
- std::unique_ptr<TestAlarmFactory> alarm_factory_;
- QuicFramer peer_framer_;
- QuicPacketCreator peer_creator_;
- std::unique_ptr<TestPacketWriter> writer_;
- TestConnection connection_;
- QuicPacketCreator* creator_;
- QuicPacketGenerator* generator_;
- QuicSentPacketManagerInterface* manager_;
- StrictMock<MockQuicConnectionVisitor> visitor_;
-
- QuicStreamFrame frame1_;
- QuicStreamFrame frame2_;
- QuicAckFrame ack_;
- QuicStopWaitingFrame stop_waiting_;
- QuicPacketNumberLength packet_number_length_;
- QuicConnectionIdLength connection_id_length_;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(QuicConnectionTest);
-};
-
-// Run all end to end tests with all supported versions.
-INSTANTIATE_TEST_CASE_P(SupportedVersion,
- QuicConnectionTest,
- ::testing::ValuesIn(GetTestParams()));
-
-TEST_P(QuicConnectionTest, SelfAddressChangeAtClient) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- EXPECT_EQ(Perspective::IS_CLIENT, connection_.perspective());
- EXPECT_TRUE(connection_.connected());
-
- QuicStreamFrame stream_frame(1u, false, 0u, StringPiece());
- EXPECT_CALL(visitor_, OnStreamFrame(_));
- ProcessFramePacketWithAddresses(QuicFrame(&stream_frame), kSelfAddress,
- kPeerAddress);
- // Cause change in self_address.
- IPEndPoint self_address(IPAddress(1, 1, 1, 1), 123);
- EXPECT_CALL(visitor_, OnStreamFrame(_));
- ProcessFramePacketWithAddresses(QuicFrame(&stream_frame), self_address,
- kPeerAddress);
- EXPECT_TRUE(connection_.connected());
-}
-
-TEST_P(QuicConnectionTest, SelfAddressChangeAtServer) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- set_perspective(Perspective::IS_SERVER);
- QuicPacketCreatorPeer::SetSendVersionInPacket(creator_, false);
-
- EXPECT_EQ(Perspective::IS_SERVER, connection_.perspective());
- EXPECT_TRUE(connection_.connected());
-
- QuicStreamFrame stream_frame(1u, false, 0u, StringPiece());
- EXPECT_CALL(visitor_, OnStreamFrame(_));
- ProcessFramePacketWithAddresses(QuicFrame(&stream_frame), kSelfAddress,
- kPeerAddress);
- // Cause change in self_address.
- IPEndPoint self_address(IPAddress(1, 1, 1, 1), 123);
- EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_ERROR_MIGRATING_ADDRESS, _, _));
- ProcessFramePacketWithAddresses(QuicFrame(&stream_frame), self_address,
- kPeerAddress);
- EXPECT_FALSE(connection_.connected());
-}
-
-TEST_P(QuicConnectionTest, ClientAddressChangeAndPacketReordered) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- set_perspective(Perspective::IS_SERVER);
- QuicPacketCreatorPeer::SetSendVersionInPacket(creator_, false);
- // Clear peer address.
- QuicConnectionPeer::SetPeerAddress(&connection_, IPEndPoint());
-
- QuicPacketCreatorPeer::SetPacketNumber(&peer_creator_, 5);
- QuicStreamFrame stream_frame(1u, false, 0u, StringPiece());
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(AnyNumber());
- const IPEndPoint kNewPeerAddress = IPEndPoint(Loopback6(),
- /*port=*/23456);
- ProcessFramePacketWithAddresses(QuicFrame(&stream_frame), kSelfAddress,
- kNewPeerAddress);
-
- // Decrease packet number to simulate out-of-order packets.
- QuicPacketCreatorPeer::SetPacketNumber(&peer_creator_, 4);
- if (FLAGS_quic_do_not_migrate_on_old_packet) {
- // This is an old packet, do not migrate.
- EXPECT_CALL(visitor_, OnConnectionMigration(PORT_CHANGE)).Times(0);
- } else {
- // A connection migration is observed.
- EXPECT_CALL(visitor_, OnConnectionMigration(PORT_CHANGE));
- }
- ProcessFramePacketWithAddresses(QuicFrame(&stream_frame), kSelfAddress,
- kPeerAddress);
-}
-
-TEST_P(QuicConnectionTest, MaxPacketSize) {
- EXPECT_EQ(Perspective::IS_CLIENT, connection_.perspective());
- EXPECT_EQ(1350u, connection_.max_packet_length());
-}
-
-TEST_P(QuicConnectionTest, SmallerServerMaxPacketSize) {
- QuicConnectionId connection_id = 42;
- TestConnection connection(connection_id, kPeerAddress, helper_.get(),
- alarm_factory_.get(), writer_.get(),
- Perspective::IS_SERVER, version());
- EXPECT_EQ(Perspective::IS_SERVER, connection.perspective());
- EXPECT_EQ(1000u, connection.max_packet_length());
-}
-
-TEST_P(QuicConnectionTest, IncreaseServerMaxPacketSize) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- set_perspective(Perspective::IS_SERVER);
- connection_.SetMaxPacketLength(1000);
-
- QuicPacketHeader header;
- header.public_header.connection_id = connection_id_;
- header.public_header.version_flag = true;
- header.path_id = kDefaultPathId;
- header.packet_number = 1;
-
- QuicFrames frames;
- QuicPaddingFrame padding;
- frames.push_back(QuicFrame(&frame1_));
- frames.push_back(QuicFrame(padding));
- std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
- char buffer[kMaxPacketSize];
- size_t encrypted_length = framer_.EncryptPayload(
- ENCRYPTION_NONE, kDefaultPathId, 12, *packet, buffer, kMaxPacketSize);
- EXPECT_EQ(kMaxPacketSize, encrypted_length);
-
- framer_.set_version(version());
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- connection_.ProcessUdpPacket(
- kSelfAddress, kPeerAddress,
- QuicReceivedPacket(buffer, encrypted_length, QuicTime::Zero(), false));
-
- EXPECT_EQ(kMaxPacketSize, connection_.max_packet_length());
-}
-
-TEST_P(QuicConnectionTest, IncreaseServerMaxPacketSizeWhileWriterLimited) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- const QuicByteCount lower_max_packet_size = 1240;
- writer_->set_max_packet_size(lower_max_packet_size);
- set_perspective(Perspective::IS_SERVER);
- connection_.SetMaxPacketLength(1000);
- EXPECT_EQ(1000u, connection_.max_packet_length());
-
- QuicPacketHeader header;
- header.public_header.connection_id = connection_id_;
- header.public_header.version_flag = true;
- header.path_id = kDefaultPathId;
- header.packet_number = 1;
-
- QuicFrames frames;
- QuicPaddingFrame padding;
- frames.push_back(QuicFrame(&frame1_));
- frames.push_back(QuicFrame(padding));
- std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
- char buffer[kMaxPacketSize];
- size_t encrypted_length = framer_.EncryptPayload(
- ENCRYPTION_NONE, kDefaultPathId, 12, *packet, buffer, kMaxPacketSize);
- EXPECT_EQ(kMaxPacketSize, encrypted_length);
-
- framer_.set_version(version());
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- connection_.ProcessUdpPacket(
- kSelfAddress, kPeerAddress,
- QuicReceivedPacket(buffer, encrypted_length, QuicTime::Zero(), false));
-
- // Here, the limit imposed by the writer is lower than the size of the packet
- // received, so the writer max packet size is used.
- EXPECT_EQ(lower_max_packet_size, connection_.max_packet_length());
-}
-
-TEST_P(QuicConnectionTest, LimitMaxPacketSizeByWriter) {
- const QuicByteCount lower_max_packet_size = 1240;
- writer_->set_max_packet_size(lower_max_packet_size);
-
- static_assert(lower_max_packet_size < kDefaultMaxPacketSize,
- "Default maximum packet size is too low");
- connection_.SetMaxPacketLength(kDefaultMaxPacketSize);
-
- EXPECT_EQ(lower_max_packet_size, connection_.max_packet_length());
-}
-
-TEST_P(QuicConnectionTest, LimitMaxPacketSizeByWriterForNewConnection) {
- const QuicConnectionId connection_id = 17;
- const QuicByteCount lower_max_packet_size = 1240;
- writer_->set_max_packet_size(lower_max_packet_size);
- TestConnection connection(connection_id, kPeerAddress, helper_.get(),
- alarm_factory_.get(), writer_.get(),
- Perspective::IS_CLIENT, version());
- EXPECT_EQ(Perspective::IS_CLIENT, connection.perspective());
- EXPECT_EQ(lower_max_packet_size, connection.max_packet_length());
-}
-
-TEST_P(QuicConnectionTest, PacketsInOrder) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- ProcessPacket(kDefaultPathId, 1);
- EXPECT_EQ(1u, outgoing_ack()->largest_observed);
- if (outgoing_ack()->missing) {
- EXPECT_TRUE(outgoing_ack()->packets.Empty());
- } else {
- EXPECT_EQ(1u, outgoing_ack()->packets.NumIntervals());
- }
-
- ProcessPacket(kDefaultPathId, 2);
- EXPECT_EQ(2u, outgoing_ack()->largest_observed);
- if (outgoing_ack()->missing) {
- EXPECT_TRUE(outgoing_ack()->packets.Empty());
- } else {
- EXPECT_EQ(1u, outgoing_ack()->packets.NumIntervals());
- }
-
- ProcessPacket(kDefaultPathId, 3);
- EXPECT_EQ(3u, outgoing_ack()->largest_observed);
- if (outgoing_ack()->missing) {
- EXPECT_TRUE(outgoing_ack()->packets.Empty());
- } else {
- EXPECT_EQ(1u, outgoing_ack()->packets.NumIntervals());
- }
-}
-
-TEST_P(QuicConnectionTest, PacketsOutOfOrder) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- ProcessPacket(kDefaultPathId, 3);
- EXPECT_EQ(3u, outgoing_ack()->largest_observed);
- EXPECT_TRUE(IsMissing(2));
- EXPECT_TRUE(IsMissing(1));
-
- ProcessPacket(kDefaultPathId, 2);
- EXPECT_EQ(3u, outgoing_ack()->largest_observed);
- EXPECT_FALSE(IsMissing(2));
- EXPECT_TRUE(IsMissing(1));
-
- ProcessPacket(kDefaultPathId, 1);
- EXPECT_EQ(3u, outgoing_ack()->largest_observed);
- EXPECT_FALSE(IsMissing(2));
- EXPECT_FALSE(IsMissing(1));
-}
-
-TEST_P(QuicConnectionTest, DuplicatePacket) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- ProcessPacket(kDefaultPathId, 3);
- EXPECT_EQ(3u, outgoing_ack()->largest_observed);
- EXPECT_TRUE(IsMissing(2));
- EXPECT_TRUE(IsMissing(1));
-
- // Send packet 3 again, but do not set the expectation that
- // the visitor OnStreamFrame() will be called.
- ProcessDataPacket(kDefaultPathId, 3, !kEntropyFlag);
- EXPECT_EQ(3u, outgoing_ack()->largest_observed);
- EXPECT_TRUE(IsMissing(2));
- EXPECT_TRUE(IsMissing(1));
-}
-
-TEST_P(QuicConnectionTest, PacketsOutOfOrderWithAdditionsAndLeastAwaiting) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- ProcessPacket(kDefaultPathId, 3);
- EXPECT_EQ(3u, outgoing_ack()->largest_observed);
- EXPECT_TRUE(IsMissing(2));
- EXPECT_TRUE(IsMissing(1));
-
- ProcessPacket(kDefaultPathId, 2);
- EXPECT_EQ(3u, outgoing_ack()->largest_observed);
- EXPECT_TRUE(IsMissing(1));
-
- ProcessPacket(kDefaultPathId, 5);
- EXPECT_EQ(5u, outgoing_ack()->largest_observed);
- EXPECT_TRUE(IsMissing(1));
- EXPECT_TRUE(IsMissing(4));
-
- // Pretend at this point the client has gotten acks for 2 and 3 and 1 is a
- // packet the peer will not retransmit. It indicates this by sending 'least
- // awaiting' is 4. The connection should then realize 1 will not be
- // retransmitted, and will remove it from the missing list.
- QuicAckFrame frame = InitAckFrame(1);
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(_, _, _, _));
- ProcessAckPacket(6, &frame);
-
- // Force an ack to be sent.
- SendAckPacketToPeer();
- EXPECT_TRUE(IsMissing(4));
-}
-
-TEST_P(QuicConnectionTest, RejectPacketTooFarOut) {
- EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_INVALID_PACKET_HEADER, _,
- ConnectionCloseSource::FROM_SELF));
- // Call ProcessDataPacket rather than ProcessPacket, as we should not get a
- // packet call to the visitor.
- ProcessDataPacket(kDefaultPathId, 6000, !kEntropyFlag);
- EXPECT_FALSE(QuicConnectionPeer::GetConnectionClosePacket(&connection_) ==
- nullptr);
-}
-
-TEST_P(QuicConnectionTest, RejectUnencryptedStreamData) {
- // Process an unencrypted packet from the non-crypto stream.
- frame1_.stream_id = 3;
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_UNENCRYPTED_STREAM_DATA, _,
- ConnectionCloseSource::FROM_SELF));
- EXPECT_DFATAL(ProcessDataPacket(kDefaultPathId, 1, !kEntropyFlag), "");
- EXPECT_FALSE(QuicConnectionPeer::GetConnectionClosePacket(&connection_) ==
- nullptr);
- const vector<QuicConnectionCloseFrame>& connection_close_frames =
- writer_->connection_close_frames();
- EXPECT_EQ(1u, connection_close_frames.size());
- EXPECT_EQ(QUIC_UNENCRYPTED_STREAM_DATA,
- connection_close_frames[0].error_code);
-}
-
-TEST_P(QuicConnectionTest, TruncatedAck) {
- if (GetParam().version > QUIC_VERSION_33) {
- return;
- }
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- QuicPacketNumber num_packets = 256 * 2 + 1;
- for (QuicPacketNumber i = 0; i < num_packets; ++i) {
- SendStreamDataToPeer(3, "foo", i * 3, !kFin, nullptr);
- }
-
- QuicAckFrame frame = InitAckFrame(num_packets);
- // Create an ack with 256 nacks, none adjacent to one another.
- for (QuicPacketNumber i = 1; i <= 256; ++i) {
- NackPacket(i * 2, &frame);
- }
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _));
- EXPECT_CALL(peer_entropy_calculator_, EntropyHash(511))
- .WillOnce(Return(static_cast<QuicPacketEntropyHash>(0)));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- ProcessAckPacket(&frame);
-
- // A truncated ack will not have the true largest observed.
- EXPECT_GT(num_packets, manager_->GetLargestObserved(frame.path_id));
-
- AckPacket(192, &frame);
-
- // Removing one missing packet allows us to ack 192 and one more range, but
- // 192 has already been declared lost, so it doesn't register as an ack.
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- ProcessAckPacket(&frame);
- EXPECT_EQ(num_packets, manager_->GetLargestObserved(frame.path_id));
-}
-
-TEST_P(QuicConnectionTest, AckReceiptCausesAckSendBadEntropy) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- ProcessPacket(kDefaultPathId, 1);
- // Delay sending, then queue up an ack.
- QuicConnectionPeer::SendAck(&connection_);
-
- // Process an ack with a least unacked of the received ack.
- // This causes an ack to be sent when TimeUntilSend returns 0.
- EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _))
- .WillRepeatedly(testing::Return(QuicTime::Delta::Zero()));
- // Skip a packet and then record an ack.
- QuicAckFrame frame = InitAckFrame(0);
- ProcessAckPacket(3, &frame);
-}
-
-TEST_P(QuicConnectionTest, OutOfOrderReceiptCausesAckSend) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- ProcessPacket(kDefaultPathId, 3);
- // Should ack immediately since we have missing packets.
- EXPECT_EQ(1u, writer_->packets_write_attempts());
-
- ProcessPacket(kDefaultPathId, 2);
- // Should ack immediately since we have missing packets.
- EXPECT_EQ(2u, writer_->packets_write_attempts());
-
- ProcessPacket(kDefaultPathId, 1);
- // Should ack immediately, since this fills the last hole.
- EXPECT_EQ(3u, writer_->packets_write_attempts());
-
- ProcessPacket(kDefaultPathId, 4);
- // Should not cause an ack.
- EXPECT_EQ(3u, writer_->packets_write_attempts());
-}
-
-TEST_P(QuicConnectionTest, OutOfOrderAckReceiptCausesNoAck) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- SendStreamDataToPeer(1, "foo", 0, !kFin, nullptr);
- SendStreamDataToPeer(1, "bar", 3, !kFin, nullptr);
- EXPECT_EQ(2u, writer_->packets_write_attempts());
-
- QuicAckFrame ack1 = InitAckFrame(1);
- QuicAckFrame ack2 = InitAckFrame(2);
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- ProcessAckPacket(2, &ack2);
- // Should ack immediately since we have missing packets.
- EXPECT_EQ(2u, writer_->packets_write_attempts());
-
- ProcessAckPacket(1, &ack1);
- // Should not ack an ack filling a missing packet.
- EXPECT_EQ(2u, writer_->packets_write_attempts());
-}
-
-TEST_P(QuicConnectionTest, AckReceiptCausesAckSend) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- QuicPacketNumber original;
- QuicByteCount packet_size;
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
- .WillOnce(
- DoAll(SaveArg<2>(&original), SaveArg<3>(&packet_size), Return(true)));
- connection_.SendStreamDataWithString(3, "foo", 0, !kFin, nullptr);
- QuicAckFrame frame = InitAckFrame(original);
- NackPacket(original, &frame);
- // First nack triggers early retransmit.
- SendAlgorithmInterface::CongestionVector lost_packets;
- lost_packets.push_back(std::make_pair(1, kMaxPacketSize));
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _))
- .WillOnce(SetArgPointee<4>(lost_packets));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- QuicPacketNumber retransmission;
- EXPECT_CALL(*send_algorithm_,
- OnPacketSent(_, _, _, packet_size - kQuicVersionSize, _))
- .WillOnce(DoAll(SaveArg<2>(&retransmission), Return(true)));
-
- ProcessAckPacket(&frame);
-
- QuicAckFrame frame2 = InitAckFrame(retransmission);
- NackPacket(original, &frame2);
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _));
- ProcessAckPacket(&frame2);
-
- // Now if the peer sends an ack which still reports the retransmitted packet
- // as missing, that will bundle an ack with data after two acks in a row
- // indicate the high water mark needs to be raised.
- EXPECT_CALL(*send_algorithm_,
- OnPacketSent(_, _, _, _, HAS_RETRANSMITTABLE_DATA));
- connection_.SendStreamDataWithString(3, "foo", 3, !kFin, nullptr);
- // No ack sent.
- EXPECT_EQ(1u, writer_->frame_count());
- EXPECT_EQ(1u, writer_->stream_frames().size());
-
- // No more packet loss for the rest of the test.
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _)).Times(AnyNumber());
- ProcessAckPacket(&frame2);
- EXPECT_CALL(*send_algorithm_,
- OnPacketSent(_, _, _, _, HAS_RETRANSMITTABLE_DATA));
- connection_.SendStreamDataWithString(3, "foo", 3, !kFin, nullptr);
- // Ack bundled.
- EXPECT_EQ(3u, writer_->frame_count());
- EXPECT_EQ(1u, writer_->stream_frames().size());
- EXPECT_FALSE(writer_->ack_frames().empty());
-
- // But an ack with no missing packets will not send an ack.
- AckPacket(original, &frame2);
- ProcessAckPacket(&frame2);
- ProcessAckPacket(&frame2);
-}
-
-TEST_P(QuicConnectionTest, 20AcksCausesAckSend) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- SendStreamDataToPeer(1, "foo", 0, !kFin, nullptr);
-
- QuicAlarm* ack_alarm = QuicConnectionPeer::GetAckAlarm(&connection_);
- // But an ack with no missing packets will not send an ack.
- QuicAckFrame frame = InitAckFrame(1);
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- for (int i = 0; i < 19; ++i) {
- ProcessAckPacket(&frame);
- EXPECT_FALSE(ack_alarm->IsSet());
- }
- EXPECT_EQ(1u, writer_->packets_write_attempts());
- // The 20th ack packet will cause an ack to be sent.
- ProcessAckPacket(&frame);
- EXPECT_EQ(2u, writer_->packets_write_attempts());
-}
-
-TEST_P(QuicConnectionTest, LeastUnackedLower) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- SendStreamDataToPeer(1, "foo", 0, !kFin, nullptr);
- SendStreamDataToPeer(1, "bar", 3, !kFin, nullptr);
- SendStreamDataToPeer(1, "eep", 6, !kFin, nullptr);
-
- // Start out saying the least unacked is 2.
- QuicPacketCreatorPeer::SetPacketNumber(&peer_creator_, 5);
- QuicStopWaitingFrame frame = InitStopWaitingFrame(2);
- ProcessStopWaitingPacket(&frame);
-
- // Change it to 1, but lower the packet number to fake out-of-order packets.
- // This should be fine.
- QuicPacketCreatorPeer::SetPacketNumber(&peer_creator_, 1);
- // The scheduler will not process out of order acks, but all packet processing
- // causes the connection to try to write.
- EXPECT_CALL(visitor_, OnCanWrite());
- QuicStopWaitingFrame frame2 = InitStopWaitingFrame(1);
- ProcessStopWaitingPacket(&frame2);
-
- // Now claim it's one, but set the ordering so it was sent "after" the first
- // one. This should cause a connection error.
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
- QuicPacketCreatorPeer::SetPacketNumber(&peer_creator_, 7);
- EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_INVALID_STOP_WAITING_DATA, _,
- ConnectionCloseSource::FROM_SELF));
- QuicStopWaitingFrame frame3 = InitStopWaitingFrame(1);
- ProcessStopWaitingPacket(&frame3);
-}
-
-TEST_P(QuicConnectionTest, TooManySentPackets) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- const int num_packets = kMaxTrackedPackets + 100;
- for (int i = 0; i < num_packets; ++i) {
- SendStreamDataToPeer(1, "foo", 3 * i, !kFin, nullptr);
- }
-
- // Ack packet 1, which leaves more than the limit outstanding.
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- if (GetParam().version <= QUIC_VERSION_33) {
- EXPECT_CALL(visitor_,
- OnConnectionClosed(QUIC_TOO_MANY_OUTSTANDING_SENT_PACKETS, _,
- ConnectionCloseSource::FROM_SELF));
- // We're receive buffer limited, so the connection won't try to write more.
- EXPECT_CALL(visitor_, OnCanWrite()).Times(0);
- }
-
- // Nack the first packet and ack the rest, leaving a huge gap.
- QuicAckFrame frame1 = InitAckFrame(num_packets);
- NackPacket(1, &frame1);
- ProcessAckPacket(&frame1);
-}
-
-TEST_P(QuicConnectionTest, TooManyReceivedPackets) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- if (GetParam().version <= QUIC_VERSION_33) {
- EXPECT_CALL(visitor_,
- OnConnectionClosed(QUIC_TOO_MANY_OUTSTANDING_RECEIVED_PACKETS,
- _, ConnectionCloseSource::FROM_SELF));
- }
- // Miss 99 of every 100 packets for 5500 packets.
- for (QuicPacketNumber i = 1; i < kMaxTrackedPackets + 500; i += 100) {
- ProcessPacket(kDefaultPathId, i);
- if (!connection_.connected()) {
- break;
- }
- }
-}
-
-TEST_P(QuicConnectionTest, LargestObservedLower) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- SendStreamDataToPeer(1, "foo", 0, !kFin, nullptr);
- SendStreamDataToPeer(1, "bar", 3, !kFin, nullptr);
- SendStreamDataToPeer(1, "eep", 6, !kFin, nullptr);
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
-
- // Start out saying the largest observed is 2.
- QuicAckFrame frame1 = InitAckFrame(1);
- QuicAckFrame frame2 = InitAckFrame(2);
- ProcessAckPacket(&frame2);
-
- // Now change it to 1, and it should cause a connection error.
- EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_INVALID_ACK_DATA, _,
- ConnectionCloseSource::FROM_SELF));
- EXPECT_CALL(visitor_, OnCanWrite()).Times(0);
- ProcessAckPacket(&frame1);
-}
-
-TEST_P(QuicConnectionTest, AckUnsentData) {
- // Ack a packet which has not been sent.
- EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_INVALID_ACK_DATA, _,
- ConnectionCloseSource::FROM_SELF));
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
- QuicAckFrame frame(MakeAckFrame(1));
- EXPECT_CALL(visitor_, OnCanWrite()).Times(0);
- ProcessAckPacket(&frame);
-}
-
-TEST_P(QuicConnectionTest, AckAll) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- ProcessPacket(kDefaultPathId, 1);
-
- QuicPacketCreatorPeer::SetPacketNumber(&peer_creator_, 1);
- QuicAckFrame frame1 = InitAckFrame(0);
- ProcessAckPacket(&frame1);
-}
-
-TEST_P(QuicConnectionTest, BasicSending) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- QuicPacketNumber last_packet;
- SendStreamDataToPeer(1, "foo", 0, !kFin, &last_packet); // Packet 1
- EXPECT_EQ(1u, last_packet);
- SendAckPacketToPeer(); // Packet 2
-
- EXPECT_EQ(1u, least_unacked());
-
- SendAckPacketToPeer(); // Packet 3
- EXPECT_EQ(1u, least_unacked());
-
- SendStreamDataToPeer(1, "bar", 3, !kFin, &last_packet); // Packet 4
- EXPECT_EQ(4u, last_packet);
- SendAckPacketToPeer(); // Packet 5
- EXPECT_EQ(1u, least_unacked());
-
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
-
- // Peer acks up to packet 3.
- QuicAckFrame frame = InitAckFrame(3);
- ProcessAckPacket(&frame);
- SendAckPacketToPeer(); // Packet 6
-
- // As soon as we've acked one, we skip ack packets 2 and 3 and note lack of
- // ack for 4.
- EXPECT_EQ(4u, least_unacked());
-
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
-
- // Peer acks up to packet 4, the last packet.
- QuicAckFrame frame2 = InitAckFrame(6);
- ProcessAckPacket(&frame2); // Acks don't instigate acks.
-
- // Verify that we did not send an ack.
- EXPECT_EQ(6u, writer_->header().packet_number);
-
- // So the last ack has not changed.
- EXPECT_EQ(4u, least_unacked());
-
- // If we force an ack, we shouldn't change our retransmit state.
- SendAckPacketToPeer(); // Packet 7
- EXPECT_EQ(7u, least_unacked());
-
- // But if we send more data it should.
- SendStreamDataToPeer(1, "eep", 6, !kFin, &last_packet); // Packet 8
- EXPECT_EQ(8u, last_packet);
- SendAckPacketToPeer(); // Packet 9
- EXPECT_EQ(7u, least_unacked());
-}
-
-// QuicConnection should record the the packet sent-time prior to sending the
-// packet.
-TEST_P(QuicConnectionTest, RecordSentTimeBeforePacketSent) {
- // We're using a MockClock for the tests, so we have complete control over the
- // time.
- // Our recorded timestamp for the last packet sent time will be passed in to
- // the send_algorithm. Make sure that it is set to the correct value.
- QuicTime actual_recorded_send_time = QuicTime::Zero();
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
- .WillOnce(DoAll(SaveArg<0>(&actual_recorded_send_time), Return(true)));
-
- // First send without any pause and check the result.
- QuicTime expected_recorded_send_time = clock_.Now();
- connection_.SendStreamDataWithString(1, "foo", 0, !kFin, nullptr);
- EXPECT_EQ(expected_recorded_send_time, actual_recorded_send_time)
- << "Expected time = " << expected_recorded_send_time.ToDebuggingValue()
- << ". Actual time = " << actual_recorded_send_time.ToDebuggingValue();
-
- // Now pause during the write, and check the results.
- actual_recorded_send_time = QuicTime::Zero();
- const QuicTime::Delta write_pause_time_delta =
- QuicTime::Delta::FromMilliseconds(5000);
- SetWritePauseTimeDelta(write_pause_time_delta);
- expected_recorded_send_time = clock_.Now();
-
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
- .WillOnce(DoAll(SaveArg<0>(&actual_recorded_send_time), Return(true)));
- connection_.SendStreamDataWithString(2, "baz", 0, !kFin, nullptr);
- EXPECT_EQ(expected_recorded_send_time, actual_recorded_send_time)
- << "Expected time = " << expected_recorded_send_time.ToDebuggingValue()
- << ". Actual time = " << actual_recorded_send_time.ToDebuggingValue();
-}
-
-TEST_P(QuicConnectionTest, FramePacking) {
- // Send an ack and two stream frames in 1 packet by queueing them.
- {
- QuicConnection::ScopedPacketBundler bundler(&connection_,
- QuicConnection::SEND_ACK);
- connection_.SendStreamData3();
- connection_.SendStreamData5();
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
- }
- EXPECT_EQ(0u, connection_.NumQueuedPackets());
- EXPECT_FALSE(connection_.HasQueuedData());
-
- // Parse the last packet and ensure it's an ack and two stream frames from
- // two different streams.
- EXPECT_EQ(4u, writer_->frame_count());
- EXPECT_FALSE(writer_->stop_waiting_frames().empty());
- EXPECT_FALSE(writer_->ack_frames().empty());
- ASSERT_EQ(2u, writer_->stream_frames().size());
- EXPECT_EQ(kClientDataStreamId1, writer_->stream_frames()[0]->stream_id);
- EXPECT_EQ(kClientDataStreamId2, writer_->stream_frames()[1]->stream_id);
-}
-
-TEST_P(QuicConnectionTest, FramePackingNonCryptoThenCrypto) {
- // Send an ack and two stream frames (one non-crypto, then one crypto) in 2
- // packets by queueing them.
- {
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(2);
- QuicConnection::ScopedPacketBundler bundler(&connection_,
- QuicConnection::SEND_ACK);
- connection_.SendStreamData3();
- connection_.SendCryptoStreamData();
- }
- EXPECT_EQ(0u, connection_.NumQueuedPackets());
- EXPECT_FALSE(connection_.HasQueuedData());
-
- // Parse the last packet and ensure it's the crypto stream frame.
- EXPECT_EQ(1u, writer_->frame_count());
- ASSERT_EQ(1u, writer_->stream_frames().size());
- EXPECT_EQ(kCryptoStreamId, writer_->stream_frames()[0]->stream_id);
-}
-
-TEST_P(QuicConnectionTest, FramePackingCryptoThenNonCrypto) {
- // Send an ack and two stream frames (one crypto, then one non-crypto) in 2
- // packets by queueing them.
- {
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(2);
- QuicConnection::ScopedPacketBundler bundler(&connection_,
- QuicConnection::SEND_ACK);
- connection_.SendCryptoStreamData();
- connection_.SendStreamData3();
- }
- EXPECT_EQ(0u, connection_.NumQueuedPackets());
- EXPECT_FALSE(connection_.HasQueuedData());
-
- // Parse the last packet and ensure it's the stream frame from stream 3.
- EXPECT_EQ(1u, writer_->frame_count());
- ASSERT_EQ(1u, writer_->stream_frames().size());
- EXPECT_EQ(kClientDataStreamId1, writer_->stream_frames()[0]->stream_id);
-}
-
-TEST_P(QuicConnectionTest, FramePackingAckResponse) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- // Process a data packet to queue up a pending ack.
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacket(kDefaultPathId, 1, kEntropyFlag);
-
- EXPECT_CALL(visitor_, OnCanWrite())
- .WillOnce(DoAll(IgnoreResult(InvokeWithoutArgs(
- &connection_, &TestConnection::SendStreamData3)),
- IgnoreResult(InvokeWithoutArgs(
- &connection_, &TestConnection::SendStreamData5))));
-
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
-
- // Process an ack to cause the visitor's OnCanWrite to be invoked.
- QuicAckFrame ack_one = InitAckFrame(0);
- ProcessAckPacket(3, &ack_one);
-
- EXPECT_EQ(0u, connection_.NumQueuedPackets());
- EXPECT_FALSE(connection_.HasQueuedData());
-
- // Parse the last packet and ensure it's an ack and two stream frames from
- // two different streams.
- EXPECT_EQ(4u, writer_->frame_count());
- EXPECT_FALSE(writer_->stop_waiting_frames().empty());
- EXPECT_FALSE(writer_->ack_frames().empty());
- ASSERT_EQ(2u, writer_->stream_frames().size());
- EXPECT_EQ(kClientDataStreamId1, writer_->stream_frames()[0]->stream_id);
- EXPECT_EQ(kClientDataStreamId2, writer_->stream_frames()[1]->stream_id);
-}
-
-TEST_P(QuicConnectionTest, FramePackingSendv) {
- // Send data in 1 packet by writing multiple blocks in a single iovector
- // using writev.
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
-
- char data[] = "ABCD";
- struct iovec iov[2];
- iov[0].iov_base = data;
- iov[0].iov_len = 2;
- iov[1].iov_base = data + 2;
- iov[1].iov_len = 2;
- connection_.SendStreamData(1, QuicIOVector(iov, 2, 4), 0, !kFin, nullptr);
-
- EXPECT_EQ(0u, connection_.NumQueuedPackets());
- EXPECT_FALSE(connection_.HasQueuedData());
-
- // Parse the last packet and ensure multiple iovector blocks have
- // been packed into a single stream frame from one stream.
- EXPECT_EQ(1u, writer_->frame_count());
- EXPECT_EQ(1u, writer_->stream_frames().size());
- QuicStreamFrame* frame = writer_->stream_frames()[0];
- EXPECT_EQ(1u, frame->stream_id);
- EXPECT_EQ("ABCD", StringPiece(frame->data_buffer, frame->data_length));
-}
-
-TEST_P(QuicConnectionTest, FramePackingSendvQueued) {
- // Try to send two stream frames in 1 packet by using writev.
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
-
- BlockOnNextWrite();
- char data[] = "ABCD";
- struct iovec iov[2];
- iov[0].iov_base = data;
- iov[0].iov_len = 2;
- iov[1].iov_base = data + 2;
- iov[1].iov_len = 2;
- connection_.SendStreamData(1, QuicIOVector(iov, 2, 4), 0, !kFin, nullptr);
-
- EXPECT_EQ(1u, connection_.NumQueuedPackets());
- EXPECT_TRUE(connection_.HasQueuedData());
-
- // Unblock the writes and actually send.
- writer_->SetWritable();
- connection_.OnCanWrite();
- EXPECT_EQ(0u, connection_.NumQueuedPackets());
-
- // Parse the last packet and ensure it's one stream frame from one stream.
- EXPECT_EQ(1u, writer_->frame_count());
- EXPECT_EQ(1u, writer_->stream_frames().size());
- EXPECT_EQ(1u, writer_->stream_frames()[0]->stream_id);
-}
-
-TEST_P(QuicConnectionTest, SendingZeroBytes) {
- // Send a zero byte write with a fin using writev.
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
- QuicIOVector empty_iov(nullptr, 0, 0);
- connection_.SendStreamData(kHeadersStreamId, empty_iov, 0, kFin, nullptr);
-
- EXPECT_EQ(0u, connection_.NumQueuedPackets());
- EXPECT_FALSE(connection_.HasQueuedData());
-
- // Parse the last packet and ensure it's one stream frame from one stream.
- EXPECT_EQ(1u, writer_->frame_count());
- EXPECT_EQ(1u, writer_->stream_frames().size());
- EXPECT_EQ(kHeadersStreamId, writer_->stream_frames()[0]->stream_id);
- EXPECT_TRUE(writer_->stream_frames()[0]->fin);
-}
-
-TEST_P(QuicConnectionTest, LargeSendWithPendingAck) {
- // Set the ack alarm by processing a ping frame.
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- // Processs a PING frame.
- ProcessFramePacket(QuicFrame(QuicPingFrame()));
- // Ensure that this has caused the ACK alarm to be set.
- QuicAlarm* ack_alarm = QuicConnectionPeer::GetAckAlarm(&connection_);
- EXPECT_TRUE(ack_alarm->IsSet());
-
- // Send data and ensure the ack is bundled.
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(8);
- size_t len = 10000;
- std::unique_ptr<char[]> data_array(new char[len]);
- memset(data_array.get(), '?', len);
- struct iovec iov;
- iov.iov_base = data_array.get();
- iov.iov_len = len;
- QuicIOVector iovector(&iov, 1, len);
- QuicConsumedData consumed =
- connection_.SendStreamData(kHeadersStreamId, iovector, 0, true, nullptr);
- EXPECT_EQ(len, consumed.bytes_consumed);
- EXPECT_TRUE(consumed.fin_consumed);
- EXPECT_EQ(0u, connection_.NumQueuedPackets());
- EXPECT_FALSE(connection_.HasQueuedData());
-
- // Parse the last packet and ensure it's one stream frame with a fin.
- EXPECT_EQ(1u, writer_->frame_count());
- EXPECT_EQ(1u, writer_->stream_frames().size());
- EXPECT_EQ(kHeadersStreamId, writer_->stream_frames()[0]->stream_id);
- EXPECT_TRUE(writer_->stream_frames()[0]->fin);
- // Ensure the ack alarm was cancelled when the ack was sent.
- EXPECT_FALSE(ack_alarm->IsSet());
-}
-
-TEST_P(QuicConnectionTest, OnCanWrite) {
- // Visitor's OnCanWrite will send data, but will have more pending writes.
- EXPECT_CALL(visitor_, OnCanWrite())
- .WillOnce(DoAll(IgnoreResult(InvokeWithoutArgs(
- &connection_, &TestConnection::SendStreamData3)),
- IgnoreResult(InvokeWithoutArgs(
- &connection_, &TestConnection::SendStreamData5))));
- EXPECT_CALL(visitor_, WillingAndAbleToWrite()).WillOnce(Return(true));
- EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _))
- .WillRepeatedly(testing::Return(QuicTime::Delta::Zero()));
-
- connection_.OnCanWrite();
-
- // Parse the last packet and ensure it's the two stream frames from
- // two different streams.
- EXPECT_EQ(2u, writer_->frame_count());
- EXPECT_EQ(2u, writer_->stream_frames().size());
- EXPECT_EQ(kClientDataStreamId1, writer_->stream_frames()[0]->stream_id);
- EXPECT_EQ(kClientDataStreamId2, writer_->stream_frames()[1]->stream_id);
-}
-
-TEST_P(QuicConnectionTest, RetransmitOnNack) {
- QuicPacketNumber last_packet;
- QuicByteCount second_packet_size;
- SendStreamDataToPeer(3, "foo", 0, !kFin, &last_packet); // Packet 1
- second_packet_size =
- SendStreamDataToPeer(3, "foos", 3, !kFin, &last_packet); // Packet 2
- SendStreamDataToPeer(3, "fooos", 7, !kFin, &last_packet); // Packet 3
-
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- // Don't lose a packet on an ack, and nothing is retransmitted.
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- QuicAckFrame ack_one = InitAckFrame(1);
- ProcessAckPacket(&ack_one);
-
- // Lose a packet and ensure it triggers retransmission.
- QuicAckFrame nack_two = InitAckFrame(3);
- NackPacket(2, &nack_two);
- SendAlgorithmInterface::CongestionVector lost_packets;
- lost_packets.push_back(std::make_pair(2, kMaxPacketSize));
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _))
- .WillOnce(SetArgPointee<4>(lost_packets));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- EXPECT_CALL(*send_algorithm_,
- OnPacketSent(_, _, _, second_packet_size - kQuicVersionSize, _))
- .Times(1);
- ProcessAckPacket(&nack_two);
-}
-
-TEST_P(QuicConnectionTest, DoNotSendQueuedPacketForResetStream) {
- // Block the connection to queue the packet.
- BlockOnNextWrite();
-
- QuicStreamId stream_id = 2;
- connection_.SendStreamDataWithString(stream_id, "foo", 0, !kFin, nullptr);
-
- // Now that there is a queued packet, reset the stream.
- connection_.SendRstStream(stream_id, QUIC_ERROR_PROCESSING_STREAM, 14);
-
- // Unblock the connection and verify that only the RST_STREAM is sent.
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
- writer_->SetWritable();
- connection_.OnCanWrite();
- EXPECT_EQ(1u, writer_->frame_count());
- EXPECT_EQ(1u, writer_->rst_stream_frames().size());
-}
-
-TEST_P(QuicConnectionTest, SendQueuedPacketForQuicRstStreamNoError) {
- // Block the connection to queue the packet.
- BlockOnNextWrite();
-
- QuicStreamId stream_id = 2;
- connection_.SendStreamDataWithString(stream_id, "foo", 0, !kFin, nullptr);
-
- // Now that there is a queued packet, reset the stream.
- connection_.SendRstStream(stream_id, QUIC_STREAM_NO_ERROR, 14);
-
- // Unblock the connection and verify that the RST_STREAM is sent and the data
- // packet is sent.
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(AtLeast(2));
- writer_->SetWritable();
- connection_.OnCanWrite();
- EXPECT_EQ(1u, writer_->frame_count());
- EXPECT_EQ(1u, writer_->rst_stream_frames().size());
-}
-
-TEST_P(QuicConnectionTest, DoNotRetransmitForResetStreamOnNack) {
- QuicStreamId stream_id = 2;
- QuicPacketNumber last_packet;
- SendStreamDataToPeer(stream_id, "foo", 0, !kFin, &last_packet);
- SendStreamDataToPeer(stream_id, "foos", 3, !kFin, &last_packet);
- SendStreamDataToPeer(stream_id, "fooos", 7, !kFin, &last_packet);
-
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
- connection_.SendRstStream(stream_id, QUIC_ERROR_PROCESSING_STREAM, 14);
-
- // Lose a packet and ensure it does not trigger retransmission.
- QuicAckFrame nack_two = InitAckFrame(last_packet);
- NackPacket(last_packet - 1, &nack_two);
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
- ProcessAckPacket(&nack_two);
-}
-
-TEST_P(QuicConnectionTest, RetransmitForQuicRstStreamNoErrorOnNack) {
- QuicStreamId stream_id = 2;
- QuicPacketNumber last_packet;
- SendStreamDataToPeer(stream_id, "foo", 0, !kFin, &last_packet);
- SendStreamDataToPeer(stream_id, "foos", 3, !kFin, &last_packet);
- SendStreamDataToPeer(stream_id, "fooos", 7, !kFin, &last_packet);
-
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
- connection_.SendRstStream(stream_id, QUIC_STREAM_NO_ERROR, 14);
-
- // Lose a packet, ensure it triggers retransmission.
- QuicAckFrame nack_two = InitAckFrame(last_packet);
- NackPacket(last_packet - 1, &nack_two);
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- SendAlgorithmInterface::CongestionVector lost_packets;
- lost_packets.push_back(std::make_pair(last_packet - 1, kMaxPacketSize));
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _))
- .WillOnce(SetArgPointee<4>(lost_packets));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(AtLeast(1));
- ProcessAckPacket(&nack_two);
-}
-
-TEST_P(QuicConnectionTest, DoNotRetransmitForResetStreamOnRTO) {
- QuicStreamId stream_id = 2;
- QuicPacketNumber last_packet;
- SendStreamDataToPeer(stream_id, "foo", 0, !kFin, &last_packet);
-
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
- connection_.SendRstStream(stream_id, QUIC_ERROR_PROCESSING_STREAM, 14);
-
- // Fire the RTO and verify that the RST_STREAM is resent, not stream data.
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
- clock_.AdvanceTime(DefaultRetransmissionTime());
- connection_.GetRetransmissionAlarm()->Fire();
- EXPECT_EQ(1u, writer_->frame_count());
- EXPECT_EQ(1u, writer_->rst_stream_frames().size());
- EXPECT_EQ(stream_id, writer_->rst_stream_frames().front().stream_id);
-}
-
-TEST_P(QuicConnectionTest, RetransmitForQuicRstStreamNoErrorOnRTO) {
- connection_.SetMaxTailLossProbes(kDefaultPathId, 0);
-
- QuicStreamId stream_id = 2;
- QuicPacketNumber last_packet;
- SendStreamDataToPeer(stream_id, "foo", 0, !kFin, &last_packet);
-
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
- connection_.SendRstStream(stream_id, QUIC_STREAM_NO_ERROR, 14);
-
- // Fire the RTO and verify that the RST_STREAM is resent, the stream data
- // is sent.
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(AtLeast(2));
- clock_.AdvanceTime(DefaultRetransmissionTime());
- connection_.GetRetransmissionAlarm()->Fire();
- EXPECT_EQ(1u, writer_->frame_count());
- ASSERT_EQ(1u, writer_->rst_stream_frames().size());
- EXPECT_EQ(stream_id, writer_->rst_stream_frames().front().stream_id);
-}
-
-TEST_P(QuicConnectionTest, DoNotSendPendingRetransmissionForResetStream) {
- QuicStreamId stream_id = 2;
- QuicPacketNumber last_packet;
- SendStreamDataToPeer(stream_id, "foo", 0, !kFin, &last_packet);
- SendStreamDataToPeer(stream_id, "foos", 3, !kFin, &last_packet);
- BlockOnNextWrite();
- connection_.SendStreamDataWithString(stream_id, "fooos", 7, !kFin, nullptr);
-
- // Lose a packet which will trigger a pending retransmission.
- QuicAckFrame ack = InitAckFrame(last_packet);
- NackPacket(last_packet - 1, &ack);
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
- ProcessAckPacket(&ack);
-
- connection_.SendRstStream(stream_id, QUIC_ERROR_PROCESSING_STREAM, 14);
-
- // Unblock the connection and verify that the RST_STREAM is sent but not the
- // second data packet nor a retransmit.
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
- writer_->SetWritable();
- connection_.OnCanWrite();
- EXPECT_EQ(1u, writer_->frame_count());
- EXPECT_EQ(1u, writer_->rst_stream_frames().size());
- EXPECT_EQ(stream_id, writer_->rst_stream_frames().front().stream_id);
-}
-
-TEST_P(QuicConnectionTest, SendPendingRetransmissionForQuicRstStreamNoError) {
- QuicStreamId stream_id = 2;
- QuicPacketNumber last_packet;
- SendStreamDataToPeer(stream_id, "foo", 0, !kFin, &last_packet);
- SendStreamDataToPeer(stream_id, "foos", 3, !kFin, &last_packet);
- BlockOnNextWrite();
- connection_.SendStreamDataWithString(stream_id, "fooos", 7, !kFin, nullptr);
-
- // Lose a packet which will trigger a pending retransmission.
- QuicAckFrame ack = InitAckFrame(last_packet);
- NackPacket(last_packet - 1, &ack);
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- SendAlgorithmInterface::CongestionVector lost_packets;
- lost_packets.push_back(std::make_pair(last_packet - 1, kMaxPacketSize));
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _))
- .WillOnce(SetArgPointee<4>(lost_packets));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
- ProcessAckPacket(&ack);
-
- connection_.SendRstStream(stream_id, QUIC_STREAM_NO_ERROR, 14);
-
- // Unblock the connection and verify that the RST_STREAM is sent and the
- // second data packet or a retransmit is sent.
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(AtLeast(2));
- writer_->SetWritable();
- connection_.OnCanWrite();
- EXPECT_EQ(1u, writer_->frame_count());
- EXPECT_EQ(0u, writer_->rst_stream_frames().size());
-}
-
-TEST_P(QuicConnectionTest, RetransmitAckedPacket) {
- QuicPacketNumber last_packet;
- SendStreamDataToPeer(1, "foo", 0, !kFin, &last_packet); // Packet 1
- SendStreamDataToPeer(1, "foos", 3, !kFin, &last_packet); // Packet 2
- SendStreamDataToPeer(1, "fooos", 7, !kFin, &last_packet); // Packet 3
-
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- // Instigate a loss with an ack.
- QuicAckFrame nack_two = InitAckFrame(3);
- NackPacket(2, &nack_two);
- // The first nack should trigger a fast retransmission, but we'll be
- // write blocked, so the packet will be queued.
- BlockOnNextWrite();
-
- SendAlgorithmInterface::CongestionVector lost_packets;
- lost_packets.push_back(std::make_pair(2, kMaxPacketSize));
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _))
- .WillOnce(SetArgPointee<4>(lost_packets));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- ProcessAckPacket(&nack_two);
- EXPECT_EQ(1u, connection_.NumQueuedPackets());
-
- // Now, ack the previous transmission.
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _));
- QuicAckFrame ack_all = InitAckFrame(3);
- ProcessAckPacket(&ack_all);
-
- // Unblock the socket and attempt to send the queued packets. We will always
- // send the retransmission.
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, 4, _, _)).Times(1);
-
- writer_->SetWritable();
- connection_.OnCanWrite();
-
- EXPECT_EQ(0u, connection_.NumQueuedPackets());
- // We do not store retransmittable frames of this retransmission.
- EXPECT_FALSE(QuicConnectionPeer::HasRetransmittableFrames(&connection_,
- kDefaultPathId, 4));
-}
-
-TEST_P(QuicConnectionTest, RetransmitNackedLargestObserved) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- QuicPacketNumber largest_observed;
- QuicByteCount packet_size;
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
- .WillOnce(DoAll(SaveArg<2>(&largest_observed), SaveArg<3>(&packet_size),
- Return(true)));
- connection_.SendStreamDataWithString(3, "foo", 0, !kFin, nullptr);
-
- QuicAckFrame frame = InitAckFrame(1);
- NackPacket(largest_observed, &frame);
- // The first nack should retransmit the largest observed packet.
- SendAlgorithmInterface::CongestionVector lost_packets;
- lost_packets.push_back(std::make_pair(1, kMaxPacketSize));
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _))
- .WillOnce(SetArgPointee<4>(lost_packets));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- EXPECT_CALL(*send_algorithm_,
- OnPacketSent(_, _, _, packet_size - kQuicVersionSize, _));
- ProcessAckPacket(&frame);
-}
-
-TEST_P(QuicConnectionTest, QueueAfterTwoRTOs) {
- connection_.SetMaxTailLossProbes(kDefaultPathId, 0);
-
- for (int i = 0; i < 10; ++i) {
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
- connection_.SendStreamDataWithString(3, "foo", i * 3, !kFin, nullptr);
- }
-
- // Block the writer and ensure they're queued.
- BlockOnNextWrite();
- clock_.AdvanceTime(DefaultRetransmissionTime());
- // Only one packet should be retransmitted.
- connection_.GetRetransmissionAlarm()->Fire();
- EXPECT_TRUE(connection_.HasQueuedData());
-
- // Unblock the writer.
- writer_->SetWritable();
- clock_.AdvanceTime(QuicTime::Delta::FromMicroseconds(
- 2 * DefaultRetransmissionTime().ToMicroseconds()));
- // Retransmit already retransmitted packets event though the packet number
- // greater than the largest observed.
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(2);
- connection_.GetRetransmissionAlarm()->Fire();
- connection_.OnCanWrite();
-}
-
-TEST_P(QuicConnectionTest, WriteBlockedBufferedThenSent) {
- BlockOnNextWrite();
- writer_->set_is_write_blocked_data_buffered(true);
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
- connection_.SendStreamDataWithString(1, "foo", 0, !kFin, nullptr);
- EXPECT_TRUE(connection_.GetRetransmissionAlarm()->IsSet());
-
- writer_->SetWritable();
- connection_.OnCanWrite();
- EXPECT_TRUE(connection_.GetRetransmissionAlarm()->IsSet());
-}
-
-TEST_P(QuicConnectionTest, WriteBlockedThenSent) {
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
- BlockOnNextWrite();
- connection_.SendStreamDataWithString(1, "foo", 0, !kFin, nullptr);
- EXPECT_FALSE(connection_.GetRetransmissionAlarm()->IsSet());
- EXPECT_EQ(1u, connection_.NumQueuedPackets());
-
- // The second packet should also be queued, in order to ensure packets are
- // never sent out of order.
- writer_->SetWritable();
- connection_.SendStreamDataWithString(1, "foo", 0, !kFin, nullptr);
- EXPECT_EQ(2u, connection_.NumQueuedPackets());
-
- // Now both are sent in order when we unblock.
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(2);
- connection_.OnCanWrite();
- EXPECT_TRUE(connection_.GetRetransmissionAlarm()->IsSet());
-}
-
-TEST_P(QuicConnectionTest, RetransmitWriteBlockedAckedOriginalThenSent) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- connection_.SendStreamDataWithString(3, "foo", 0, !kFin, nullptr);
- EXPECT_TRUE(connection_.GetRetransmissionAlarm()->IsSet());
-
- BlockOnNextWrite();
- writer_->set_is_write_blocked_data_buffered(true);
- // Simulate the retransmission alarm firing.
- clock_.AdvanceTime(DefaultRetransmissionTime());
- connection_.GetRetransmissionAlarm()->Fire();
-
- // Ack the sent packet before the callback returns, which happens in
- // rare circumstances with write blocked sockets.
- QuicAckFrame ack = InitAckFrame(1);
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- ProcessAckPacket(&ack);
-
- writer_->SetWritable();
- connection_.OnCanWrite();
- // There is now a pending packet, but with no retransmittable frames.
- EXPECT_TRUE(connection_.GetRetransmissionAlarm()->IsSet());
- EXPECT_FALSE(QuicConnectionPeer::HasRetransmittableFrames(&connection_,
- ack.path_id, 2));
-}
-
-TEST_P(QuicConnectionTest, AlarmsWhenWriteBlocked) {
- // Block the connection.
- BlockOnNextWrite();
- connection_.SendStreamDataWithString(3, "foo", 0, !kFin, nullptr);
- EXPECT_EQ(1u, writer_->packets_write_attempts());
- EXPECT_TRUE(writer_->IsWriteBlocked());
-
- // Set the send and resumption alarms. Fire the alarms and ensure they don't
- // attempt to write.
- connection_.GetResumeWritesAlarm()->Set(clock_.ApproximateNow());
- connection_.GetSendAlarm()->Set(clock_.ApproximateNow());
- connection_.GetResumeWritesAlarm()->Fire();
- connection_.GetSendAlarm()->Fire();
- EXPECT_TRUE(writer_->IsWriteBlocked());
- EXPECT_EQ(1u, writer_->packets_write_attempts());
-}
-
-TEST_P(QuicConnectionTest, NoLimitPacketsPerNack) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- int offset = 0;
- // Send packets 1 to 15.
- for (int i = 0; i < 15; ++i) {
- SendStreamDataToPeer(1, "foo", offset, !kFin, nullptr);
- offset += 3;
- }
-
- // Ack 15, nack 1-14.
-
- QuicAckFrame nack = InitAckFrame(15);
- for (int i = 1; i < 15; ++i) {
- NackPacket(i, &nack);
- }
-
- // 14 packets have been NACK'd and lost.
- SendAlgorithmInterface::CongestionVector lost_packets;
- for (int i = 1; i < 15; ++i) {
- lost_packets.push_back(std::make_pair(i, kMaxPacketSize));
- }
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _))
- .WillOnce(SetArgPointee<4>(lost_packets));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(14);
- ProcessAckPacket(&nack);
-}
-
-// Test sending multiple acks from the connection to the session.
-TEST_P(QuicConnectionTest, MultipleAcks) {
- QuicPacketNumber last_packet;
- SendStreamDataToPeer(1, "foo", 0, !kFin, &last_packet); // Packet 1
- EXPECT_EQ(1u, last_packet);
- SendStreamDataToPeer(3, "foo", 0, !kFin, &last_packet); // Packet 2
- EXPECT_EQ(2u, last_packet);
- SendAckPacketToPeer(); // Packet 3
- SendStreamDataToPeer(5, "foo", 0, !kFin, &last_packet); // Packet 4
- EXPECT_EQ(4u, last_packet);
- SendStreamDataToPeer(1, "foo", 3, !kFin, &last_packet); // Packet 5
- EXPECT_EQ(5u, last_packet);
- SendStreamDataToPeer(3, "foo", 3, !kFin, &last_packet); // Packet 6
- EXPECT_EQ(6u, last_packet);
-
- // Client will ack packets 1, 2, [!3], 4, 5.
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- QuicAckFrame frame1 = InitAckFrame(5);
- NackPacket(3, &frame1);
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- ProcessAckPacket(&frame1);
-
- // Now the client implicitly acks 3, and explicitly acks 6.
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- QuicAckFrame frame2 = InitAckFrame(6);
- ProcessAckPacket(&frame2);
-}
-
-TEST_P(QuicConnectionTest, DontLatchUnackedPacket) {
- SendStreamDataToPeer(1, "foo", 0, !kFin, nullptr); // Packet 1;
- // From now on, we send acks, so the send algorithm won't mark them pending.
- ON_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
- .WillByDefault(Return(false));
- SendAckPacketToPeer(); // Packet 2
-
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- QuicAckFrame frame = InitAckFrame(1);
- ProcessAckPacket(&frame);
-
- // Verify that our internal state has least-unacked as 2, because we're still
- // waiting for a potential ack for 2.
-
- EXPECT_EQ(2u, stop_waiting()->least_unacked);
-
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- frame = InitAckFrame(2);
- ProcessAckPacket(&frame);
- EXPECT_EQ(3u, stop_waiting()->least_unacked);
-
- // When we send an ack, we make sure our least-unacked makes sense. In this
- // case since we're not waiting on an ack for 2 and all packets are acked, we
- // set it to 3.
- SendAckPacketToPeer(); // Packet 3
- // Least_unacked remains at 3 until another ack is received.
- EXPECT_EQ(3u, stop_waiting()->least_unacked);
- // Check that the outgoing ack had its packet number as least_unacked.
- EXPECT_EQ(3u, least_unacked());
-
- // Ack the ack, which updates the rtt and raises the least unacked.
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- frame = InitAckFrame(3);
- ProcessAckPacket(&frame);
-
- ON_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
- .WillByDefault(Return(true));
- SendStreamDataToPeer(1, "bar", 3, false, nullptr); // Packet 4
- EXPECT_EQ(4u, stop_waiting()->least_unacked);
- ON_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
- .WillByDefault(Return(false));
- SendAckPacketToPeer(); // Packet 5
- EXPECT_EQ(4u, least_unacked());
-
- // Send two data packets at the end, and ensure if the last one is acked,
- // the least unacked is raised above the ack packets.
- ON_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
- .WillByDefault(Return(true));
- SendStreamDataToPeer(1, "bar", 6, false, nullptr); // Packet 6
- SendStreamDataToPeer(1, "bar", 9, false, nullptr); // Packet 7
-
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- frame = InitAckFrame(7);
- NackPacket(5, &frame);
- NackPacket(6, &frame);
- ProcessAckPacket(&frame);
-
- EXPECT_EQ(6u, stop_waiting()->least_unacked);
-}
-
-TEST_P(QuicConnectionTest, TLP) {
- connection_.SetMaxTailLossProbes(kDefaultPathId, 1);
-
- SendStreamDataToPeer(3, "foo", 0, !kFin, nullptr);
- EXPECT_EQ(1u, stop_waiting()->least_unacked);
- QuicTime retransmission_time =
- connection_.GetRetransmissionAlarm()->deadline();
- EXPECT_NE(QuicTime::Zero(), retransmission_time);
-
- EXPECT_EQ(1u, writer_->header().packet_number);
- // Simulate the retransmission alarm firing and sending a tlp,
- // so send algorithm's OnRetransmissionTimeout is not called.
- clock_.AdvanceTime(retransmission_time - clock_.Now());
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, 2u, _, _));
- connection_.GetRetransmissionAlarm()->Fire();
- EXPECT_EQ(2u, writer_->header().packet_number);
- // We do not raise the high water mark yet.
- EXPECT_EQ(1u, stop_waiting()->least_unacked);
-}
-
-TEST_P(QuicConnectionTest, RTO) {
- connection_.SetMaxTailLossProbes(kDefaultPathId, 0);
-
- QuicTime default_retransmission_time =
- clock_.ApproximateNow() + DefaultRetransmissionTime();
- SendStreamDataToPeer(3, "foo", 0, !kFin, nullptr);
- EXPECT_EQ(1u, stop_waiting()->least_unacked);
-
- EXPECT_EQ(1u, writer_->header().packet_number);
- EXPECT_EQ(default_retransmission_time,
- connection_.GetRetransmissionAlarm()->deadline());
- // Simulate the retransmission alarm firing.
- clock_.AdvanceTime(DefaultRetransmissionTime());
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, 2u, _, _));
- connection_.GetRetransmissionAlarm()->Fire();
- EXPECT_EQ(2u, writer_->header().packet_number);
- // We do not raise the high water mark yet.
- EXPECT_EQ(1u, stop_waiting()->least_unacked);
-}
-
-TEST_P(QuicConnectionTest, RTOWithSameEncryptionLevel) {
- connection_.SetMaxTailLossProbes(kDefaultPathId, 0);
-
- QuicTime default_retransmission_time =
- clock_.ApproximateNow() + DefaultRetransmissionTime();
- use_tagging_decrypter();
-
- // A TaggingEncrypter puts kTagSize copies of the given byte (0x01 here) at
- // the end of the packet. We can test this to check which encrypter was used.
- connection_.SetEncrypter(ENCRYPTION_NONE, new TaggingEncrypter(0x01));
- SendStreamDataToPeer(3, "foo", 0, !kFin, nullptr);
- EXPECT_EQ(0x01010101u, writer_->final_bytes_of_last_packet());
-
- connection_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(0x02));
- connection_.SetDefaultEncryptionLevel(ENCRYPTION_INITIAL);
- SendStreamDataToPeer(3, "foo", 0, !kFin, nullptr);
- EXPECT_EQ(0x02020202u, writer_->final_bytes_of_last_packet());
-
- EXPECT_EQ(default_retransmission_time,
- connection_.GetRetransmissionAlarm()->deadline());
- {
- InSequence s;
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, 3, _, _));
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, 4, _, _));
- }
-
- // Simulate the retransmission alarm firing.
- clock_.AdvanceTime(DefaultRetransmissionTime());
- connection_.GetRetransmissionAlarm()->Fire();
-
- // Packet should have been sent with ENCRYPTION_NONE.
- EXPECT_EQ(0x01010101u, writer_->final_bytes_of_previous_packet());
-
- // Packet should have been sent with ENCRYPTION_INITIAL.
- EXPECT_EQ(0x02020202u, writer_->final_bytes_of_last_packet());
-}
-
-TEST_P(QuicConnectionTest, SendHandshakeMessages) {
- use_tagging_decrypter();
- // A TaggingEncrypter puts kTagSize copies of the given byte (0x01 here) at
- // the end of the packet. We can test this to check which encrypter was used.
- connection_.SetEncrypter(ENCRYPTION_NONE, new TaggingEncrypter(0x01));
-
- // Attempt to send a handshake message and have the socket block.
- EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _))
- .WillRepeatedly(testing::Return(QuicTime::Delta::Zero()));
- BlockOnNextWrite();
- connection_.SendStreamDataWithString(1, "foo", 0, !kFin, nullptr);
- // The packet should be serialized, but not queued.
- EXPECT_EQ(1u, connection_.NumQueuedPackets());
-
- // Switch to the new encrypter.
- connection_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(0x02));
- connection_.SetDefaultEncryptionLevel(ENCRYPTION_INITIAL);
-
- // Now become writeable and flush the packets.
- writer_->SetWritable();
- EXPECT_CALL(visitor_, OnCanWrite());
- connection_.OnCanWrite();
- EXPECT_EQ(0u, connection_.NumQueuedPackets());
-
- // Verify that the handshake packet went out at the null encryption.
- EXPECT_EQ(0x01010101u, writer_->final_bytes_of_last_packet());
-}
-
-TEST_P(QuicConnectionTest,
- DropRetransmitsForNullEncryptedPacketAfterForwardSecure) {
- use_tagging_decrypter();
- connection_.SetEncrypter(ENCRYPTION_NONE, new TaggingEncrypter(0x01));
- QuicPacketNumber packet_number;
- SendStreamDataToPeer(3, "foo", 0, !kFin, &packet_number);
-
- // Simulate the retransmission alarm firing and the socket blocking.
- BlockOnNextWrite();
- clock_.AdvanceTime(DefaultRetransmissionTime());
- connection_.GetRetransmissionAlarm()->Fire();
-
- // Go forward secure.
- connection_.SetEncrypter(ENCRYPTION_FORWARD_SECURE,
- new TaggingEncrypter(0x02));
- connection_.SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
- connection_.NeuterUnencryptedPackets();
-
- EXPECT_EQ(QuicTime::Zero(), connection_.GetRetransmissionAlarm()->deadline());
- // Unblock the socket and ensure that no packets are sent.
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
- writer_->SetWritable();
- connection_.OnCanWrite();
-}
-
-TEST_P(QuicConnectionTest, RetransmitPacketsWithInitialEncryption) {
- use_tagging_decrypter();
- connection_.SetEncrypter(ENCRYPTION_NONE, new TaggingEncrypter(0x01));
- connection_.SetDefaultEncryptionLevel(ENCRYPTION_NONE);
-
- SendStreamDataToPeer(1, "foo", 0, !kFin, nullptr);
-
- connection_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(0x02));
- connection_.SetDefaultEncryptionLevel(ENCRYPTION_INITIAL);
-
- SendStreamDataToPeer(2, "bar", 0, !kFin, nullptr);
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
-
- connection_.RetransmitUnackedPackets(ALL_INITIAL_RETRANSMISSION);
-}
-
-TEST_P(QuicConnectionTest, DelayForwardSecureEncryptionUntilClientIsReady) {
- // A TaggingEncrypter puts kTagSize copies of the given byte (0x02 here) at
- // the end of the packet. We can test this to check which encrypter was used.
- use_tagging_decrypter();
- connection_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(0x02));
- connection_.SetDefaultEncryptionLevel(ENCRYPTION_INITIAL);
- SendAckPacketToPeer();
- EXPECT_EQ(0x02020202u, writer_->final_bytes_of_last_packet());
-
- // Set a forward-secure encrypter but do not make it the default, and verify
- // that it is not yet used.
- connection_.SetEncrypter(ENCRYPTION_FORWARD_SECURE,
- new TaggingEncrypter(0x03));
- SendAckPacketToPeer();
- EXPECT_EQ(0x02020202u, writer_->final_bytes_of_last_packet());
-
- // Now simulate receipt of a forward-secure packet and verify that the
- // forward-secure encrypter is now used.
- connection_.OnDecryptedPacket(ENCRYPTION_FORWARD_SECURE);
- SendAckPacketToPeer();
- EXPECT_EQ(0x03030303u, writer_->final_bytes_of_last_packet());
-}
-
-TEST_P(QuicConnectionTest, DelayForwardSecureEncryptionUntilManyPacketSent) {
- // Set a congestion window of 10 packets.
- QuicPacketCount congestion_window = 10;
- EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
- .WillRepeatedly(Return(congestion_window * kDefaultMaxPacketSize));
-
- // A TaggingEncrypter puts kTagSize copies of the given byte (0x02 here) at
- // the end of the packet. We can test this to check which encrypter was used.
- use_tagging_decrypter();
- connection_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(0x02));
- connection_.SetDefaultEncryptionLevel(ENCRYPTION_INITIAL);
- SendAckPacketToPeer();
- EXPECT_EQ(0x02020202u, writer_->final_bytes_of_last_packet());
-
- // Set a forward-secure encrypter but do not make it the default, and
- // verify that it is not yet used.
- connection_.SetEncrypter(ENCRYPTION_FORWARD_SECURE,
- new TaggingEncrypter(0x03));
- SendAckPacketToPeer();
- EXPECT_EQ(0x02020202u, writer_->final_bytes_of_last_packet());
-
- // Now send a packet "Far enough" after the encrypter was set and verify that
- // the forward-secure encrypter is now used.
- for (uint64_t i = 0; i < 3 * congestion_window - 1; ++i) {
- EXPECT_EQ(0x02020202u, writer_->final_bytes_of_last_packet());
- SendAckPacketToPeer();
- }
- EXPECT_EQ(0x03030303u, writer_->final_bytes_of_last_packet());
-}
-
-TEST_P(QuicConnectionTest, BufferNonDecryptablePackets) {
- // SetFromConfig is always called after construction from InitializeSession.
- EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
- QuicConfig config;
- connection_.SetFromConfig(config);
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- use_tagging_decrypter();
-
- const uint8_t tag = 0x07;
- framer_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
-
- // Process an encrypted packet which can not yet be decrypted which should
- // result in the packet being buffered.
- ProcessDataPacketAtLevel(kDefaultPathId, 1, kEntropyFlag, !kHasStopWaiting,
- ENCRYPTION_INITIAL);
-
- // Transition to the new encryption state and process another encrypted packet
- // which should result in the original packet being processed.
- connection_.SetDecrypter(ENCRYPTION_INITIAL, new StrictTaggingDecrypter(tag));
- connection_.SetDefaultEncryptionLevel(ENCRYPTION_INITIAL);
- connection_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(2);
- ProcessDataPacketAtLevel(kDefaultPathId, 2, kEntropyFlag, !kHasStopWaiting,
- ENCRYPTION_INITIAL);
-
- // Finally, process a third packet and note that we do not reprocess the
- // buffered packet.
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, 3, kEntropyFlag, !kHasStopWaiting,
- ENCRYPTION_INITIAL);
-}
-
-TEST_P(QuicConnectionTest, Buffer100NonDecryptablePackets) {
- // SetFromConfig is always called after construction from InitializeSession.
- EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
- QuicConfig config;
- config.set_max_undecryptable_packets(100);
- connection_.SetFromConfig(config);
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- use_tagging_decrypter();
-
- const uint8_t tag = 0x07;
- framer_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
-
- // Process an encrypted packet which can not yet be decrypted which should
- // result in the packet being buffered.
- for (QuicPacketNumber i = 1; i <= 100; ++i) {
- ProcessDataPacketAtLevel(kDefaultPathId, i, kEntropyFlag, !kHasStopWaiting,
- ENCRYPTION_INITIAL);
- }
-
- // Transition to the new encryption state and process another encrypted packet
- // which should result in the original packets being processed.
- connection_.SetDecrypter(ENCRYPTION_INITIAL, new StrictTaggingDecrypter(tag));
- connection_.SetDefaultEncryptionLevel(ENCRYPTION_INITIAL);
- connection_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(101);
- ProcessDataPacketAtLevel(kDefaultPathId, 101, kEntropyFlag, !kHasStopWaiting,
- ENCRYPTION_INITIAL);
-
- // Finally, process a third packet and note that we do not reprocess the
- // buffered packet.
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, 102, kEntropyFlag, !kHasStopWaiting,
- ENCRYPTION_INITIAL);
-}
-
-TEST_P(QuicConnectionTest, TestRetransmitOrder) {
- connection_.SetMaxTailLossProbes(kDefaultPathId, 0);
-
- QuicByteCount first_packet_size;
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
- .WillOnce(DoAll(SaveArg<3>(&first_packet_size), Return(true)));
-
- connection_.SendStreamDataWithString(3, "first_packet", 0, !kFin, nullptr);
- QuicByteCount second_packet_size;
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
- .WillOnce(DoAll(SaveArg<3>(&second_packet_size), Return(true)));
- connection_.SendStreamDataWithString(3, "second_packet", 12, !kFin, nullptr);
- EXPECT_NE(first_packet_size, second_packet_size);
- // Advance the clock by huge time to make sure packets will be retransmitted.
- clock_.AdvanceTime(QuicTime::Delta::FromSeconds(10));
- {
- InSequence s;
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, first_packet_size, _));
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, second_packet_size, _));
- }
- connection_.GetRetransmissionAlarm()->Fire();
-
- // Advance again and expect the packets to be sent again in the same order.
- clock_.AdvanceTime(QuicTime::Delta::FromSeconds(20));
- {
- InSequence s;
- EXPECT_CALL(visitor_, OnPathDegrading());
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, first_packet_size, _));
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, second_packet_size, _));
- }
- connection_.GetRetransmissionAlarm()->Fire();
-}
-
-TEST_P(QuicConnectionTest, SetRTOAfterWritingToSocket) {
- BlockOnNextWrite();
- connection_.SendStreamDataWithString(1, "foo", 0, !kFin, nullptr);
- // Make sure that RTO is not started when the packet is queued.
- EXPECT_FALSE(connection_.GetRetransmissionAlarm()->IsSet());
-
- // Test that RTO is started once we write to the socket.
- writer_->SetWritable();
- connection_.OnCanWrite();
- EXPECT_TRUE(connection_.GetRetransmissionAlarm()->IsSet());
-}
-
-TEST_P(QuicConnectionTest, DelayRTOWithAckReceipt) {
- connection_.SetMaxTailLossProbes(kDefaultPathId, 0);
-
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(2);
- connection_.SendStreamDataWithString(2, "foo", 0, !kFin, nullptr);
- connection_.SendStreamDataWithString(3, "bar", 0, !kFin, nullptr);
- QuicAlarm* retransmission_alarm = connection_.GetRetransmissionAlarm();
- EXPECT_TRUE(retransmission_alarm->IsSet());
- EXPECT_EQ(clock_.Now() + DefaultRetransmissionTime(),
- retransmission_alarm->deadline());
-
- // Advance the time right before the RTO, then receive an ack for the first
- // packet to delay the RTO.
- clock_.AdvanceTime(DefaultRetransmissionTime());
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- QuicAckFrame ack = InitAckFrame(1);
- ProcessAckPacket(&ack);
- EXPECT_TRUE(retransmission_alarm->IsSet());
- EXPECT_GT(retransmission_alarm->deadline(), clock_.Now());
-
- // Move forward past the original RTO and ensure the RTO is still pending.
- clock_.AdvanceTime(2 * DefaultRetransmissionTime());
-
- // Ensure the second packet gets retransmitted when it finally fires.
- EXPECT_TRUE(retransmission_alarm->IsSet());
- EXPECT_LT(retransmission_alarm->deadline(), clock_.ApproximateNow());
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
- // Manually cancel the alarm to simulate a real test.
- connection_.GetRetransmissionAlarm()->Fire();
-
- // The new retransmitted packet number should set the RTO to a larger value
- // than previously.
- EXPECT_TRUE(retransmission_alarm->IsSet());
- QuicTime next_rto_time = retransmission_alarm->deadline();
- QuicTime expected_rto_time =
- connection_.sent_packet_manager().GetRetransmissionTime();
- EXPECT_EQ(next_rto_time, expected_rto_time);
-}
-
-TEST_P(QuicConnectionTest, TestQueued) {
- connection_.SetMaxTailLossProbes(kDefaultPathId, 0);
-
- EXPECT_EQ(0u, connection_.NumQueuedPackets());
- BlockOnNextWrite();
- connection_.SendStreamDataWithString(1, "foo", 0, !kFin, nullptr);
- EXPECT_EQ(1u, connection_.NumQueuedPackets());
-
- // Unblock the writes and actually send.
- writer_->SetWritable();
- connection_.OnCanWrite();
- EXPECT_EQ(0u, connection_.NumQueuedPackets());
-}
-
-TEST_P(QuicConnectionTest, InitialTimeout) {
- EXPECT_TRUE(connection_.connected());
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(AnyNumber());
- EXPECT_FALSE(connection_.GetTimeoutAlarm()->IsSet());
-
- // SetFromConfig sets the initial timeouts before negotiation.
- EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
- QuicConfig config;
- connection_.SetFromConfig(config);
- // Subtract a second from the idle timeout on the client side.
- QuicTime default_timeout =
- clock_.ApproximateNow() +
- QuicTime::Delta::FromSeconds(kInitialIdleTimeoutSecs - 1);
- EXPECT_EQ(default_timeout, connection_.GetTimeoutAlarm()->deadline());
-
- EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_NETWORK_IDLE_TIMEOUT, _,
- ConnectionCloseSource::FROM_SELF));
- // Simulate the timeout alarm firing.
- clock_.AdvanceTime(QuicTime::Delta::FromSeconds(kInitialIdleTimeoutSecs - 1));
- connection_.GetTimeoutAlarm()->Fire();
-
- EXPECT_FALSE(connection_.GetTimeoutAlarm()->IsSet());
- EXPECT_FALSE(connection_.connected());
-
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
- EXPECT_FALSE(connection_.GetPingAlarm()->IsSet());
- EXPECT_FALSE(connection_.GetResumeWritesAlarm()->IsSet());
- EXPECT_FALSE(connection_.GetRetransmissionAlarm()->IsSet());
- EXPECT_FALSE(connection_.GetSendAlarm()->IsSet());
- EXPECT_FALSE(connection_.GetMtuDiscoveryAlarm()->IsSet());
-}
-
-TEST_P(QuicConnectionTest, HandshakeTimeout) {
- // Use a shorter handshake timeout than idle timeout for this test.
- const QuicTime::Delta timeout = QuicTime::Delta::FromSeconds(5);
- connection_.SetNetworkTimeouts(timeout, timeout);
- EXPECT_TRUE(connection_.connected());
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(AnyNumber());
-
- QuicTime handshake_timeout =
- clock_.ApproximateNow() + timeout - QuicTime::Delta::FromSeconds(1);
- EXPECT_EQ(handshake_timeout, connection_.GetTimeoutAlarm()->deadline());
- EXPECT_TRUE(connection_.connected());
-
- // Send and ack new data 3 seconds later to lengthen the idle timeout.
- SendStreamDataToPeer(kHeadersStreamId, "GET /", 0, kFin, nullptr);
- clock_.AdvanceTime(QuicTime::Delta::FromSeconds(3));
- QuicAckFrame frame = InitAckFrame(1);
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- ProcessAckPacket(&frame);
-
- // Fire early to verify it wouldn't timeout yet.
- connection_.GetTimeoutAlarm()->Fire();
- EXPECT_TRUE(connection_.GetTimeoutAlarm()->IsSet());
- EXPECT_TRUE(connection_.connected());
-
- clock_.AdvanceTime(timeout - QuicTime::Delta::FromSeconds(2));
-
- EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_HANDSHAKE_TIMEOUT, _,
- ConnectionCloseSource::FROM_SELF));
- // Simulate the timeout alarm firing.
- connection_.GetTimeoutAlarm()->Fire();
-
- EXPECT_FALSE(connection_.GetTimeoutAlarm()->IsSet());
- EXPECT_FALSE(connection_.connected());
-
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
- EXPECT_FALSE(connection_.GetPingAlarm()->IsSet());
- EXPECT_FALSE(connection_.GetResumeWritesAlarm()->IsSet());
- EXPECT_FALSE(connection_.GetRetransmissionAlarm()->IsSet());
- EXPECT_FALSE(connection_.GetSendAlarm()->IsSet());
-}
-
-TEST_P(QuicConnectionTest, PingAfterSend) {
- EXPECT_TRUE(connection_.connected());
- EXPECT_CALL(visitor_, HasOpenDynamicStreams()).WillRepeatedly(Return(true));
- EXPECT_FALSE(connection_.GetPingAlarm()->IsSet());
-
- // Advance to 5ms, and send a packet to the peer, which will set
- // the ping alarm.
- clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
- EXPECT_FALSE(connection_.GetRetransmissionAlarm()->IsSet());
- SendStreamDataToPeer(kHeadersStreamId, "GET /", 0, kFin, nullptr);
- EXPECT_TRUE(connection_.GetPingAlarm()->IsSet());
- EXPECT_EQ(clock_.ApproximateNow() + QuicTime::Delta::FromSeconds(15),
- connection_.GetPingAlarm()->deadline());
-
- // Now recevie and ACK of the previous packet, which will move the
- // ping alarm forward.
- clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
- QuicAckFrame frame = InitAckFrame(1);
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- ProcessAckPacket(&frame);
- EXPECT_TRUE(connection_.GetPingAlarm()->IsSet());
- // The ping timer is set slightly less than 15 seconds in the future, because
- // of the 1s ping timer alarm granularity.
- EXPECT_EQ(clock_.ApproximateNow() + QuicTime::Delta::FromSeconds(15) -
- QuicTime::Delta::FromMilliseconds(5),
- connection_.GetPingAlarm()->deadline());
-
- writer_->Reset();
- clock_.AdvanceTime(QuicTime::Delta::FromSeconds(15));
- connection_.GetPingAlarm()->Fire();
- EXPECT_EQ(1u, writer_->frame_count());
- ASSERT_EQ(1u, writer_->ping_frames().size());
- writer_->Reset();
-
- EXPECT_CALL(visitor_, HasOpenDynamicStreams()).WillRepeatedly(Return(false));
- clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
- SendAckPacketToPeer();
-
- EXPECT_FALSE(connection_.GetPingAlarm()->IsSet());
-}
-
-// Tests whether sending an MTU discovery packet to peer successfully causes the
-// maximum packet size to increase.
-TEST_P(QuicConnectionTest, SendMtuDiscoveryPacket) {
- EXPECT_TRUE(connection_.connected());
-
- // Send an MTU probe.
- const size_t new_mtu = kDefaultMaxPacketSize + 100;
- QuicByteCount mtu_probe_size;
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
- .WillOnce(DoAll(SaveArg<3>(&mtu_probe_size), Return(true)));
- connection_.SendMtuDiscoveryPacket(new_mtu);
- EXPECT_EQ(new_mtu, mtu_probe_size);
- EXPECT_EQ(1u, creator_->packet_number());
-
- // Send more than MTU worth of data. No acknowledgement was received so far,
- // so the MTU should be at its old value.
- const string data(kDefaultMaxPacketSize + 1, '.');
- QuicByteCount size_before_mtu_change;
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
- .WillOnce(DoAll(SaveArg<3>(&size_before_mtu_change), Return(true)))
- .WillOnce(Return(true));
- connection_.SendStreamDataWithString(3, data, 0, kFin, nullptr);
- EXPECT_EQ(3u, creator_->packet_number());
- EXPECT_EQ(kDefaultMaxPacketSize, size_before_mtu_change);
-
- // Acknowledge all packets so far.
- QuicAckFrame probe_ack = InitAckFrame(3);
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- ProcessAckPacket(&probe_ack);
- EXPECT_EQ(new_mtu, connection_.max_packet_length());
-
- // Send the same data again. Check that it fits into a single packet now.
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
- connection_.SendStreamDataWithString(3, data, 0, kFin, nullptr);
- EXPECT_EQ(4u, creator_->packet_number());
-}
-
-// Tests whether MTU discovery does not happen when it is not explicitly enabled
-// by the connection options.
-TEST_P(QuicConnectionTest, MtuDiscoveryDisabled) {
- EXPECT_TRUE(connection_.connected());
-
- const QuicPacketCount number_of_packets = kPacketsBetweenMtuProbesBase * 2;
- for (QuicPacketCount i = 0; i < number_of_packets; i++) {
- SendStreamDataToPeer(3, ".", i, /*fin=*/false, nullptr);
- EXPECT_FALSE(connection_.GetMtuDiscoveryAlarm()->IsSet());
- EXPECT_EQ(0u, connection_.mtu_probe_count());
- }
-}
-
-// Tests whether MTU discovery works when the probe gets acknowledged on the
-// first try.
-TEST_P(QuicConnectionTest, MtuDiscoveryEnabled) {
- EXPECT_TRUE(connection_.connected());
-
- connection_.EnablePathMtuDiscovery(send_algorithm_);
-
- // Send enough packets so that the next one triggers path MTU discovery.
- for (QuicPacketCount i = 0; i < kPacketsBetweenMtuProbesBase - 1; i++) {
- SendStreamDataToPeer(3, ".", i, /*fin=*/false, nullptr);
- ASSERT_FALSE(connection_.GetMtuDiscoveryAlarm()->IsSet());
- }
-
- // Trigger the probe.
- SendStreamDataToPeer(3, "!", kPacketsBetweenMtuProbesBase,
- /*fin=*/false, nullptr);
- ASSERT_TRUE(connection_.GetMtuDiscoveryAlarm()->IsSet());
- QuicByteCount probe_size;
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
- .WillOnce(DoAll(SaveArg<3>(&probe_size), Return(true)));
- connection_.GetMtuDiscoveryAlarm()->Fire();
- EXPECT_EQ(kMtuDiscoveryTargetPacketSizeHigh, probe_size);
-
- const QuicPacketCount probe_packet_number = kPacketsBetweenMtuProbesBase + 1;
- ASSERT_EQ(probe_packet_number, creator_->packet_number());
-
- // Acknowledge all packets sent so far.
- QuicAckFrame probe_ack = InitAckFrame(probe_packet_number);
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- ProcessAckPacket(&probe_ack);
- EXPECT_EQ(kMtuDiscoveryTargetPacketSizeHigh, connection_.max_packet_length());
- EXPECT_EQ(0u, connection_.GetBytesInFlight(kDefaultPathId));
-
- // Send more packets, and ensure that none of them sets the alarm.
- for (QuicPacketCount i = 0; i < 4 * kPacketsBetweenMtuProbesBase; i++) {
- SendStreamDataToPeer(3, ".", i, /*fin=*/false, nullptr);
- ASSERT_FALSE(connection_.GetMtuDiscoveryAlarm()->IsSet());
- }
-
- EXPECT_EQ(1u, connection_.mtu_probe_count());
-}
-
-// Tests whether MTU discovery works correctly when the probes never get
-// acknowledged.
-TEST_P(QuicConnectionTest, MtuDiscoveryFailed) {
- EXPECT_TRUE(connection_.connected());
-
- connection_.EnablePathMtuDiscovery(send_algorithm_);
-
- const QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(100);
-
- EXPECT_EQ(kPacketsBetweenMtuProbesBase,
- QuicConnectionPeer::GetPacketsBetweenMtuProbes(&connection_));
- // Lower the number of probes between packets in order to make the test go
- // much faster.
- const QuicPacketCount packets_between_probes_base = 10;
- QuicConnectionPeer::SetPacketsBetweenMtuProbes(&connection_,
- packets_between_probes_base);
- QuicConnectionPeer::SetNextMtuProbeAt(&connection_,
- packets_between_probes_base);
-
- // This tests sends more packets than strictly necessary to make sure that if
- // the connection was to send more discovery packets than needed, those would
- // get caught as well.
- const QuicPacketCount number_of_packets =
- packets_between_probes_base * (1 << (kMtuDiscoveryAttempts + 1));
- vector<QuicPacketNumber> mtu_discovery_packets;
- // Called by the first ack.
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- // Called on many acks.
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _))
- .Times(AnyNumber());
- for (QuicPacketCount i = 0; i < number_of_packets; i++) {
- SendStreamDataToPeer(3, "!", i, /*fin=*/false, nullptr);
- clock_.AdvanceTime(rtt);
-
- // Receive an ACK, which marks all data packets as received, and all MTU
- // discovery packets as missing.
- QuicAckFrame ack = InitAckFrame(creator_->packet_number());
- for (QuicPacketNumber& packet : mtu_discovery_packets) {
- NackPacket(packet, &ack);
- }
- ProcessAckPacket(&ack);
-
- // Trigger MTU probe if it would be scheduled now.
- if (!connection_.GetMtuDiscoveryAlarm()->IsSet()) {
- continue;
- }
-
- // Fire the alarm. The alarm should cause a packet to be sent.
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
- .WillOnce(Return(true));
- connection_.GetMtuDiscoveryAlarm()->Fire();
- // Record the packet number of the MTU discovery packet in order to
- // mark it as NACK'd.
- mtu_discovery_packets.push_back(creator_->packet_number());
- }
-
- // Ensure the number of packets between probes grows exponentially by checking
- // it against the closed-form expression for the packet number.
- ASSERT_EQ(kMtuDiscoveryAttempts, mtu_discovery_packets.size());
- for (QuicPacketNumber i = 0; i < kMtuDiscoveryAttempts; i++) {
- // 2^0 + 2^1 + 2^2 + ... + 2^n = 2^(n + 1) - 1
- const QuicPacketCount packets_between_probes =
- packets_between_probes_base * ((1 << (i + 1)) - 1);
- EXPECT_EQ(packets_between_probes + (i + 1), mtu_discovery_packets[i]);
- }
-
- EXPECT_FALSE(connection_.GetMtuDiscoveryAlarm()->IsSet());
- EXPECT_EQ(kDefaultMaxPacketSize, connection_.max_packet_length());
- EXPECT_EQ(kMtuDiscoveryAttempts, connection_.mtu_probe_count());
-}
-
-// Tests whether MTU discovery works when the writer has a limit on how large a
-// packet can be.
-TEST_P(QuicConnectionTest, MtuDiscoveryWriterLimited) {
- EXPECT_TRUE(connection_.connected());
-
- const QuicByteCount mtu_limit = kMtuDiscoveryTargetPacketSizeHigh - 1;
- writer_->set_max_packet_size(mtu_limit);
- connection_.EnablePathMtuDiscovery(send_algorithm_);
-
- // Send enough packets so that the next one triggers path MTU discovery.
- for (QuicPacketCount i = 0; i < kPacketsBetweenMtuProbesBase - 1; i++) {
- SendStreamDataToPeer(3, ".", i, /*fin=*/false, nullptr);
- ASSERT_FALSE(connection_.GetMtuDiscoveryAlarm()->IsSet());
- }
-
- // Trigger the probe.
- SendStreamDataToPeer(3, "!", kPacketsBetweenMtuProbesBase,
- /*fin=*/false, nullptr);
- ASSERT_TRUE(connection_.GetMtuDiscoveryAlarm()->IsSet());
- QuicByteCount probe_size;
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
- .WillOnce(DoAll(SaveArg<3>(&probe_size), Return(true)));
- connection_.GetMtuDiscoveryAlarm()->Fire();
- EXPECT_EQ(mtu_limit, probe_size);
-
- const QuicPacketCount probe_sequence_number =
- kPacketsBetweenMtuProbesBase + 1;
- ASSERT_EQ(probe_sequence_number, creator_->packet_number());
-
- // Acknowledge all packets sent so far.
- QuicAckFrame probe_ack = InitAckFrame(probe_sequence_number);
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- ProcessAckPacket(&probe_ack);
- EXPECT_EQ(mtu_limit, connection_.max_packet_length());
- EXPECT_EQ(0u, connection_.GetBytesInFlight(kDefaultPathId));
-
- // Send more packets, and ensure that none of them sets the alarm.
- for (QuicPacketCount i = 0; i < 4 * kPacketsBetweenMtuProbesBase; i++) {
- SendStreamDataToPeer(3, ".", i, /*fin=*/false, nullptr);
- ASSERT_FALSE(connection_.GetMtuDiscoveryAlarm()->IsSet());
- }
-
- EXPECT_EQ(1u, connection_.mtu_probe_count());
-}
-
-TEST_P(QuicConnectionTest, NoMtuDiscoveryAfterConnectionClosed) {
- EXPECT_TRUE(connection_.connected());
-
- connection_.EnablePathMtuDiscovery(send_algorithm_);
-
- // Send enough packets so that the next one triggers path MTU discovery.
- for (QuicPacketCount i = 0; i < kPacketsBetweenMtuProbesBase - 1; i++) {
- SendStreamDataToPeer(3, ".", i, /*fin=*/false, nullptr);
- ASSERT_FALSE(connection_.GetMtuDiscoveryAlarm()->IsSet());
- }
-
- SendStreamDataToPeer(3, "!", kPacketsBetweenMtuProbesBase,
- /*fin=*/false, nullptr);
- EXPECT_TRUE(connection_.GetMtuDiscoveryAlarm()->IsSet());
-
- EXPECT_CALL(visitor_, OnConnectionClosed(_, _, _));
- connection_.CloseConnection(QUIC_PEER_GOING_AWAY, "no reason",
- ConnectionCloseBehavior::SILENT_CLOSE);
- EXPECT_FALSE(connection_.GetMtuDiscoveryAlarm()->IsSet());
-}
-
-TEST_P(QuicConnectionTest, TimeoutAfterSend) {
- EXPECT_TRUE(connection_.connected());
- EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
- QuicConfig config;
- connection_.SetFromConfig(config);
- EXPECT_FALSE(QuicConnectionPeer::IsSilentCloseEnabled(&connection_));
-
- const QuicTime::Delta initial_idle_timeout =
- QuicTime::Delta::FromSeconds(kInitialIdleTimeoutSecs - 1);
- const QuicTime::Delta five_ms = QuicTime::Delta::FromMilliseconds(5);
- QuicTime default_timeout = clock_.ApproximateNow() + initial_idle_timeout;
-
- // When we send a packet, the timeout will change to 5ms +
- // kInitialIdleTimeoutSecs.
- clock_.AdvanceTime(five_ms);
- SendStreamDataToPeer(kClientDataStreamId1, "foo", 0, kFin, nullptr);
- EXPECT_EQ(default_timeout, connection_.GetTimeoutAlarm()->deadline());
-
- // Now send more data. This will not move the timeout becase
- // no data has been recieved since the previous write.
- clock_.AdvanceTime(five_ms);
- SendStreamDataToPeer(kClientDataStreamId1, "foo", 0, kFin, nullptr);
- EXPECT_EQ(default_timeout, connection_.GetTimeoutAlarm()->deadline());
-
- // The original alarm will fire. We should not time out because we had a
- // network event at t=5ms. The alarm will reregister.
- clock_.AdvanceTime(initial_idle_timeout - five_ms - five_ms);
- EXPECT_EQ(default_timeout, clock_.ApproximateNow());
- connection_.GetTimeoutAlarm()->Fire();
- EXPECT_TRUE(connection_.GetTimeoutAlarm()->IsSet());
- EXPECT_TRUE(connection_.connected());
- EXPECT_EQ(default_timeout + five_ms + five_ms,
- connection_.GetTimeoutAlarm()->deadline());
-
- // This time, we should time out.
- EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_NETWORK_IDLE_TIMEOUT, _,
- ConnectionCloseSource::FROM_SELF));
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
- clock_.AdvanceTime(five_ms);
- EXPECT_EQ(default_timeout + five_ms, clock_.ApproximateNow());
- connection_.GetTimeoutAlarm()->Fire();
- EXPECT_FALSE(connection_.GetTimeoutAlarm()->IsSet());
- EXPECT_FALSE(connection_.connected());
-}
-
-TEST_P(QuicConnectionTest, NewTimeoutAfterSendSilentClose) {
- // Same test as above, but complete a handshake which enables silent close,
- // causing no connection close packet to be sent.
- EXPECT_TRUE(connection_.connected());
- EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
- QuicConfig config;
-
- // Create a handshake message that also enables silent close.
- CryptoHandshakeMessage msg;
- string error_details;
- QuicConfig client_config;
- client_config.SetInitialStreamFlowControlWindowToSend(
- kInitialStreamFlowControlWindowForTest);
- client_config.SetInitialSessionFlowControlWindowToSend(
- kInitialSessionFlowControlWindowForTest);
- client_config.SetIdleConnectionStateLifetime(
- QuicTime::Delta::FromSeconds(kDefaultIdleTimeoutSecs),
- QuicTime::Delta::FromSeconds(kDefaultIdleTimeoutSecs));
- client_config.ToHandshakeMessage(&msg);
- const QuicErrorCode error =
- config.ProcessPeerHello(msg, CLIENT, &error_details);
- EXPECT_EQ(QUIC_NO_ERROR, error);
-
- connection_.SetFromConfig(config);
- EXPECT_TRUE(QuicConnectionPeer::IsSilentCloseEnabled(&connection_));
-
- const QuicTime::Delta default_idle_timeout =
- QuicTime::Delta::FromSeconds(kDefaultIdleTimeoutSecs - 1);
- const QuicTime::Delta five_ms = QuicTime::Delta::FromMilliseconds(5);
- QuicTime default_timeout = clock_.ApproximateNow() + default_idle_timeout;
-
- // When we send a packet, the timeout will change to 5ms +
- // kInitialIdleTimeoutSecs.
- clock_.AdvanceTime(five_ms);
- SendStreamDataToPeer(kClientDataStreamId1, "foo", 0, kFin, nullptr);
- EXPECT_EQ(default_timeout, connection_.GetTimeoutAlarm()->deadline());
-
- // Now send more data. This will not move the timeout becase
- // no data has been recieved since the previous write.
- clock_.AdvanceTime(five_ms);
- SendStreamDataToPeer(kClientDataStreamId1, "foo", 0, kFin, nullptr);
- EXPECT_EQ(default_timeout, connection_.GetTimeoutAlarm()->deadline());
-
- // The original alarm will fire. We should not time out because we had a
- // network event at t=5ms. The alarm will reregister.
- clock_.AdvanceTime(default_idle_timeout - five_ms - five_ms);
- EXPECT_EQ(default_timeout, clock_.ApproximateNow());
- connection_.GetTimeoutAlarm()->Fire();
- EXPECT_TRUE(connection_.GetTimeoutAlarm()->IsSet());
- EXPECT_TRUE(connection_.connected());
- EXPECT_EQ(default_timeout + five_ms + five_ms,
- connection_.GetTimeoutAlarm()->deadline());
-
- // This time, we should time out.
- EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_NETWORK_IDLE_TIMEOUT, _,
- ConnectionCloseSource::FROM_SELF));
- clock_.AdvanceTime(five_ms);
- EXPECT_EQ(default_timeout + five_ms, clock_.ApproximateNow());
- connection_.GetTimeoutAlarm()->Fire();
- EXPECT_FALSE(connection_.GetTimeoutAlarm()->IsSet());
- EXPECT_FALSE(connection_.connected());
-}
-
-TEST_P(QuicConnectionTest, TimeoutAfterReceive) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- EXPECT_TRUE(connection_.connected());
- EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
- QuicConfig config;
- connection_.SetFromConfig(config);
- EXPECT_FALSE(QuicConnectionPeer::IsSilentCloseEnabled(&connection_));
-
- const QuicTime::Delta initial_idle_timeout =
- QuicTime::Delta::FromSeconds(kInitialIdleTimeoutSecs - 1);
- const QuicTime::Delta five_ms = QuicTime::Delta::FromMilliseconds(5);
- QuicTime default_timeout = clock_.ApproximateNow() + initial_idle_timeout;
-
- connection_.SendStreamDataWithString(kClientDataStreamId1, "foo", 0, !kFin,
- nullptr);
- connection_.SendStreamDataWithString(kClientDataStreamId1, "foo", 3, !kFin,
- nullptr);
-
- EXPECT_EQ(default_timeout, connection_.GetTimeoutAlarm()->deadline());
- clock_.AdvanceTime(five_ms);
-
- // When we receive a packet, the timeout will change to 5ms +
- // kInitialIdleTimeoutSecs.
- QuicAckFrame ack = InitAckFrame(2);
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- ProcessAckPacket(&ack);
-
- // The original alarm will fire. We should not time out because we had a
- // network event at t=5ms. The alarm will reregister.
- clock_.AdvanceTime(initial_idle_timeout - five_ms);
- EXPECT_EQ(default_timeout, clock_.ApproximateNow());
- connection_.GetTimeoutAlarm()->Fire();
- EXPECT_TRUE(connection_.connected());
- EXPECT_TRUE(connection_.GetTimeoutAlarm()->IsSet());
- EXPECT_EQ(default_timeout + five_ms,
- connection_.GetTimeoutAlarm()->deadline());
-
- // This time, we should time out.
- EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_NETWORK_IDLE_TIMEOUT, _,
- ConnectionCloseSource::FROM_SELF));
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
- clock_.AdvanceTime(five_ms);
- EXPECT_EQ(default_timeout + five_ms, clock_.ApproximateNow());
- connection_.GetTimeoutAlarm()->Fire();
- EXPECT_FALSE(connection_.GetTimeoutAlarm()->IsSet());
- EXPECT_FALSE(connection_.connected());
-}
-
-TEST_P(QuicConnectionTest, TimeoutAfterReceiveNotSendWhenUnacked) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- EXPECT_TRUE(connection_.connected());
- EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
- QuicConfig config;
- connection_.SetFromConfig(config);
- EXPECT_FALSE(QuicConnectionPeer::IsSilentCloseEnabled(&connection_));
-
- const QuicTime::Delta initial_idle_timeout =
- QuicTime::Delta::FromSeconds(kInitialIdleTimeoutSecs - 1);
- connection_.SetNetworkTimeouts(
- QuicTime::Delta::Infinite(),
- initial_idle_timeout + QuicTime::Delta::FromSeconds(1));
- const QuicTime::Delta five_ms = QuicTime::Delta::FromMilliseconds(5);
- QuicTime default_timeout = clock_.ApproximateNow() + initial_idle_timeout;
-
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
- connection_.SendStreamDataWithString(kClientDataStreamId1, "foo", 0, !kFin,
- nullptr);
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
- connection_.SendStreamDataWithString(kClientDataStreamId1, "foo", 3, !kFin,
- nullptr);
-
- EXPECT_EQ(default_timeout, connection_.GetTimeoutAlarm()->deadline());
-
- clock_.AdvanceTime(five_ms);
-
- // When we receive a packet, the timeout will change to 5ms +
- // kInitialIdleTimeoutSecs.
- QuicAckFrame ack = InitAckFrame(2);
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- ProcessAckPacket(&ack);
-
- // The original alarm will fire. We should not time out because we had a
- // network event at t=5ms. The alarm will reregister.
- clock_.AdvanceTime(initial_idle_timeout - five_ms);
- EXPECT_EQ(default_timeout, clock_.ApproximateNow());
- connection_.GetTimeoutAlarm()->Fire();
- EXPECT_TRUE(connection_.connected());
- EXPECT_TRUE(connection_.GetTimeoutAlarm()->IsSet());
- EXPECT_EQ(default_timeout + five_ms,
- connection_.GetTimeoutAlarm()->deadline());
-
- // Now, send packets while advancing the time and verify that the connection
- // eventually times out.
- EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_NETWORK_IDLE_TIMEOUT, _,
- ConnectionCloseSource::FROM_SELF));
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(AnyNumber());
- for (int i = 0; i < 100 && connection_.connected(); ++i) {
- VLOG(1) << "sending data packet";
- connection_.SendStreamDataWithString(kClientDataStreamId1, "foo", 0, !kFin,
- nullptr);
- connection_.GetTimeoutAlarm()->Fire();
- clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
- }
- EXPECT_FALSE(connection_.connected());
- EXPECT_FALSE(connection_.GetTimeoutAlarm()->IsSet());
-}
-
-TEST_P(QuicConnectionTest, TimeoutAfter5RTOs) {
- connection_.SetMaxTailLossProbes(kDefaultPathId, 2);
- EXPECT_TRUE(connection_.connected());
- EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
- QuicConfig config;
- QuicTagVector connection_options;
- connection_options.push_back(k5RTO);
- config.SetConnectionOptionsToSend(connection_options);
- connection_.SetFromConfig(config);
-
- // Send stream data.
- SendStreamDataToPeer(kClientDataStreamId1, "foo", 0, kFin, nullptr);
-
- EXPECT_CALL(visitor_, OnPathDegrading());
- // Fire the retransmission alarm 6 times, twice for TLP and 4 times for RTO.
- for (int i = 0; i < 6; ++i) {
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
- connection_.GetRetransmissionAlarm()->Fire();
- EXPECT_TRUE(connection_.GetTimeoutAlarm()->IsSet());
- EXPECT_TRUE(connection_.connected());
- }
-
- EXPECT_EQ(2u, connection_.sent_packet_manager().GetConsecutiveTlpCount());
- EXPECT_EQ(4u, connection_.sent_packet_manager().GetConsecutiveRtoCount());
- // This time, we should time out.
- EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_TOO_MANY_RTOS, _,
- ConnectionCloseSource::FROM_SELF));
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
- connection_.GetRetransmissionAlarm()->Fire();
- EXPECT_FALSE(connection_.GetTimeoutAlarm()->IsSet());
- EXPECT_FALSE(connection_.connected());
-}
-
-TEST_P(QuicConnectionTest, SendScheduler) {
- // Test that if we send a packet without delay, it is not queued.
- QuicPacket* packet =
- ConstructDataPacket(kDefaultPathId, 1, !kEntropyFlag, !kHasStopWaiting);
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
- connection_.SendPacket(ENCRYPTION_NONE, kDefaultPathId, 1, packet,
- kTestEntropyHash, HAS_RETRANSMITTABLE_DATA, false,
- false);
- EXPECT_EQ(0u, connection_.NumQueuedPackets());
-}
-
-TEST_P(QuicConnectionTest, FailToSendFirstPacket) {
- // Test that the connection does not crash when it fails to send the first
- // packet at which point self_address_ might be uninitialized.
- EXPECT_CALL(visitor_, OnConnectionClosed(_, _, _)).Times(1);
- QuicPacket* packet =
- ConstructDataPacket(kDefaultPathId, 1, !kEntropyFlag, !kHasStopWaiting);
- writer_->SetShouldWriteFail();
- connection_.SendPacket(ENCRYPTION_NONE, kDefaultPathId, 1, packet,
- kTestEntropyHash, HAS_RETRANSMITTABLE_DATA, false,
- false);
-}
-
-TEST_P(QuicConnectionTest, SendSchedulerEAGAIN) {
- QuicPacket* packet =
- ConstructDataPacket(kDefaultPathId, 1, !kEntropyFlag, !kHasStopWaiting);
- BlockOnNextWrite();
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, 1, _, _)).Times(0);
- connection_.SendPacket(ENCRYPTION_NONE, kDefaultPathId, 1, packet,
- kTestEntropyHash, HAS_RETRANSMITTABLE_DATA, false,
- false);
- EXPECT_EQ(1u, connection_.NumQueuedPackets());
-}
-
-TEST_P(QuicConnectionTest, TestQueueLimitsOnSendStreamData) {
- // All packets carry version info till version is negotiated.
- size_t payload_length;
- size_t length = GetPacketLengthForOneStream(
- connection_.version(), kIncludeVersion, !kIncludePathId,
- !kIncludeDiversificationNonce, PACKET_8BYTE_CONNECTION_ID,
- PACKET_1BYTE_PACKET_NUMBER, &payload_length);
- connection_.SetMaxPacketLength(length);
-
- // Queue the first packet.
- EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _))
- .WillOnce(testing::Return(QuicTime::Delta::FromMicroseconds(10)));
- const string payload(payload_length, 'a');
- EXPECT_EQ(0u,
- connection_.SendStreamDataWithString(3, payload, 0, !kFin, nullptr)
- .bytes_consumed);
- EXPECT_EQ(0u, connection_.NumQueuedPackets());
-}
-
-TEST_P(QuicConnectionTest, LoopThroughSendingPackets) {
- // All packets carry version info till version is negotiated.
- size_t payload_length;
- // GetPacketLengthForOneStream() assumes a stream offset of 0 in determining
- // packet length. The size of the offset field in a stream frame is 0 for
- // offset 0, and 2 for non-zero offsets up through 16K. Increase
- // max_packet_length by 2 so that subsequent packets containing subsequent
- // stream frames with non-zero offets will fit within the packet length.
- size_t length =
- 2 + GetPacketLengthForOneStream(
- connection_.version(), kIncludeVersion, !kIncludePathId,
- !kIncludeDiversificationNonce, PACKET_8BYTE_CONNECTION_ID,
- PACKET_1BYTE_PACKET_NUMBER, &payload_length);
- connection_.SetMaxPacketLength(length);
-
- // Queue the first packet.
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(7);
- // The first stream frame will have 2 fewer overhead bytes than the other six.
- const string payload(payload_length * 7 + 2, 'a');
- EXPECT_EQ(payload.size(),
- connection_.SendStreamDataWithString(1, payload, 0, !kFin, nullptr)
- .bytes_consumed);
-}
-
-TEST_P(QuicConnectionTest, LoopThroughSendingPacketsWithTruncation) {
- // Set up a larger payload than will fit in one packet.
- const string payload(connection_.max_packet_length(), 'a');
- EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)).Times(AnyNumber());
-
- // Now send some packets with no truncation.
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(2);
- EXPECT_EQ(payload.size(),
- connection_.SendStreamDataWithString(3, payload, 0, !kFin, nullptr)
- .bytes_consumed);
- // Track the size of the second packet here. The overhead will be the largest
- // we see in this test, due to the non-truncated connection id.
- size_t non_truncated_packet_size = writer_->last_packet_size();
-
- // Change to a 0 byte connection id.
- QuicConfig config;
- QuicConfigPeer::SetReceivedBytesForConnectionId(&config, 0);
- connection_.SetFromConfig(config);
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(2);
- EXPECT_EQ(payload.size(),
- connection_.SendStreamDataWithString(3, payload, 0, !kFin, nullptr)
- .bytes_consumed);
- // Just like above, we save 8 bytes on payload, and 8 on truncation.
- EXPECT_EQ(non_truncated_packet_size, writer_->last_packet_size() + 8 * 2);
-}
-
-TEST_P(QuicConnectionTest, SendDelayedAck) {
- QuicTime ack_time = clock_.ApproximateNow() + DefaultDelayedAckTime();
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
- const uint8_t tag = 0x07;
- connection_.SetDecrypter(ENCRYPTION_INITIAL, new StrictTaggingDecrypter(tag));
- framer_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
- // Process a packet from the non-crypto stream.
- frame1_.stream_id = 3;
-
- // The same as ProcessPacket(1) except that ENCRYPTION_INITIAL is used
- // instead of ENCRYPTION_NONE.
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, 1, !kEntropyFlag, !kHasStopWaiting,
- ENCRYPTION_INITIAL);
-
- // Check if delayed ack timer is running for the expected interval.
- EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
- EXPECT_EQ(ack_time, connection_.GetAckAlarm()->deadline());
- // Simulate delayed ack alarm firing.
- connection_.GetAckAlarm()->Fire();
- // Check that ack is sent and that delayed ack alarm is reset.
- EXPECT_EQ(2u, writer_->frame_count());
- EXPECT_FALSE(writer_->stop_waiting_frames().empty());
- EXPECT_FALSE(writer_->ack_frames().empty());
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
-}
-
-TEST_P(QuicConnectionTest, SendDelayedAckDecimation) {
- QuicConnectionPeer::SetAckMode(&connection_, QuicConnection::ACK_DECIMATION);
-
- const size_t kMinRttMs = 40;
- RttStats* rtt_stats = const_cast<RttStats*>(manager_->GetRttStats());
- rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(kMinRttMs),
- QuicTime::Delta::Zero(), QuicTime::Zero());
- // The ack time should be based on min_rtt/4, since it's less than the
- // default delayed ack time.
- QuicTime ack_time = clock_.ApproximateNow() +
- QuicTime::Delta::FromMilliseconds(kMinRttMs / 4);
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
- const uint8_t tag = 0x07;
- connection_.SetDecrypter(ENCRYPTION_INITIAL, new StrictTaggingDecrypter(tag));
- framer_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
- // Process a packet from the non-crypto stream.
- frame1_.stream_id = 3;
-
- // Process all the initial packets in order so there aren't missing packets.
- QuicPacketNumber kFirstDecimatedPacket = 101;
- for (unsigned int i = 0; i < kFirstDecimatedPacket - 1; ++i) {
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, 1 + i, !kEntropyFlag,
- !kHasStopWaiting, ENCRYPTION_INITIAL);
- }
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
- // The same as ProcessPacket(1) except that ENCRYPTION_INITIAL is used
- // instead of ENCRYPTION_NONE.
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, kFirstDecimatedPacket, !kEntropyFlag,
- !kHasStopWaiting, ENCRYPTION_INITIAL);
-
- // Check if delayed ack timer is running for the expected interval.
- EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
- EXPECT_EQ(ack_time, connection_.GetAckAlarm()->deadline());
-
- // The 10th received packet causes an ack to be sent.
- for (int i = 0; i < 9; ++i) {
- EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, kFirstDecimatedPacket + 1 + i,
- !kEntropyFlag, !kHasStopWaiting,
- ENCRYPTION_INITIAL);
- }
- // Check that ack is sent and that delayed ack alarm is reset.
- EXPECT_EQ(2u, writer_->frame_count());
- EXPECT_FALSE(writer_->stop_waiting_frames().empty());
- EXPECT_FALSE(writer_->ack_frames().empty());
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
-}
-
-TEST_P(QuicConnectionTest, SendDelayedAckDecimationEighthRtt) {
- QuicConnectionPeer::SetAckMode(&connection_, QuicConnection::ACK_DECIMATION);
- QuicConnectionPeer::SetAckDecimationDelay(&connection_, 0.125);
-
- const size_t kMinRttMs = 40;
- RttStats* rtt_stats = const_cast<RttStats*>(manager_->GetRttStats());
- rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(kMinRttMs),
- QuicTime::Delta::Zero(), QuicTime::Zero());
- // The ack time should be based on min_rtt/8, since it's less than the
- // default delayed ack time.
- QuicTime ack_time = clock_.ApproximateNow() +
- QuicTime::Delta::FromMilliseconds(kMinRttMs / 8);
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
- const uint8_t tag = 0x07;
- connection_.SetDecrypter(ENCRYPTION_INITIAL, new StrictTaggingDecrypter(tag));
- framer_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
- // Process a packet from the non-crypto stream.
- frame1_.stream_id = 3;
-
- // Process all the initial packets in order so there aren't missing packets.
- QuicPacketNumber kFirstDecimatedPacket = 101;
- for (unsigned int i = 0; i < kFirstDecimatedPacket - 1; ++i) {
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, 1 + i, !kEntropyFlag,
- !kHasStopWaiting, ENCRYPTION_INITIAL);
- }
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
- // The same as ProcessPacket(1) except that ENCRYPTION_INITIAL is used
- // instead of ENCRYPTION_NONE.
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, kFirstDecimatedPacket, !kEntropyFlag,
- !kHasStopWaiting, ENCRYPTION_INITIAL);
-
- // Check if delayed ack timer is running for the expected interval.
- EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
- EXPECT_EQ(ack_time, connection_.GetAckAlarm()->deadline());
-
- // The 10th received packet causes an ack to be sent.
- for (int i = 0; i < 9; ++i) {
- EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, kFirstDecimatedPacket + 1 + i,
- !kEntropyFlag, !kHasStopWaiting,
- ENCRYPTION_INITIAL);
- }
- // Check that ack is sent and that delayed ack alarm is reset.
- EXPECT_EQ(2u, writer_->frame_count());
- EXPECT_FALSE(writer_->stop_waiting_frames().empty());
- EXPECT_FALSE(writer_->ack_frames().empty());
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
-}
-
-TEST_P(QuicConnectionTest, SendDelayedAckDecimationWithReordering) {
- QuicConnectionPeer::SetAckMode(
- &connection_, QuicConnection::ACK_DECIMATION_WITH_REORDERING);
-
- const size_t kMinRttMs = 40;
- RttStats* rtt_stats = const_cast<RttStats*>(manager_->GetRttStats());
- rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(kMinRttMs),
- QuicTime::Delta::Zero(), QuicTime::Zero());
- // The ack time should be based on min_rtt/4, since it's less than the
- // default delayed ack time.
- QuicTime ack_time = clock_.ApproximateNow() +
- QuicTime::Delta::FromMilliseconds(kMinRttMs / 4);
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
- const uint8_t tag = 0x07;
- connection_.SetDecrypter(ENCRYPTION_INITIAL, new StrictTaggingDecrypter(tag));
- framer_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
- // Process a packet from the non-crypto stream.
- frame1_.stream_id = 3;
-
- // Process all the initial packets in order so there aren't missing packets.
- QuicPacketNumber kFirstDecimatedPacket = 101;
- for (unsigned int i = 0; i < kFirstDecimatedPacket - 1; ++i) {
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, 1 + i, !kEntropyFlag,
- !kHasStopWaiting, ENCRYPTION_INITIAL);
- }
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
- // The same as ProcessPacket(1) except that ENCRYPTION_INITIAL is used
- // instead of ENCRYPTION_NONE.
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, kFirstDecimatedPacket, !kEntropyFlag,
- !kHasStopWaiting, ENCRYPTION_INITIAL);
-
- // Check if delayed ack timer is running for the expected interval.
- EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
- EXPECT_EQ(ack_time, connection_.GetAckAlarm()->deadline());
-
- // Process packet 10 first and ensure the alarm is one eighth min_rtt.
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, kFirstDecimatedPacket + 9,
- !kEntropyFlag, !kHasStopWaiting, ENCRYPTION_INITIAL);
- ack_time = clock_.ApproximateNow() + QuicTime::Delta::FromMilliseconds(5);
- EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
- EXPECT_EQ(ack_time, connection_.GetAckAlarm()->deadline());
-
- // The 10th received packet causes an ack to be sent.
- for (int i = 0; i < 8; ++i) {
- EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, kFirstDecimatedPacket + 1 + i,
- !kEntropyFlag, !kHasStopWaiting,
- ENCRYPTION_INITIAL);
- }
- // Check that ack is sent and that delayed ack alarm is reset.
- EXPECT_EQ(2u, writer_->frame_count());
- EXPECT_FALSE(writer_->stop_waiting_frames().empty());
- EXPECT_FALSE(writer_->ack_frames().empty());
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
-}
-
-TEST_P(QuicConnectionTest, SendDelayedAckDecimationWithLargeReordering) {
- QuicConnectionPeer::SetAckMode(
- &connection_, QuicConnection::ACK_DECIMATION_WITH_REORDERING);
-
- const size_t kMinRttMs = 40;
- RttStats* rtt_stats = const_cast<RttStats*>(manager_->GetRttStats());
- rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(kMinRttMs),
- QuicTime::Delta::Zero(), QuicTime::Zero());
- // The ack time should be based on min_rtt/4, since it's less than the
- // default delayed ack time.
- QuicTime ack_time = clock_.ApproximateNow() +
- QuicTime::Delta::FromMilliseconds(kMinRttMs / 4);
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
- const uint8_t tag = 0x07;
- connection_.SetDecrypter(ENCRYPTION_INITIAL, new StrictTaggingDecrypter(tag));
- framer_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
- // Process a packet from the non-crypto stream.
- frame1_.stream_id = 3;
-
- // Process all the initial packets in order so there aren't missing packets.
- QuicPacketNumber kFirstDecimatedPacket = 101;
- for (unsigned int i = 0; i < kFirstDecimatedPacket - 1; ++i) {
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, 1 + i, !kEntropyFlag,
- !kHasStopWaiting, ENCRYPTION_INITIAL);
- }
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
- // The same as ProcessPacket(1) except that ENCRYPTION_INITIAL is used
- // instead of ENCRYPTION_NONE.
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, kFirstDecimatedPacket, !kEntropyFlag,
- !kHasStopWaiting, ENCRYPTION_INITIAL);
-
- // Check if delayed ack timer is running for the expected interval.
- EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
- EXPECT_EQ(ack_time, connection_.GetAckAlarm()->deadline());
-
- // Process packet 10 first and ensure the alarm is one eighth min_rtt.
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, kFirstDecimatedPacket + 19,
- !kEntropyFlag, !kHasStopWaiting, ENCRYPTION_INITIAL);
- ack_time = clock_.ApproximateNow() + QuicTime::Delta::FromMilliseconds(5);
- EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
- EXPECT_EQ(ack_time, connection_.GetAckAlarm()->deadline());
-
- // The 10th received packet causes an ack to be sent.
- for (int i = 0; i < 8; ++i) {
- EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, kFirstDecimatedPacket + 1 + i,
- !kEntropyFlag, !kHasStopWaiting,
- ENCRYPTION_INITIAL);
- }
- // Check that ack is sent and that delayed ack alarm is reset.
- EXPECT_EQ(2u, writer_->frame_count());
- EXPECT_FALSE(writer_->stop_waiting_frames().empty());
- EXPECT_FALSE(writer_->ack_frames().empty());
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
-
- // The next packet received in order will cause an immediate ack,
- // because it fills a hole.
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, kFirstDecimatedPacket + 10,
- !kEntropyFlag, !kHasStopWaiting, ENCRYPTION_INITIAL);
- // Check that ack is sent and that delayed ack alarm is reset.
- EXPECT_EQ(2u, writer_->frame_count());
- EXPECT_FALSE(writer_->stop_waiting_frames().empty());
- EXPECT_FALSE(writer_->ack_frames().empty());
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
-}
-
-TEST_P(QuicConnectionTest, SendDelayedAckDecimationWithReorderingEighthRtt) {
- QuicConnectionPeer::SetAckMode(
- &connection_, QuicConnection::ACK_DECIMATION_WITH_REORDERING);
- QuicConnectionPeer::SetAckDecimationDelay(&connection_, 0.125);
-
- const size_t kMinRttMs = 40;
- RttStats* rtt_stats = const_cast<RttStats*>(manager_->GetRttStats());
- rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(kMinRttMs),
- QuicTime::Delta::Zero(), QuicTime::Zero());
- // The ack time should be based on min_rtt/8, since it's less than the
- // default delayed ack time.
- QuicTime ack_time = clock_.ApproximateNow() +
- QuicTime::Delta::FromMilliseconds(kMinRttMs / 8);
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
- const uint8_t tag = 0x07;
- connection_.SetDecrypter(ENCRYPTION_INITIAL, new StrictTaggingDecrypter(tag));
- framer_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
- // Process a packet from the non-crypto stream.
- frame1_.stream_id = 3;
-
- // Process all the initial packets in order so there aren't missing packets.
- QuicPacketNumber kFirstDecimatedPacket = 101;
- for (unsigned int i = 0; i < kFirstDecimatedPacket - 1; ++i) {
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, 1 + i, !kEntropyFlag,
- !kHasStopWaiting, ENCRYPTION_INITIAL);
- }
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
- // The same as ProcessPacket(1) except that ENCRYPTION_INITIAL is used
- // instead of ENCRYPTION_NONE.
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, kFirstDecimatedPacket, !kEntropyFlag,
- !kHasStopWaiting, ENCRYPTION_INITIAL);
-
- // Check if delayed ack timer is running for the expected interval.
- EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
- EXPECT_EQ(ack_time, connection_.GetAckAlarm()->deadline());
-
- // Process packet 10 first and ensure the alarm is one eighth min_rtt.
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, kFirstDecimatedPacket + 9,
- !kEntropyFlag, !kHasStopWaiting, ENCRYPTION_INITIAL);
- ack_time = clock_.ApproximateNow() + QuicTime::Delta::FromMilliseconds(5);
- EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
- EXPECT_EQ(ack_time, connection_.GetAckAlarm()->deadline());
-
- // The 10th received packet causes an ack to be sent.
- for (int i = 0; i < 8; ++i) {
- EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, kFirstDecimatedPacket + 1 + i,
- !kEntropyFlag, !kHasStopWaiting,
- ENCRYPTION_INITIAL);
- }
- // Check that ack is sent and that delayed ack alarm is reset.
- EXPECT_EQ(2u, writer_->frame_count());
- EXPECT_FALSE(writer_->stop_waiting_frames().empty());
- EXPECT_FALSE(writer_->ack_frames().empty());
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
-}
-
-TEST_P(QuicConnectionTest,
- SendDelayedAckDecimationWithLargeReorderingEighthRtt) {
- QuicConnectionPeer::SetAckMode(
- &connection_, QuicConnection::ACK_DECIMATION_WITH_REORDERING);
- QuicConnectionPeer::SetAckDecimationDelay(&connection_, 0.125);
-
- const size_t kMinRttMs = 40;
- RttStats* rtt_stats = const_cast<RttStats*>(manager_->GetRttStats());
- rtt_stats->UpdateRtt(QuicTime::Delta::FromMilliseconds(kMinRttMs),
- QuicTime::Delta::Zero(), QuicTime::Zero());
- // The ack time should be based on min_rtt/8, since it's less than the
- // default delayed ack time.
- QuicTime ack_time = clock_.ApproximateNow() +
- QuicTime::Delta::FromMilliseconds(kMinRttMs / 8);
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
- const uint8_t tag = 0x07;
- connection_.SetDecrypter(ENCRYPTION_INITIAL, new StrictTaggingDecrypter(tag));
- framer_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
- // Process a packet from the non-crypto stream.
- frame1_.stream_id = 3;
-
- // Process all the initial packets in order so there aren't missing packets.
- QuicPacketNumber kFirstDecimatedPacket = 101;
- for (unsigned int i = 0; i < kFirstDecimatedPacket - 1; ++i) {
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, 1 + i, !kEntropyFlag,
- !kHasStopWaiting, ENCRYPTION_INITIAL);
- }
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
- // The same as ProcessPacket(1) except that ENCRYPTION_INITIAL is used
- // instead of ENCRYPTION_NONE.
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, kFirstDecimatedPacket, !kEntropyFlag,
- !kHasStopWaiting, ENCRYPTION_INITIAL);
-
- // Check if delayed ack timer is running for the expected interval.
- EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
- EXPECT_EQ(ack_time, connection_.GetAckAlarm()->deadline());
-
- // Process packet 10 first and ensure the alarm is one eighth min_rtt.
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, kFirstDecimatedPacket + 19,
- !kEntropyFlag, !kHasStopWaiting, ENCRYPTION_INITIAL);
- ack_time = clock_.ApproximateNow() + QuicTime::Delta::FromMilliseconds(5);
- EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
- EXPECT_EQ(ack_time, connection_.GetAckAlarm()->deadline());
-
- // The 10th received packet causes an ack to be sent.
- for (int i = 0; i < 8; ++i) {
- EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, kFirstDecimatedPacket + 1 + i,
- !kEntropyFlag, !kHasStopWaiting,
- ENCRYPTION_INITIAL);
- }
- // Check that ack is sent and that delayed ack alarm is reset.
- EXPECT_EQ(2u, writer_->frame_count());
- EXPECT_FALSE(writer_->stop_waiting_frames().empty());
- EXPECT_FALSE(writer_->ack_frames().empty());
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
-
- // The next packet received in order will cause an immediate ack,
- // because it fills a hole.
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- ProcessDataPacketAtLevel(kDefaultPathId, kFirstDecimatedPacket + 10,
- !kEntropyFlag, !kHasStopWaiting, ENCRYPTION_INITIAL);
- // Check that ack is sent and that delayed ack alarm is reset.
- EXPECT_EQ(2u, writer_->frame_count());
- EXPECT_FALSE(writer_->stop_waiting_frames().empty());
- EXPECT_FALSE(writer_->ack_frames().empty());
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
-}
-
-TEST_P(QuicConnectionTest, SendDelayedAckOnHandshakeConfirmed) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- ProcessPacket(kDefaultPathId, 1);
- // Check that ack is sent and that delayed ack alarm is set.
- EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
- QuicTime ack_time = clock_.ApproximateNow() + DefaultDelayedAckTime();
- EXPECT_EQ(ack_time, connection_.GetAckAlarm()->deadline());
-
- // Completing the handshake as the server does nothing.
- QuicConnectionPeer::SetPerspective(&connection_, Perspective::IS_SERVER);
- connection_.OnHandshakeComplete();
- EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
- EXPECT_EQ(ack_time, connection_.GetAckAlarm()->deadline());
-
- // Complete the handshake as the client decreases the delayed ack time to 0ms.
- QuicConnectionPeer::SetPerspective(&connection_, Perspective::IS_CLIENT);
- connection_.OnHandshakeComplete();
- EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
- EXPECT_EQ(clock_.ApproximateNow(), connection_.GetAckAlarm()->deadline());
-}
-
-TEST_P(QuicConnectionTest, SendDelayedAckOnSecondPacket) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- ProcessPacket(kDefaultPathId, 1);
- ProcessPacket(kDefaultPathId, 2);
- // Check that ack is sent and that delayed ack alarm is reset.
- EXPECT_EQ(2u, writer_->frame_count());
- EXPECT_FALSE(writer_->stop_waiting_frames().empty());
- EXPECT_FALSE(writer_->ack_frames().empty());
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
-}
-
-TEST_P(QuicConnectionTest, NoAckOnOldNacks) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- // Drop one packet, triggering a sequence of acks.
- ProcessPacket(kDefaultPathId, 2);
- size_t frames_per_ack = 2;
- EXPECT_EQ(frames_per_ack, writer_->frame_count());
- EXPECT_FALSE(writer_->ack_frames().empty());
- writer_->Reset();
- ProcessPacket(kDefaultPathId, 3);
- EXPECT_EQ(frames_per_ack, writer_->frame_count());
- EXPECT_FALSE(writer_->ack_frames().empty());
- writer_->Reset();
- ProcessPacket(kDefaultPathId, 4);
- EXPECT_EQ(frames_per_ack, writer_->frame_count());
- EXPECT_FALSE(writer_->ack_frames().empty());
- writer_->Reset();
- ProcessPacket(kDefaultPathId, 5);
- EXPECT_EQ(frames_per_ack, writer_->frame_count());
- EXPECT_FALSE(writer_->ack_frames().empty());
- writer_->Reset();
- // Now only set the timer on the 6th packet, instead of sending another ack.
- ProcessPacket(kDefaultPathId, 6);
- EXPECT_EQ(0u, writer_->frame_count());
- EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
-}
-
-TEST_P(QuicConnectionTest, SendDelayedAckOnOutgoingPacket) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- ProcessPacket(kDefaultPathId, 1);
- connection_.SendStreamDataWithString(kClientDataStreamId1, "foo", 0, !kFin,
- nullptr);
- // Check that ack is bundled with outgoing data and that delayed ack
- // alarm is reset.
- EXPECT_EQ(3u, writer_->frame_count());
- EXPECT_FALSE(writer_->stop_waiting_frames().empty());
- EXPECT_FALSE(writer_->ack_frames().empty());
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
-}
-
-TEST_P(QuicConnectionTest, SendDelayedAckOnOutgoingCryptoPacket) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- ProcessPacket(kDefaultPathId, 1);
- connection_.SendStreamDataWithString(kCryptoStreamId, "foo", 0, !kFin,
- nullptr);
- // Check that ack is bundled with outgoing crypto data.
- EXPECT_EQ(3u, writer_->frame_count());
- EXPECT_FALSE(writer_->ack_frames().empty());
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
-}
-
-TEST_P(QuicConnectionTest, BlockAndBufferOnFirstCHLOPacketOfTwo) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- ProcessPacket(kDefaultPathId, 1);
- BlockOnNextWrite();
- writer_->set_is_write_blocked_data_buffered(true);
- connection_.SendStreamDataWithString(kCryptoStreamId, "foo", 0, !kFin,
- nullptr);
- EXPECT_TRUE(writer_->IsWriteBlocked());
- EXPECT_FALSE(connection_.HasQueuedData());
- connection_.SendStreamDataWithString(kCryptoStreamId, "bar", 3, !kFin,
- nullptr);
- EXPECT_TRUE(writer_->IsWriteBlocked());
- EXPECT_TRUE(connection_.HasQueuedData());
-}
-
-TEST_P(QuicConnectionTest, BundleAckForSecondCHLO) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
- EXPECT_CALL(visitor_, OnCanWrite())
- .WillOnce(IgnoreResult(InvokeWithoutArgs(
- &connection_, &TestConnection::SendCryptoStreamData)));
- // Process a packet from the crypto stream, which is frame1_'s default.
- // Receiving the CHLO as packet 2 first will cause the connection to
- // immediately send an ack, due to the packet gap.
- ProcessPacket(kDefaultPathId, 2);
- // Check that ack is sent and that delayed ack alarm is reset.
- EXPECT_EQ(3u, writer_->frame_count());
- EXPECT_FALSE(writer_->stop_waiting_frames().empty());
- EXPECT_EQ(1u, writer_->stream_frames().size());
- EXPECT_FALSE(writer_->ack_frames().empty());
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
-}
-
-TEST_P(QuicConnectionTest, BundleAckWithDataOnIncomingAck) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- connection_.SendStreamDataWithString(kClientDataStreamId1, "foo", 0, !kFin,
- nullptr);
- connection_.SendStreamDataWithString(kClientDataStreamId1, "foo", 3, !kFin,
- nullptr);
- // Ack the second packet, which will retransmit the first packet.
- QuicAckFrame ack = InitAckFrame(2);
- NackPacket(1, &ack);
- SendAlgorithmInterface::CongestionVector lost_packets;
- lost_packets.push_back(std::make_pair(1, kMaxPacketSize));
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _))
- .WillOnce(SetArgPointee<4>(lost_packets));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- ProcessAckPacket(&ack);
- EXPECT_EQ(1u, writer_->frame_count());
- EXPECT_EQ(1u, writer_->stream_frames().size());
- writer_->Reset();
-
- // Now ack the retransmission, which will both raise the high water mark
- // and see if there is more data to send.
- ack = InitAckFrame(3);
- NackPacket(1, &ack);
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- ProcessAckPacket(&ack);
-
- // Check that no packet is sent and the ack alarm isn't set.
- EXPECT_EQ(0u, writer_->frame_count());
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
- writer_->Reset();
-
- // Send the same ack, but send both data and an ack together.
- ack = InitAckFrame(3);
- NackPacket(1, &ack);
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _));
- EXPECT_CALL(visitor_, OnCanWrite())
- .WillOnce(IgnoreResult(InvokeWithoutArgs(
- &connection_, &TestConnection::EnsureWritableAndSendStreamData5)));
- ProcessAckPacket(&ack);
-
- // Check that ack is bundled with outgoing data and the delayed ack
- // alarm is reset.
- EXPECT_EQ(3u, writer_->frame_count());
- EXPECT_FALSE(writer_->stop_waiting_frames().empty());
- EXPECT_FALSE(writer_->ack_frames().empty());
- EXPECT_EQ(1u, writer_->stream_frames().size());
- EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
-}
-
-TEST_P(QuicConnectionTest, NoAckSentForClose) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- ProcessPacket(kDefaultPathId, 1);
- EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_PEER_GOING_AWAY, _,
- ConnectionCloseSource::FROM_PEER));
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
- ProcessClosePacket(kDefaultPathId, 2);
-}
-
-TEST_P(QuicConnectionTest, SendWhenDisconnected) {
- EXPECT_TRUE(connection_.connected());
- EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_PEER_GOING_AWAY, _,
- ConnectionCloseSource::FROM_SELF));
- connection_.CloseConnection(QUIC_PEER_GOING_AWAY, "no reason",
- ConnectionCloseBehavior::SILENT_CLOSE);
- EXPECT_FALSE(connection_.connected());
- EXPECT_FALSE(connection_.CanWriteStreamData());
- QuicPacket* packet =
- ConstructDataPacket(kDefaultPathId, 1, !kEntropyFlag, !kHasStopWaiting);
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, 1, _, _)).Times(0);
- connection_.SendPacket(ENCRYPTION_NONE, kDefaultPathId, 1, packet,
- kTestEntropyHash, HAS_RETRANSMITTABLE_DATA, false,
- false);
-}
-
-TEST_P(QuicConnectionTest, PublicReset) {
- QuicPublicResetPacket header;
- header.public_header.connection_id = connection_id_;
- header.public_header.reset_flag = true;
- header.public_header.version_flag = false;
- header.rejected_packet_number = 10101;
- std::unique_ptr<QuicEncryptedPacket> packet(
- framer_.BuildPublicResetPacket(header));
- std::unique_ptr<QuicReceivedPacket> received(
- ConstructReceivedPacket(*packet, QuicTime::Zero()));
- EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_PUBLIC_RESET, _,
- ConnectionCloseSource::FROM_PEER));
- connection_.ProcessUdpPacket(kSelfAddress, kPeerAddress, *received);
-}
-
-TEST_P(QuicConnectionTest, GoAway) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- QuicGoAwayFrame goaway;
- goaway.last_good_stream_id = 1;
- goaway.error_code = QUIC_PEER_GOING_AWAY;
- goaway.reason_phrase = "Going away.";
- EXPECT_CALL(visitor_, OnGoAway(_));
- ProcessGoAwayPacket(&goaway);
-}
-
-TEST_P(QuicConnectionTest, WindowUpdate) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- QuicWindowUpdateFrame window_update;
- window_update.stream_id = 3;
- window_update.byte_offset = 1234;
- EXPECT_CALL(visitor_, OnWindowUpdateFrame(_));
- ProcessFramePacket(QuicFrame(&window_update));
-}
-
-TEST_P(QuicConnectionTest, Blocked) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- QuicBlockedFrame blocked;
- blocked.stream_id = 3;
- EXPECT_CALL(visitor_, OnBlockedFrame(_));
- ProcessFramePacket(QuicFrame(&blocked));
-}
-
-TEST_P(QuicConnectionTest, PathClose) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- QuicPathCloseFrame path_close = QuicPathCloseFrame(1);
- ProcessPathClosePacket(&path_close);
- EXPECT_TRUE(QuicFramerPeer::IsPathClosed(
- QuicConnectionPeer::GetFramer(&connection_), 1));
-}
-
-TEST_P(QuicConnectionTest, ZeroBytePacket) {
- // Don't close the connection for zero byte packets.
- EXPECT_CALL(visitor_, OnConnectionClosed(_, _, _)).Times(0);
- QuicReceivedPacket encrypted(nullptr, 0, QuicTime::Zero());
- connection_.ProcessUdpPacket(kSelfAddress, kPeerAddress, encrypted);
-}
-
-TEST_P(QuicConnectionTest, MissingPacketsBeforeLeastUnacked) {
- // Set the packet number of the ack packet to be least unacked (4).
- QuicPacketCreatorPeer::SetPacketNumber(&peer_creator_, 3);
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- QuicStopWaitingFrame frame = InitStopWaitingFrame(4);
- ProcessStopWaitingPacket(&frame);
- if (outgoing_ack()->missing) {
- EXPECT_TRUE(outgoing_ack()->packets.Empty());
- } else {
- EXPECT_FALSE(outgoing_ack()->packets.Empty());
- }
-}
-
-TEST_P(QuicConnectionTest, ReceivedEntropyHashCalculation) {
- if (GetParam().version > QUIC_VERSION_33) {
- return;
- }
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(AtLeast(1));
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- ProcessDataPacket(kDefaultPathId, 1, kEntropyFlag);
- ProcessDataPacket(kDefaultPathId, 4, kEntropyFlag);
- ProcessDataPacket(kDefaultPathId, 3, !kEntropyFlag);
- ProcessDataPacket(kDefaultPathId, 7, kEntropyFlag);
- EXPECT_EQ(146u, outgoing_ack()->entropy_hash);
-}
-
-TEST_P(QuicConnectionTest, UpdateEntropyForReceivedPackets) {
- if (GetParam().version > QUIC_VERSION_33) {
- return;
- }
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(AtLeast(1));
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- ProcessDataPacket(kDefaultPathId, 1, kEntropyFlag);
- ProcessDataPacket(kDefaultPathId, 5, kEntropyFlag);
- ProcessDataPacket(kDefaultPathId, 4, !kEntropyFlag);
- EXPECT_EQ(34u, outgoing_ack()->entropy_hash);
- // Make 4th packet my least unacked, and update entropy for 2, 3 packets.
- QuicPacketCreatorPeer::SetPacketNumber(&peer_creator_, 5);
- QuicPacketEntropyHash six_packet_entropy_hash = 0;
- QuicPacketEntropyHash random_entropy_hash = 129u;
- QuicStopWaitingFrame frame = InitStopWaitingFrame(4);
- frame.entropy_hash = random_entropy_hash;
- if (ProcessStopWaitingPacket(&frame)) {
- six_packet_entropy_hash = 1 << 6;
- }
-
- EXPECT_EQ((random_entropy_hash + (1 << 5) + six_packet_entropy_hash),
- outgoing_ack()->entropy_hash);
-}
-
-TEST_P(QuicConnectionTest, UpdateEntropyHashUptoCurrentPacket) {
- if (GetParam().version > QUIC_VERSION_33) {
- return;
- }
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(AtLeast(1));
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- ProcessDataPacket(kDefaultPathId, 1, kEntropyFlag);
- ProcessDataPacket(kDefaultPathId, 5, !kEntropyFlag);
- ProcessDataPacket(kDefaultPathId, 22, kEntropyFlag);
- EXPECT_EQ(66u, outgoing_ack()->entropy_hash);
- QuicPacketCreatorPeer::SetPacketNumber(&peer_creator_, 22);
- QuicPacketEntropyHash random_entropy_hash = 85u;
- // Current packet is the least unacked packet.
- QuicPacketEntropyHash ack_entropy_hash;
- QuicStopWaitingFrame frame = InitStopWaitingFrame(23);
- frame.entropy_hash = random_entropy_hash;
- ack_entropy_hash = ProcessStopWaitingPacket(&frame);
- EXPECT_EQ((random_entropy_hash + ack_entropy_hash),
- outgoing_ack()->entropy_hash);
- ProcessDataPacket(kDefaultPathId, 25, kEntropyFlag);
- EXPECT_EQ((random_entropy_hash + ack_entropy_hash + (1 << (25 % 8))),
- outgoing_ack()->entropy_hash);
-}
-
-TEST_P(QuicConnectionTest, EntropyCalculationForTruncatedAck) {
- if (GetParam().version > QUIC_VERSION_33) {
- return;
- }
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(AtLeast(1));
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- QuicPacketEntropyHash entropy[51];
- entropy[0] = 0;
- for (int i = 1; i < 51; ++i) {
- bool should_send = i % 10 != 1;
- bool entropy_flag = (i & (i - 1)) != 0;
- if (!should_send) {
- entropy[i] = entropy[i - 1];
- continue;
- }
- if (entropy_flag) {
- entropy[i] = entropy[i - 1] ^ (1 << (i % 8));
- } else {
- entropy[i] = entropy[i - 1];
- }
- ProcessDataPacket(kDefaultPathId, i, entropy_flag);
- }
- for (int i = 1; i < 50; ++i) {
- EXPECT_EQ(entropy[i],
- QuicConnectionPeer::ReceivedEntropyHash(&connection_, i));
- }
-}
-
-TEST_P(QuicConnectionTest, ServerSendsVersionNegotiationPacket) {
- connection_.SetSupportedVersions(QuicSupportedVersions());
- set_perspective(Perspective::IS_SERVER);
- peer_framer_.set_version_for_tests(QUIC_VERSION_UNSUPPORTED);
-
- QuicPacketHeader header;
- header.public_header.connection_id = connection_id_;
- header.public_header.version_flag = true;
- header.path_id = kDefaultPathId;
- header.packet_number = 12;
-
- QuicFrames frames;
- frames.push_back(QuicFrame(&frame1_));
- std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
- char buffer[kMaxPacketSize];
- size_t encrypted_length = framer_.EncryptPayload(
- ENCRYPTION_NONE, kDefaultPathId, 12, *packet, buffer, kMaxPacketSize);
-
- framer_.set_version(version());
- connection_.ProcessUdpPacket(
- kSelfAddress, kPeerAddress,
- QuicReceivedPacket(buffer, encrypted_length, QuicTime::Zero(), false));
- EXPECT_TRUE(writer_->version_negotiation_packet() != nullptr);
-
- size_t num_versions = arraysize(kSupportedQuicVersions);
- ASSERT_EQ(num_versions,
- writer_->version_negotiation_packet()->versions.size());
-
- // We expect all versions in kSupportedQuicVersions to be
- // included in the packet.
- for (size_t i = 0; i < num_versions; ++i) {
- EXPECT_EQ(kSupportedQuicVersions[i],
- writer_->version_negotiation_packet()->versions[i]);
- }
-}
-
-TEST_P(QuicConnectionTest, ServerSendsVersionNegotiationPacketSocketBlocked) {
- connection_.SetSupportedVersions(QuicSupportedVersions());
- set_perspective(Perspective::IS_SERVER);
- peer_framer_.set_version_for_tests(QUIC_VERSION_UNSUPPORTED);
-
- QuicPacketHeader header;
- header.public_header.connection_id = connection_id_;
- header.public_header.version_flag = true;
- header.packet_number = 12;
-
- QuicFrames frames;
- frames.push_back(QuicFrame(&frame1_));
- std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
- char buffer[kMaxPacketSize];
- size_t encrypted_length = framer_.EncryptPayload(
- ENCRYPTION_NONE, kDefaultPathId, 12, *packet, buffer, kMaxPacketSize);
-
- framer_.set_version(version());
- BlockOnNextWrite();
- connection_.ProcessUdpPacket(
- kSelfAddress, kPeerAddress,
- QuicReceivedPacket(buffer, encrypted_length, QuicTime::Zero(), false));
- EXPECT_EQ(0u, writer_->last_packet_size());
- EXPECT_TRUE(connection_.HasQueuedData());
-
- writer_->SetWritable();
- connection_.OnCanWrite();
- EXPECT_TRUE(writer_->version_negotiation_packet() != nullptr);
-
- size_t num_versions = arraysize(kSupportedQuicVersions);
- ASSERT_EQ(num_versions,
- writer_->version_negotiation_packet()->versions.size());
-
- // We expect all versions in kSupportedQuicVersions to be
- // included in the packet.
- for (size_t i = 0; i < num_versions; ++i) {
- EXPECT_EQ(kSupportedQuicVersions[i],
- writer_->version_negotiation_packet()->versions[i]);
- }
-}
-
-TEST_P(QuicConnectionTest,
- ServerSendsVersionNegotiationPacketSocketBlockedDataBuffered) {
- connection_.SetSupportedVersions(QuicSupportedVersions());
- set_perspective(Perspective::IS_SERVER);
- peer_framer_.set_version_for_tests(QUIC_VERSION_UNSUPPORTED);
-
- QuicPacketHeader header;
- header.public_header.connection_id = connection_id_;
- header.public_header.version_flag = true;
- header.packet_number = 12;
-
- QuicFrames frames;
- frames.push_back(QuicFrame(&frame1_));
- std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
- char buffer[kMaxPacketSize];
- size_t encryped_length = framer_.EncryptPayload(
- ENCRYPTION_NONE, kDefaultPathId, 12, *packet, buffer, kMaxPacketSize);
-
- framer_.set_version(version());
- set_perspective(Perspective::IS_SERVER);
- BlockOnNextWrite();
- writer_->set_is_write_blocked_data_buffered(true);
- connection_.ProcessUdpPacket(
- kSelfAddress, kPeerAddress,
- QuicReceivedPacket(buffer, encryped_length, QuicTime::Zero(), false));
- EXPECT_EQ(0u, writer_->last_packet_size());
- EXPECT_FALSE(connection_.HasQueuedData());
-}
-
-TEST_P(QuicConnectionTest, ClientHandlesVersionNegotiation) {
- // Start out with some unsupported version.
- QuicConnectionPeer::GetFramer(&connection_)
- ->set_version_for_tests(QUIC_VERSION_UNSUPPORTED);
-
- // Send a version negotiation packet.
- std::unique_ptr<QuicEncryptedPacket> encrypted(
- framer_.BuildVersionNegotiationPacket(connection_id_,
- QuicSupportedVersions()));
- std::unique_ptr<QuicReceivedPacket> received(
- ConstructReceivedPacket(*encrypted, QuicTime::Zero()));
- connection_.ProcessUdpPacket(kSelfAddress, kPeerAddress, *received);
-
- // Now force another packet. The connection should transition into
- // NEGOTIATED_VERSION state and tell the packet creator to StopSendingVersion.
- QuicPacketHeader header;
- header.public_header.connection_id = connection_id_;
- header.path_id = kDefaultPathId;
- header.packet_number = 12;
- header.public_header.version_flag = false;
- QuicFrames frames;
- frames.push_back(QuicFrame(&frame1_));
- std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
- char buffer[kMaxPacketSize];
- size_t encrypted_length = framer_.EncryptPayload(
- ENCRYPTION_NONE, kDefaultPathId, 12, *packet, buffer, kMaxPacketSize);
- ASSERT_NE(0u, encrypted_length);
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- connection_.ProcessUdpPacket(
- kSelfAddress, kPeerAddress,
- QuicReceivedPacket(buffer, encrypted_length, QuicTime::Zero(), false));
-
- ASSERT_FALSE(QuicPacketCreatorPeer::SendVersionInPacket(creator_));
-}
-
-TEST_P(QuicConnectionTest, BadVersionNegotiation) {
- // Send a version negotiation packet with the version the client started with.
- // It should be rejected.
- EXPECT_CALL(visitor_,
- OnConnectionClosed(QUIC_INVALID_VERSION_NEGOTIATION_PACKET, _,
- ConnectionCloseSource::FROM_SELF));
- std::unique_ptr<QuicEncryptedPacket> encrypted(
- framer_.BuildVersionNegotiationPacket(connection_id_,
- QuicSupportedVersions()));
- std::unique_ptr<QuicReceivedPacket> received(
- ConstructReceivedPacket(*encrypted, QuicTime::Zero()));
- connection_.ProcessUdpPacket(kSelfAddress, kPeerAddress, *received);
-}
-
-TEST_P(QuicConnectionTest, CheckSendStats) {
- connection_.SetMaxTailLossProbes(kDefaultPathId, 0);
-
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
- connection_.SendStreamDataWithString(3, "first", 0, !kFin, nullptr);
- size_t first_packet_size = writer_->last_packet_size();
-
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
- connection_.SendStreamDataWithString(5, "second", 0, !kFin, nullptr);
- size_t second_packet_size = writer_->last_packet_size();
-
- // 2 retransmissions due to rto, 1 due to explicit nack.
- EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(3);
-
- // Retransmit due to RTO.
- clock_.AdvanceTime(QuicTime::Delta::FromSeconds(10));
- connection_.GetRetransmissionAlarm()->Fire();
-
- // Retransmit due to explicit nacks.
- QuicAckFrame nack_three = InitAckFrame(4);
- NackPacket(3, &nack_three);
- NackPacket(1, &nack_three);
- SendAlgorithmInterface::CongestionVector lost_packets;
- lost_packets.push_back(std::make_pair(1, kMaxPacketSize));
- lost_packets.push_back(std::make_pair(3, kMaxPacketSize));
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _))
- .WillOnce(SetArgPointee<4>(lost_packets));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- EXPECT_CALL(visitor_, OnCanWrite());
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- ProcessAckPacket(&nack_three);
-
- EXPECT_CALL(*send_algorithm_, BandwidthEstimate())
- .WillOnce(Return(QuicBandwidth::Zero()));
-
- const QuicConnectionStats& stats = connection_.GetStats();
- EXPECT_EQ(3 * first_packet_size + 2 * second_packet_size - kQuicVersionSize,
- stats.bytes_sent);
- EXPECT_EQ(5u, stats.packets_sent);
- EXPECT_EQ(2 * first_packet_size + second_packet_size - kQuicVersionSize,
- stats.bytes_retransmitted);
- EXPECT_EQ(3u, stats.packets_retransmitted);
- EXPECT_EQ(1u, stats.rto_count);
- EXPECT_EQ(kDefaultMaxPacketSize, stats.max_packet_size);
-}
-
-TEST_P(QuicConnectionTest, ProcessFramesIfPacketClosedConnection) {
- // Construct a packet with stream frame and connection close frame.
- QuicPacketHeader header;
- header.public_header.connection_id = connection_id_;
- header.packet_number = 1;
- header.public_header.version_flag = false;
-
- QuicConnectionCloseFrame qccf;
- qccf.error_code = QUIC_PEER_GOING_AWAY;
-
- QuicFrames frames;
- frames.push_back(QuicFrame(&frame1_));
- frames.push_back(QuicFrame(&qccf));
- std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
- EXPECT_TRUE(nullptr != packet.get());
- char buffer[kMaxPacketSize];
- size_t encrypted_length = framer_.EncryptPayload(
- ENCRYPTION_NONE, kDefaultPathId, 1, *packet, buffer, kMaxPacketSize);
-
- EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_PEER_GOING_AWAY, _,
- ConnectionCloseSource::FROM_PEER));
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- connection_.ProcessUdpPacket(
- kSelfAddress, kPeerAddress,
- QuicReceivedPacket(buffer, encrypted_length, QuicTime::Zero(), false));
-}
-
-TEST_P(QuicConnectionTest, SelectMutualVersion) {
- connection_.SetSupportedVersions(QuicSupportedVersions());
- // Set the connection to speak the lowest quic version.
- connection_.set_version(QuicVersionMin());
- EXPECT_EQ(QuicVersionMin(), connection_.version());
-
- // Pass in available versions which includes a higher mutually supported
- // version. The higher mutually supported version should be selected.
- QuicVersionVector supported_versions;
- for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) {
- supported_versions.push_back(kSupportedQuicVersions[i]);
- }
- EXPECT_TRUE(connection_.SelectMutualVersion(supported_versions));
- EXPECT_EQ(QuicVersionMax(), connection_.version());
-
- // Expect that the lowest version is selected.
- // Ensure the lowest supported version is less than the max, unless they're
- // the same.
- EXPECT_LE(QuicVersionMin(), QuicVersionMax());
- QuicVersionVector lowest_version_vector;
- lowest_version_vector.push_back(QuicVersionMin());
- EXPECT_TRUE(connection_.SelectMutualVersion(lowest_version_vector));
- EXPECT_EQ(QuicVersionMin(), connection_.version());
-
- // Shouldn't be able to find a mutually supported version.
- QuicVersionVector unsupported_version;
- unsupported_version.push_back(QUIC_VERSION_UNSUPPORTED);
- EXPECT_FALSE(connection_.SelectMutualVersion(unsupported_version));
-}
-
-TEST_P(QuicConnectionTest, ConnectionCloseWhenWritable) {
- EXPECT_FALSE(writer_->IsWriteBlocked());
-
- // Send a packet.
- connection_.SendStreamDataWithString(1, "foo", 0, !kFin, nullptr);
- EXPECT_EQ(0u, connection_.NumQueuedPackets());
- EXPECT_EQ(1u, writer_->packets_write_attempts());
-
- TriggerConnectionClose();
- EXPECT_EQ(2u, writer_->packets_write_attempts());
-}
-
-TEST_P(QuicConnectionTest, ConnectionCloseGettingWriteBlocked) {
- BlockOnNextWrite();
- TriggerConnectionClose();
- EXPECT_EQ(1u, writer_->packets_write_attempts());
- EXPECT_TRUE(writer_->IsWriteBlocked());
-}
-
-TEST_P(QuicConnectionTest, ConnectionCloseWhenWriteBlocked) {
- BlockOnNextWrite();
- connection_.SendStreamDataWithString(1, "foo", 0, !kFin, nullptr);
- EXPECT_EQ(1u, connection_.NumQueuedPackets());
- EXPECT_EQ(1u, writer_->packets_write_attempts());
- EXPECT_TRUE(writer_->IsWriteBlocked());
- TriggerConnectionClose();
- EXPECT_EQ(1u, writer_->packets_write_attempts());
-}
-
-TEST_P(QuicConnectionTest, AckNotifierTriggerCallback) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- // Create a listener which we expect to be called.
- scoped_refptr<MockAckListener> listener(new MockAckListener);
- EXPECT_CALL(*listener, OnPacketAcked(_, _)).Times(1);
-
- // Send some data, which will register the listener to be notified.
- connection_.SendStreamDataWithString(1, "foo", 0, !kFin, listener.get());
-
- // Process an ACK from the server which should trigger the callback.
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- QuicAckFrame frame = InitAckFrame(1);
- ProcessAckPacket(&frame);
-}
-
-TEST_P(QuicConnectionTest, AckNotifierFailToTriggerCallback) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- // Create a listener which we don't expect to be called.
- scoped_refptr<MockAckListener> listener(new MockAckListener);
- EXPECT_CALL(*listener, OnPacketAcked(_, _)).Times(0);
-
- // Send some data, which will register the listener to be notified. This will
- // not be ACKed and so the listener should never be called.
- connection_.SendStreamDataWithString(1, "foo", 0, !kFin, listener.get());
-
- // Send some other data which we will ACK.
- connection_.SendStreamDataWithString(1, "foo", 0, !kFin, nullptr);
- connection_.SendStreamDataWithString(1, "bar", 0, !kFin, nullptr);
-
- // Now we receive ACK for packets 2 and 3, but importantly missing packet 1
- // which we registered to be notified about.
- QuicAckFrame frame = InitAckFrame(3);
- NackPacket(1, &frame);
- SendAlgorithmInterface::CongestionVector lost_packets;
- lost_packets.push_back(std::make_pair(1, kMaxPacketSize));
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _))
- .WillOnce(SetArgPointee<4>(lost_packets));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- ProcessAckPacket(&frame);
-}
-
-TEST_P(QuicConnectionTest, AckNotifierCallbackAfterRetransmission) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- // Create a listener which we expect to be called.
- scoped_refptr<MockAckListener> listener(new MockAckListener);
- EXPECT_CALL(*listener, OnPacketRetransmitted(3)).Times(1);
- EXPECT_CALL(*listener, OnPacketAcked(3, _)).Times(1);
-
- // Send four packets, and register to be notified on ACK of packet 2.
- connection_.SendStreamDataWithString(3, "foo", 0, !kFin, nullptr);
- connection_.SendStreamDataWithString(3, "bar", 0, !kFin, listener.get());
- connection_.SendStreamDataWithString(3, "baz", 0, !kFin, nullptr);
- connection_.SendStreamDataWithString(3, "qux", 0, !kFin, nullptr);
-
- // Now we receive ACK for packets 1, 3, and 4 and lose 2.
- QuicAckFrame frame = InitAckFrame(4);
- NackPacket(2, &frame);
- SendAlgorithmInterface::CongestionVector lost_packets;
- lost_packets.push_back(std::make_pair(2, kMaxPacketSize));
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _))
- .WillOnce(SetArgPointee<4>(lost_packets));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
- ProcessAckPacket(&frame);
-
- // Now we get an ACK for packet 5 (retransmitted packet 2), which should
- // trigger the callback.
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- QuicAckFrame second_ack_frame = InitAckFrame(5);
- ProcessAckPacket(&second_ack_frame);
-}
-
-// AckNotifierCallback is triggered by the ack of a packet that timed
-// out and was retransmitted, even though the retransmission has a
-// different packet number.
-TEST_P(QuicConnectionTest, AckNotifierCallbackForAckAfterRTO) {
- connection_.SetMaxTailLossProbes(kDefaultPathId, 0);
-
- // Create a listener which we expect to be called.
- scoped_refptr<MockAckListener> listener(new StrictMock<MockAckListener>);
-
- QuicTime default_retransmission_time =
- clock_.ApproximateNow() + DefaultRetransmissionTime();
- connection_.SendStreamDataWithString(3, "foo", 0, !kFin, listener.get());
- EXPECT_EQ(1u, stop_waiting()->least_unacked);
-
- EXPECT_EQ(1u, writer_->header().packet_number);
- EXPECT_EQ(default_retransmission_time,
- connection_.GetRetransmissionAlarm()->deadline());
- // Simulate the retransmission alarm firing.
- clock_.AdvanceTime(DefaultRetransmissionTime());
- EXPECT_CALL(*listener, OnPacketRetransmitted(3));
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, 2u, _, _));
- connection_.GetRetransmissionAlarm()->Fire();
- EXPECT_EQ(2u, writer_->header().packet_number);
- // We do not raise the high water mark yet.
- EXPECT_EQ(1u, stop_waiting()->least_unacked);
-
- // Ack the original packet, which will revert the RTO.
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- EXPECT_CALL(*listener, OnPacketAcked(3, _));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- QuicAckFrame ack_frame = InitAckFrame(1);
- ProcessAckPacket(&ack_frame);
-
- // listener is not notified again when the retransmit is acked.
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- QuicAckFrame second_ack_frame = InitAckFrame(2);
- ProcessAckPacket(&second_ack_frame);
-}
-
-// AckNotifierCallback is triggered by the ack of a packet that was
-// previously nacked, even though the retransmission has a different
-// packet number.
-TEST_P(QuicConnectionTest, AckNotifierCallbackForAckOfNackedPacket) {
- // Create a listener which we expect to be called.
- scoped_refptr<MockAckListener> listener(new StrictMock<MockAckListener>);
-
- // Send four packets, and register to be notified on ACK of packet 2.
- connection_.SendStreamDataWithString(3, "foo", 0, !kFin, nullptr);
- connection_.SendStreamDataWithString(3, "bar", 0, !kFin, listener.get());
- connection_.SendStreamDataWithString(3, "baz", 0, !kFin, nullptr);
- connection_.SendStreamDataWithString(3, "qux", 0, !kFin, nullptr);
-
- // Now we receive ACK for packets 1, 3, and 4 and lose 2.
- QuicAckFrame frame = InitAckFrame(4);
- NackPacket(2, &frame);
- EXPECT_CALL(*listener, OnPacketRetransmitted(_));
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- SendAlgorithmInterface::CongestionVector lost_packets;
- lost_packets.push_back(std::make_pair(2, kMaxPacketSize));
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _))
- .WillOnce(SetArgPointee<4>(lost_packets));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
- ProcessAckPacket(&frame);
-
- // Now we get an ACK for packet 2, which was previously nacked.
- EXPECT_CALL(*listener, OnPacketAcked(3, _));
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _));
- QuicAckFrame second_ack_frame = InitAckFrame(4);
- ProcessAckPacket(&second_ack_frame);
-
- // Verify that the listener is not notified again when the
- // retransmit is acked.
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- QuicAckFrame third_ack_frame = InitAckFrame(5);
- ProcessAckPacket(&third_ack_frame);
-}
-
-TEST_P(QuicConnectionTest, OnPacketHeaderDebugVisitor) {
- QuicPacketHeader header;
-
- std::unique_ptr<MockQuicConnectionDebugVisitor> debug_visitor(
- new MockQuicConnectionDebugVisitor());
- connection_.set_debug_visitor(debug_visitor.get());
- EXPECT_CALL(*debug_visitor, OnPacketHeader(Ref(header))).Times(1);
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_)).Times(1);
- EXPECT_CALL(*debug_visitor, OnSuccessfulVersionNegotiation(_)).Times(1);
- connection_.OnPacketHeader(header);
-}
-
-TEST_P(QuicConnectionTest, Pacing) {
- // static_cast here does not work if using multipath_sent_packet_manager.
- FLAGS_quic_enable_multipath = false;
- TestConnection server(connection_id_, kSelfAddress, helper_.get(),
- alarm_factory_.get(), writer_.get(),
- Perspective::IS_SERVER, version());
- TestConnection client(connection_id_, kPeerAddress, helper_.get(),
- alarm_factory_.get(), writer_.get(),
- Perspective::IS_CLIENT, version());
- EXPECT_FALSE(QuicSentPacketManagerPeer::UsingPacing(
- static_cast<const QuicSentPacketManager*>(
- &client.sent_packet_manager())));
- EXPECT_FALSE(QuicSentPacketManagerPeer::UsingPacing(
- static_cast<const QuicSentPacketManager*>(
- &server.sent_packet_manager())));
-}
-
-TEST_P(QuicConnectionTest, WindowUpdateInstigateAcks) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- // Send a WINDOW_UPDATE frame.
- QuicWindowUpdateFrame window_update;
- window_update.stream_id = 3;
- window_update.byte_offset = 1234;
- EXPECT_CALL(visitor_, OnWindowUpdateFrame(_));
- ProcessFramePacket(QuicFrame(&window_update));
-
- // Ensure that this has caused the ACK alarm to be set.
- QuicAlarm* ack_alarm = QuicConnectionPeer::GetAckAlarm(&connection_);
- EXPECT_TRUE(ack_alarm->IsSet());
-}
-
-TEST_P(QuicConnectionTest, BlockedFrameInstigateAcks) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- // Send a BLOCKED frame.
- QuicBlockedFrame blocked;
- blocked.stream_id = 3;
- EXPECT_CALL(visitor_, OnBlockedFrame(_));
- ProcessFramePacket(QuicFrame(&blocked));
-
- // Ensure that this has caused the ACK alarm to be set.
- QuicAlarm* ack_alarm = QuicConnectionPeer::GetAckAlarm(&connection_);
- EXPECT_TRUE(ack_alarm->IsSet());
-}
-
-TEST_P(QuicConnectionTest, NoDataNoFin) {
- // Make sure that a call to SendStreamWithData, with no data and no FIN, does
- // not result in a QuicAckNotifier being used-after-free (fail under ASAN).
- // Regression test for b/18594622
- scoped_refptr<MockAckListener> listener(new MockAckListener);
- EXPECT_DFATAL(
- connection_.SendStreamDataWithString(3, "", 0, !kFin, listener.get()),
- "Attempt to send empty stream frame");
-}
-
-TEST_P(QuicConnectionTest, DoNotSendGoAwayTwice) {
- EXPECT_FALSE(connection_.goaway_sent());
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
- connection_.SendGoAway(QUIC_PEER_GOING_AWAY, kHeadersStreamId, "Going Away.");
- EXPECT_TRUE(connection_.goaway_sent());
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
- connection_.SendGoAway(QUIC_PEER_GOING_AWAY, kHeadersStreamId, "Going Away.");
-}
-
-TEST_P(QuicConnectionTest, ReevaluateTimeUntilSendOnAck) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- connection_.SendStreamDataWithString(kClientDataStreamId1, "foo", 0, !kFin,
- nullptr);
-
- // Evaluate CanWrite, and have it return a non-Zero value.
- EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _))
- .WillRepeatedly(Return(QuicTime::Delta::FromMilliseconds(1)));
- connection_.OnCanWrite();
- EXPECT_TRUE(connection_.GetSendAlarm()->IsSet());
- EXPECT_EQ(clock_.Now() + QuicTime::Delta::FromMilliseconds(1),
- connection_.GetSendAlarm()->deadline());
-
- // Process an ack and the send alarm will be set to the new 2ms delay.
- QuicAckFrame ack = InitAckFrame(1);
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
- EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _))
- .WillRepeatedly(Return(QuicTime::Delta::FromMilliseconds(2)));
- ProcessAckPacket(&ack);
- EXPECT_EQ(1u, writer_->frame_count());
- EXPECT_EQ(1u, writer_->stream_frames().size());
- EXPECT_TRUE(connection_.GetSendAlarm()->IsSet());
- EXPECT_EQ(clock_.Now() + QuicTime::Delta::FromMilliseconds(2),
- connection_.GetSendAlarm()->deadline());
- writer_->Reset();
-}
-
-TEST_P(QuicConnectionTest, SendAcksImmediately) {
- CongestionBlockWrites();
- SendAckPacketToPeer();
-}
-
-TEST_P(QuicConnectionTest, SendPingImmediately) {
- CongestionBlockWrites();
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
- connection_.SendPing();
- EXPECT_FALSE(connection_.HasQueuedData());
-}
-
-TEST_P(QuicConnectionTest, SendingUnencryptedStreamDataFails) {
- FLAGS_quic_never_write_unencrypted_data = true;
- EXPECT_CALL(visitor_,
- OnConnectionClosed(QUIC_ATTEMPT_TO_SEND_UNENCRYPTED_STREAM_DATA,
- _, ConnectionCloseSource::FROM_SELF));
- EXPECT_DFATAL(connection_.SendStreamDataWithString(3, "", 0, kFin, nullptr),
- "Cannot send stream data without encryption.");
- EXPECT_FALSE(connection_.connected());
-}
-
-TEST_P(QuicConnectionTest, EnableMultipathNegotiation) {
- // Test multipath negotiation during crypto handshake. Multipath is enabled
- // when both endpoints enable multipath.
- ValueRestore<bool> old_flag(&FLAGS_quic_enable_multipath, true);
- EXPECT_TRUE(connection_.connected());
- EXPECT_FALSE(QuicConnectionPeer::IsMultipathEnabled(&connection_));
- EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
- QuicConfig config;
- // Enable multipath on server side.
- config.SetMultipathEnabled(true);
-
- // Create a handshake message enables multipath.
- CryptoHandshakeMessage msg;
- string error_details;
- QuicConfig client_config;
- // Enable multipath on client side.
- client_config.SetMultipathEnabled(true);
- client_config.ToHandshakeMessage(&msg);
- const QuicErrorCode error =
- config.ProcessPeerHello(msg, CLIENT, &error_details);
- EXPECT_EQ(QUIC_NO_ERROR, error);
-
- connection_.SetFromConfig(config);
- EXPECT_TRUE(QuicConnectionPeer::IsMultipathEnabled(&connection_));
-}
-
-TEST_P(QuicConnectionTest, ClosePath) {
- QuicPathId kTestPathId = 1;
- connection_.SendPathClose(kTestPathId);
- EXPECT_TRUE(QuicFramerPeer::IsPathClosed(
- QuicConnectionPeer::GetFramer(&connection_), kTestPathId));
-}
-
-TEST_P(QuicConnectionTest, BadMultipathFlag) {
- EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_BAD_MULTIPATH_FLAG, _,
- ConnectionCloseSource::FROM_SELF));
-
- // Receieve a packet with multipath flag on when multipath is not enabled.
- EXPECT_TRUE(connection_.connected());
- EXPECT_FALSE(QuicConnectionPeer::IsMultipathEnabled(&connection_));
- peer_creator_.SetCurrentPath(/*path_id=*/1u, 1u, 10u);
- QuicStreamFrame stream_frame(1u, false, 0u, StringPiece());
- EXPECT_DFATAL(
- ProcessFramePacket(QuicFrame(&stream_frame)),
- "Received a packet with multipath flag but multipath is not enabled.");
- EXPECT_FALSE(connection_.connected());
-}
-
-TEST_P(QuicConnectionTest, OnPathDegrading) {
- QuicByteCount packet_size;
- const size_t kMinTimeoutsBeforePathDegrading = 2;
-
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
- .WillOnce(DoAll(SaveArg<3>(&packet_size), Return(true)));
- connection_.SendStreamDataWithString(3, "packet", 0, !kFin, nullptr);
- size_t num_timeouts = kMinTimeoutsBeforePathDegrading +
- QuicSentPacketManagerPeer::GetMaxTailLossProbes(
- QuicConnectionPeer::GetSentPacketManager(
- &connection_, kDefaultPathId));
- for (size_t i = 1; i < num_timeouts; ++i) {
- clock_.AdvanceTime(QuicTime::Delta::FromSeconds(10 * i));
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, packet_size, _));
- connection_.GetRetransmissionAlarm()->Fire();
- }
- // Next RTO should cause OnPathDegrading to be called before the
- // retransmission is sent out.
- clock_.AdvanceTime(
- QuicTime::Delta::FromSeconds(kMinTimeoutsBeforePathDegrading * 10));
- {
- InSequence s;
- EXPECT_CALL(visitor_, OnPathDegrading());
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, packet_size, _));
- }
- connection_.GetRetransmissionAlarm()->Fire();
-}
-
-TEST_P(QuicConnectionTest, MultipleCallsToCloseConnection) {
- // Verifies that multiple calls to CloseConnection do not
- // result in multiple attempts to close the connection - it will be marked as
- // disconnected after the first call.
- EXPECT_CALL(visitor_, OnConnectionClosed(_, _, _)).Times(1);
- connection_.CloseConnection(QUIC_NO_ERROR, "no reason",
- ConnectionCloseBehavior::SILENT_CLOSE);
- connection_.CloseConnection(QUIC_NO_ERROR, "no reason",
- ConnectionCloseBehavior::SILENT_CLOSE);
-}
-
-TEST_P(QuicConnectionTest, ServerReceivesChloOnNonCryptoStream) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- set_perspective(Perspective::IS_SERVER);
- QuicPacketCreatorPeer::SetSendVersionInPacket(creator_, false);
-
- CryptoHandshakeMessage message;
- CryptoFramer framer;
- message.set_tag(kCHLO);
- std::unique_ptr<QuicData> data(framer.ConstructHandshakeMessage(message));
- frame1_.stream_id = 10;
- frame1_.data_buffer = data->data();
- frame1_.data_length = data->length();
-
- EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_MAYBE_CORRUPTED_MEMORY, _,
- ConnectionCloseSource::FROM_SELF));
- ProcessFramePacket(QuicFrame(&frame1_));
-}
-
-TEST_P(QuicConnectionTest, ClientReceivesRejOnNonCryptoStream) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- CryptoHandshakeMessage message;
- CryptoFramer framer;
- message.set_tag(kREJ);
- std::unique_ptr<QuicData> data(framer.ConstructHandshakeMessage(message));
- frame1_.stream_id = 10;
- frame1_.data_buffer = data->data();
- frame1_.data_length = data->length();
-
- EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_MAYBE_CORRUPTED_MEMORY, _,
- ConnectionCloseSource::FROM_SELF));
- ProcessFramePacket(QuicFrame(&frame1_));
-}
-
-} // namespace
-} // namespace test
-} // namespace net
« no previous file with comments | « net/quic/quic_connection_stats.cc ('k') | net/quic/quic_crypto_client_stream.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698