src/net/quic/congestion_control/quic_congestion_manager_test.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/logging.h"
   6 #include "base/memory/scoped_ptr.h"
   7 #include "net/quic/congestion_control/inter_arrival_sender.h"
   8 #include "net/quic/congestion_control/quic_congestion_manager.h"
   9 #include "net/quic/quic_protocol.h"
  10 #include "net/quic/test_tools/mock_clock.h"
  11 #include "net/quic/test_tools/quic_test_utils.h"
  12 #include "testing/gmock/include/gmock/gmock.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 using testing::_;
  16 using testing::StrictMock;
  17 using testing::Return;
  18
  19 namespace net {
  20 namespace test {
  21
  22 class QuicCongestionManagerPeer : public QuicCongestionManager {
  23  public:
  24   explicit QuicCongestionManagerPeer(const QuicClock* clock,
  25                                      CongestionFeedbackType congestion_type)
  26       : QuicCongestionManager(clock, congestion_type) {
  27   }
  28   void SetSendAlgorithm(SendAlgorithmInterface* send_algorithm) {
  29     this->send_algorithm_.reset(send_algorithm);
  30   }
  31
  32   using QuicCongestionManager::rtt;
  33   const SendAlgorithmInterface::SentPacketsMap& packet_history_map() {
  34     return packet_history_map_;
  35   }
  36  private:
  37   DISALLOW_COPY_AND_ASSIGN(QuicCongestionManagerPeer);
  38 };
  39
  40 class QuicCongestionManagerTest : public ::testing::Test {
  41  protected:
  42   void SetUpCongestionType(CongestionFeedbackType congestion_type) {
  43     manager_.reset(new QuicCongestionManagerPeer(&clock_, congestion_type));
  44   }
  45
  46   static const HasRetransmittableData kIgnored = HAS_RETRANSMITTABLE_DATA;
  47
  48   MockClock clock_;
  49   scoped_ptr<QuicCongestionManagerPeer> manager_;
  50 };
  51
  52 TEST_F(QuicCongestionManagerTest, Bandwidth) {
  53   SetUpCongestionType(kFixRate);
  54   QuicAckFrame ack;
  55   manager_->OnIncomingAckFrame(ack, clock_.Now());
  56
  57   QuicCongestionFeedbackFrame feedback;
  58   feedback.type = kFixRate;
  59   feedback.fix_rate.bitrate = QuicBandwidth::FromKBytesPerSecond(100);
  60   manager_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
  61
  62   for (int i = 1; i <= 100; ++i) {
  63     QuicTime::Delta advance_time = manager_->TimeUntilSend(
  64         clock_.Now(), NOT_RETRANSMISSION, kIgnored, NOT_HANDSHAKE);
  65     clock_.AdvanceTime(advance_time);
  66     EXPECT_TRUE(manager_->TimeUntilSend(
  67         clock_.Now(), NOT_RETRANSMISSION, kIgnored, NOT_HANDSHAKE).IsZero());
  68     manager_->OnPacketSent(i, clock_.Now(), 1000, NOT_RETRANSMISSION,
  69                          HAS_RETRANSMITTABLE_DATA);
  70     // Ack the packet we sent.
  71     ack.received_info.largest_observed = i;
  72     manager_->OnIncomingAckFrame(ack, clock_.Now());
  73   }
  74   EXPECT_EQ(100, manager_->BandwidthEstimate().ToKBytesPerSecond());
  75   EXPECT_NEAR(100,
  76               InterArrivalSender::CalculateSentBandwidth(
  77                   manager_->packet_history_map(),
  78                   clock_.Now()).ToKBytesPerSecond(),
  79               4);
  80 }
  81
  82 TEST_F(QuicCongestionManagerTest, BandwidthWith1SecondGap) {
  83   SetUpCongestionType(kFixRate);
  84   QuicAckFrame ack;
  85   manager_->OnIncomingAckFrame(ack, clock_.Now());
  86
  87   QuicCongestionFeedbackFrame feedback;
  88   feedback.type = kFixRate;
  89   feedback.fix_rate.bitrate = QuicBandwidth::FromKBytesPerSecond(100);
  90   manager_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
  91
  92   for (QuicPacketSequenceNumber sequence_number = 1; sequence_number <= 100;
  93       ++sequence_number) {
  94     clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
  95     EXPECT_TRUE(manager_->TimeUntilSend(
  96         clock_.Now(), NOT_RETRANSMISSION, kIgnored, NOT_HANDSHAKE).IsZero());
  97     manager_->OnPacketSent(sequence_number, clock_.Now(), 1000,
  98                          NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
  99     // Ack the packet we sent.
 100     ack.received_info.largest_observed = sequence_number;
 101     manager_->OnIncomingAckFrame(ack, clock_.Now());
 102   }
 103   EXPECT_EQ(100000, manager_->BandwidthEstimate().ToBytesPerSecond());
 104   EXPECT_NEAR(100000,
 105               InterArrivalSender::CalculateSentBandwidth(
 106                   manager_->packet_history_map(),
 107                   clock_.Now()).ToBytesPerSecond(),
 108               2000);
 109   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(500));
 110   EXPECT_NEAR(50000,
 111               InterArrivalSender::CalculateSentBandwidth(
 112                   manager_->packet_history_map(),
 113                   clock_.Now()).ToBytesPerSecond(),
 114               1000);
 115   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(501));
 116   EXPECT_NEAR(100000, manager_->BandwidthEstimate().ToBytesPerSecond(), 2000);
 117   EXPECT_TRUE(InterArrivalSender::CalculateSentBandwidth(
 118       manager_->packet_history_map(),
 119       clock_.Now()).IsZero());
 120   for (int i = 1; i <= 150; ++i) {
 121     EXPECT_TRUE(manager_->TimeUntilSend(
 122         clock_.Now(), NOT_RETRANSMISSION, kIgnored, NOT_HANDSHAKE).IsZero());
 123     manager_->OnPacketSent(i + 100, clock_.Now(), 1000, NOT_RETRANSMISSION,
 124                          HAS_RETRANSMITTABLE_DATA);
 125     clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
 126     // Ack the packet we sent.
 127     ack.received_info.largest_observed = i + 100;
 128     manager_->OnIncomingAckFrame(ack, clock_.Now());
 129   }
 130   EXPECT_EQ(100, manager_->BandwidthEstimate().ToKBytesPerSecond());
 131   EXPECT_NEAR(100,
 132               InterArrivalSender::CalculateSentBandwidth(
 133                   manager_->packet_history_map(),
 134                   clock_.Now()).ToKBytesPerSecond(),
 135               2);
 136 }
 137
 138 TEST_F(QuicCongestionManagerTest, Rtt) {
 139   SetUpCongestionType(kFixRate);
 140
 141   MockSendAlgorithm* send_algorithm = new StrictMock<MockSendAlgorithm>;
 142   manager_->SetSendAlgorithm(send_algorithm);
 143
 144   QuicPacketSequenceNumber sequence_number = 1;
 145   QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(15);
 146
 147   EXPECT_CALL(*send_algorithm, OnPacketSent(_, _, _, _, _))
 148                                .Times(1).WillOnce(Return(true));
 149   EXPECT_CALL(*send_algorithm,
 150               OnIncomingAck(sequence_number, _, expected_rtt)).Times(1);
 151
 152   manager_->OnPacketSent(sequence_number, clock_.Now(), 1000,
 153                          NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
 154   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(20));
 155
 156   QuicAckFrame ack;
 157   ack.received_info.largest_observed = sequence_number;
 158   ack.received_info.delta_time_largest_observed =
 159       QuicTime::Delta::FromMilliseconds(5);
 160   manager_->OnIncomingAckFrame(ack, clock_.Now());
 161   EXPECT_EQ(manager_->rtt(), expected_rtt);
 162 }
 163
 164 TEST_F(QuicCongestionManagerTest, RttWithInvalidDelta) {
 165   // Expect that the RTT is infinite since the delta_time_largest_observed is
 166   // larger than the local time elapsed aka invalid.
 167   SetUpCongestionType(kFixRate);
 168
 169   MockSendAlgorithm* send_algorithm = new StrictMock<MockSendAlgorithm>;
 170   manager_->SetSendAlgorithm(send_algorithm);
 171
 172   QuicPacketSequenceNumber sequence_number = 1;
 173   QuicTime::Delta expected_rtt = QuicTime::Delta::Infinite();
 174
 175   EXPECT_CALL(*send_algorithm, OnPacketSent(_, _, _, _, _))
 176                                .Times(1).WillOnce(Return(true));
 177   EXPECT_CALL(*send_algorithm,
 178               OnIncomingAck(sequence_number, _, expected_rtt)).Times(1);
 179
 180   manager_->OnPacketSent(sequence_number, clock_.Now(), 1000,
 181                          NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
 182   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
 183
 184   QuicAckFrame ack;
 185   ack.received_info.largest_observed = sequence_number;
 186   ack.received_info.delta_time_largest_observed =
 187       QuicTime::Delta::FromMilliseconds(11);
 188   manager_->OnIncomingAckFrame(ack, clock_.Now());
 189   EXPECT_EQ(manager_->rtt(), expected_rtt);
 190 }
 191
 192 TEST_F(QuicCongestionManagerTest, RttInfiniteDelta) {
 193   // Expect that the RTT is infinite since the delta_time_largest_observed is
 194   // infinite aka invalid.
 195   SetUpCongestionType(kFixRate);
 196
 197   MockSendAlgorithm* send_algorithm = new StrictMock<MockSendAlgorithm>;
 198   manager_->SetSendAlgorithm(send_algorithm);
 199
 200   QuicPacketSequenceNumber sequence_number = 1;
 201   QuicTime::Delta expected_rtt = QuicTime::Delta::Infinite();
 202
 203   EXPECT_CALL(*send_algorithm, OnPacketSent(_, _, _, _, _))
 204                                .Times(1).WillOnce(Return(true));
 205   EXPECT_CALL(*send_algorithm,
 206               OnIncomingAck(sequence_number, _, expected_rtt)).Times(1);
 207
 208   manager_->OnPacketSent(sequence_number, clock_.Now(), 1000,
 209                          NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
 210   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
 211
 212   QuicAckFrame ack;
 213   ack.received_info.largest_observed = sequence_number;
 214   ack.received_info.delta_time_largest_observed = QuicTime::Delta::Infinite();
 215   manager_->OnIncomingAckFrame(ack, clock_.Now());
 216   EXPECT_EQ(manager_->rtt(), expected_rtt);
 217 }
 218
 219 TEST_F(QuicCongestionManagerTest, RttZeroDelta) {
 220   // Expect that the RTT is the time between send and receive since the
 221   // delta_time_largest_observed is zero.
 222   SetUpCongestionType(kFixRate);
 223
 224   MockSendAlgorithm* send_algorithm = new StrictMock<MockSendAlgorithm>;
 225   manager_->SetSendAlgorithm(send_algorithm);
 226
 227   QuicPacketSequenceNumber sequence_number = 1;
 228   QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(10);
 229
 230   EXPECT_CALL(*send_algorithm, OnPacketSent(_, _, _, _, _))
 231                                .Times(1).WillOnce(Return(true));
 232   EXPECT_CALL(*send_algorithm, OnIncomingAck(sequence_number, _, expected_rtt))
 233       .Times(1);
 234
 235   manager_->OnPacketSent(sequence_number, clock_.Now(), 1000,
 236                          NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
 237   clock_.AdvanceTime(expected_rtt);
 238
 239   QuicAckFrame ack;
 240   ack.received_info.largest_observed = sequence_number;
 241   ack.received_info.delta_time_largest_observed = QuicTime::Delta::Zero();
 242   manager_->OnIncomingAckFrame(ack, clock_.Now());
 243   EXPECT_EQ(manager_->rtt(), expected_rtt);
 244 }
 245
 246 }  // namespace test
 247 }  // namespace net