src/net/quic/congestion_control/quic_congestion_control_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 // Test of the full congestion control chain.
   6
   7 #include "base/logging.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "net/quic/congestion_control/quic_congestion_manager.h"
  10 #include "net/quic/quic_protocol.h"
  11 #include "net/quic/test_tools/mock_clock.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 using std::max;
  15
  16 namespace net {
  17 namespace test {
  18
  19 class QuicCongestionControlTest : public ::testing::Test {
  20  protected:
  21   QuicCongestionControlTest()
  22       : start_(clock_.ApproximateNow()) {
  23   }
  24
  25   void SetUpCongestionType(CongestionFeedbackType congestion_type) {
  26     manager_.reset(new QuicCongestionManager(&clock_, congestion_type));
  27   }
  28
  29   MockClock clock_;
  30   QuicTime start_;
  31   scoped_ptr<QuicCongestionManager> manager_;
  32 };
  33
  34 TEST_F(QuicCongestionControlTest, FixedRateSenderAPI) {
  35   SetUpCongestionType(kFixRate);
  36   QuicCongestionFeedbackFrame congestion_feedback;
  37   congestion_feedback.type = kFixRate;
  38   congestion_feedback.fix_rate.bitrate = QuicBandwidth::FromKBytesPerSecond(30);
  39   manager_->OnIncomingQuicCongestionFeedbackFrame(congestion_feedback,
  40                                                   clock_.Now());
  41   EXPECT_TRUE(manager_->TimeUntilSend(clock_.Now(),
  42       NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
  43   manager_->OnPacketSent(1, clock_.Now(), kDefaultMaxPacketSize,
  44                          NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
  45   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(40),
  46             manager_->TimeUntilSend(clock_.Now(),
  47                 NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
  48   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(35));
  49   EXPECT_EQ(QuicTime::Delta::Infinite(),
  50             manager_->TimeUntilSend(clock_.Now(),
  51                 NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
  52   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
  53   EXPECT_EQ(QuicTime::Delta::Infinite(),
  54             manager_->TimeUntilSend(clock_.Now(),
  55                 NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
  56 }
  57
  58 TEST_F(QuicCongestionControlTest, FixedRatePacing) {
  59   SetUpCongestionType(kFixRate);
  60   QuicAckFrame ack;
  61   ack.received_info.largest_observed = 0;
  62   manager_->OnIncomingAckFrame(ack, clock_.Now());
  63
  64   QuicCongestionFeedbackFrame feedback;
  65   feedback.type = kFixRate;
  66   feedback.fix_rate.bitrate = QuicBandwidth::FromKBytesPerSecond(100);
  67   manager_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
  68
  69   QuicTime acc_advance_time(QuicTime::Zero());
  70   for (QuicPacketSequenceNumber i = 1; i <= 100; ++i) {
  71     EXPECT_TRUE(manager_->TimeUntilSend(clock_.Now(),
  72         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
  73     manager_->OnPacketSent(i, clock_.Now(), kDefaultMaxPacketSize,
  74                            NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
  75     QuicTime::Delta advance_time = manager_->TimeUntilSend(clock_.Now(),
  76         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
  77     clock_.AdvanceTime(advance_time);
  78     acc_advance_time = acc_advance_time.Add(advance_time);
  79     // Ack the packet we sent.
  80     ack.received_info.largest_observed = max(
  81         i, ack.received_info.largest_observed);
  82     manager_->OnIncomingAckFrame(ack, clock_.Now());
  83   }
  84   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(1200),
  85             acc_advance_time.Subtract(start_));
  86 }
  87
  88 TEST_F(QuicCongestionControlTest, Pacing) {
  89   SetUpCongestionType(kFixRate);
  90   QuicAckFrame ack;
  91   ack.received_info.largest_observed = 0;
  92   manager_->OnIncomingAckFrame(ack, clock_.Now());
  93
  94   QuicCongestionFeedbackFrame feedback;
  95   feedback.type = kFixRate;
  96   // Test a high bitrate (8Mbit/s) to trigger pacing.
  97   feedback.fix_rate.bitrate = QuicBandwidth::FromKBytesPerSecond(1000);
  98   manager_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
  99
 100   QuicTime acc_advance_time(QuicTime::Zero());
 101   for (QuicPacketSequenceNumber i = 1; i <= 100;) {
 102     EXPECT_TRUE(manager_->TimeUntilSend(clock_.Now(),
 103         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 104     manager_->OnPacketSent(i++, clock_.Now(), kDefaultMaxPacketSize,
 105                            NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
 106     EXPECT_TRUE(manager_->TimeUntilSend(clock_.Now(),
 107         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 108     manager_->OnPacketSent(i++, clock_.Now(), kDefaultMaxPacketSize,
 109                            NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
 110     QuicTime::Delta advance_time = manager_->TimeUntilSend(clock_.Now(),
 111         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
 112     clock_.AdvanceTime(advance_time);
 113     acc_advance_time = acc_advance_time.Add(advance_time);
 114     // Ack the packets we sent.
 115     ack.received_info.largest_observed = max(
 116         i - 2, ack.received_info.largest_observed);
 117     manager_->OnIncomingAckFrame(ack, clock_.Now());
 118     ack.received_info.largest_observed = max(
 119         i - 1, ack.received_info.largest_observed);
 120     manager_->OnIncomingAckFrame(ack, clock_.Now());
 121   }
 122   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(120),
 123             acc_advance_time.Subtract(start_));
 124 }
 125
 126 // TODO(pwestin): add TCP tests.
 127
 128 // TODO(pwestin): add InterArrival tests.
 129
 130 }  // namespace test
 131 }  // namespace net