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