src/net/quic/congestion_control/pacing_sender_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 "net/quic/congestion_control/pacing_sender.h"
   6
   7 #include "base/logging.h"
   8 #include "base/memory/scoped_ptr.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/gtest/include/gtest/gtest.h"
  13
  14 using testing::Return;
  15 using testing::StrictMock;
  16 using testing::_;
  17
  18 namespace net {
  19 namespace test {
  20
  21 const QuicByteCount kBytesInFlight = 1024;
  22
  23 class PacingSenderTest : public ::testing::Test {
  24  protected:
  25   PacingSenderTest()
  26       : zero_time_(QuicTime::Delta::Zero()),
  27         infinite_time_(QuicTime::Delta::Infinite()),
  28         sequence_number_(1),
  29         mock_sender_(new StrictMock<MockSendAlgorithm>()),
  30         pacing_sender_(new PacingSender(mock_sender_,
  31                                         QuicTime::Delta::FromMilliseconds(1))) {
  32     // Pick arbitrary time.
  33     clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(9));
  34   }
  35
  36   virtual ~PacingSenderTest() {}
  37
  38   void CheckPacketIsSentImmediately() {
  39     // In order for the packet to be sendable, the underlying sender must
  40     // permit it to be sent immediately.
  41     EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(),
  42                                              kBytesInFlight,
  43                                              HAS_RETRANSMITTABLE_DATA))
  44         .WillOnce(Return(zero_time_));
  45     // Verify that the packet can be sent immediately.
  46     EXPECT_EQ(zero_time_,
  47               pacing_sender_->TimeUntilSend(clock_.Now(),
  48                                             kBytesInFlight,
  49                                             HAS_RETRANSMITTABLE_DATA));
  50
  51     // Actually send the packet.
  52     EXPECT_CALL(*mock_sender_,
  53                 OnPacketSent(clock_.Now(), kBytesInFlight, sequence_number_,
  54                              kMaxPacketSize, HAS_RETRANSMITTABLE_DATA));
  55     pacing_sender_->OnPacketSent(clock_.Now(), kBytesInFlight,
  56                                  sequence_number_++, kMaxPacketSize,
  57                                  HAS_RETRANSMITTABLE_DATA);
  58   }
  59
  60   void CheckAckIsSentImmediately() {
  61     // In order for the ack to be sendable, the underlying sender must
  62     // permit it to be sent immediately.
  63     EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(),
  64                                              0,
  65                                              NO_RETRANSMITTABLE_DATA))
  66         .WillOnce(Return(zero_time_));
  67     // Verify that the ACK can be sent immediately.
  68     EXPECT_EQ(zero_time_,
  69               pacing_sender_->TimeUntilSend(clock_.Now(),
  70                                             0,
  71                                             NO_RETRANSMITTABLE_DATA));
  72
  73     // Actually send the packet.
  74     EXPECT_CALL(*mock_sender_,
  75                 OnPacketSent(clock_.Now(), 0, sequence_number_,
  76                              kMaxPacketSize, NO_RETRANSMITTABLE_DATA));
  77     pacing_sender_->OnPacketSent(clock_.Now(), 0,
  78                                  sequence_number_++, kMaxPacketSize,
  79                                  NO_RETRANSMITTABLE_DATA);
  80   }
  81
  82   void CheckPacketIsDelayed(QuicTime::Delta delay) {
  83     // In order for the packet to be sendable, the underlying sender must
  84     // permit it to be sent immediately.
  85     EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(),
  86                                              kBytesInFlight,
  87                                              HAS_RETRANSMITTABLE_DATA))
  88         .WillOnce(Return(zero_time_));
  89     // Verify that the packet is delayed.
  90     EXPECT_EQ(delay.ToMicroseconds(),
  91               pacing_sender_->TimeUntilSend(
  92                   clock_.Now(), kBytesInFlight,
  93                   HAS_RETRANSMITTABLE_DATA).ToMicroseconds());
  94   }
  95
  96   const QuicTime::Delta zero_time_;
  97   const QuicTime::Delta infinite_time_;
  98   MockClock clock_;
  99   QuicPacketSequenceNumber sequence_number_;
 100   StrictMock<MockSendAlgorithm>* mock_sender_;
 101   scoped_ptr<PacingSender> pacing_sender_;
 102 };
 103
 104 TEST_F(PacingSenderTest, NoSend) {
 105   EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(),
 106                                            kBytesInFlight,
 107                                            HAS_RETRANSMITTABLE_DATA))
 108       .WillOnce(Return(infinite_time_));
 109   EXPECT_EQ(infinite_time_,
 110             pacing_sender_->TimeUntilSend(clock_.Now(),
 111                                           kBytesInFlight,
 112                                           HAS_RETRANSMITTABLE_DATA));
 113 }
 114
 115 TEST_F(PacingSenderTest, SendNow) {
 116   EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(),
 117                                            kBytesInFlight,
 118                                            HAS_RETRANSMITTABLE_DATA))
 119       .WillOnce(Return(zero_time_));
 120   EXPECT_EQ(zero_time_,
 121             pacing_sender_->TimeUntilSend(clock_.Now(),
 122                                           kBytesInFlight,
 123                                           HAS_RETRANSMITTABLE_DATA));
 124 }
 125
 126 TEST_F(PacingSenderTest, VariousSending) {
 127   // Configure bandwith of 1 packet per 2 ms, for which the pacing rate
 128   // will be 1 packet per 1 ms.
 129   EXPECT_CALL(*mock_sender_, BandwidthEstimate())
 130       .WillRepeatedly(Return(QuicBandwidth::FromBytesAndTimeDelta(
 131           kMaxPacketSize, QuicTime::Delta::FromMilliseconds(2))));
 132
 133   // Send a whole pile of packets, and verify that they are not paced.
 134   for (int i = 0 ; i < 1000; ++i) {
 135     CheckPacketIsSentImmediately();
 136   }
 137
 138   // Now update the RTT and verify that packets are actually paced.
 139   EXPECT_CALL(*mock_sender_, OnCongestionEvent(true, kBytesInFlight, _, _));
 140   SendAlgorithmInterface::CongestionMap empty_map;
 141   pacing_sender_->OnCongestionEvent(true, kBytesInFlight, empty_map, empty_map);
 142
 143   CheckPacketIsSentImmediately();
 144   CheckPacketIsSentImmediately();
 145   CheckPacketIsSentImmediately();
 146
 147   // The first packet was a "make up", then we sent two packets "into the
 148   // future", so the delay should be 2.
 149   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
 150
 151   // Wake up on time.
 152   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(2));
 153   CheckPacketIsSentImmediately();
 154   CheckPacketIsSentImmediately();
 155   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
 156   CheckAckIsSentImmediately();
 157
 158   // Wake up late.
 159   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(4));
 160   CheckPacketIsSentImmediately();
 161   CheckPacketIsSentImmediately();
 162   CheckPacketIsSentImmediately();
 163   CheckPacketIsSentImmediately();
 164   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
 165
 166   // Wake up too early.
 167   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
 168
 169   // Wake up early, but after enough time has passed to permit a send.
 170   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
 171   CheckPacketIsSentImmediately();
 172   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
 173 }
 174
 175 }  // namespace test
 176 }  // namespace net