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 for (int i = 0; i < 2; ++i) { 42 EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(), 43 kBytesInFlight, 44 HAS_RETRANSMITTABLE_DATA)) 45 .WillOnce(Return(zero_time_)); 46 // Verify that the packet can be sent immediately. 47 EXPECT_EQ(zero_time_, 48 pacing_sender_->TimeUntilSend(clock_.Now(), 49 kBytesInFlight, 50 HAS_RETRANSMITTABLE_DATA)); 51 } 52 53 // Actually send the packet. 54 EXPECT_CALL(*mock_sender_, 55 OnPacketSent(clock_.Now(), kBytesInFlight, sequence_number_, 56 kMaxPacketSize, HAS_RETRANSMITTABLE_DATA)); 57 pacing_sender_->OnPacketSent(clock_.Now(), kBytesInFlight, 58 sequence_number_++, kMaxPacketSize, 59 HAS_RETRANSMITTABLE_DATA); 60 } 61 62 void CheckAckIsSentImmediately() { 63 // In order for the ack to be sendable, the underlying sender must 64 // permit it to be sent immediately. 65 EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(), 66 0, 67 NO_RETRANSMITTABLE_DATA)) 68 .WillOnce(Return(zero_time_)); 69 // Verify that the ACK can be sent immediately. 70 EXPECT_EQ(zero_time_, 71 pacing_sender_->TimeUntilSend(clock_.Now(), 72 0, 73 NO_RETRANSMITTABLE_DATA)); 74 75 // Actually send the packet. 76 EXPECT_CALL(*mock_sender_, 77 OnPacketSent(clock_.Now(), 0, sequence_number_, 78 kMaxPacketSize, NO_RETRANSMITTABLE_DATA)); 79 pacing_sender_->OnPacketSent(clock_.Now(), 0, 80 sequence_number_++, kMaxPacketSize, 81 NO_RETRANSMITTABLE_DATA); 82 } 83 84 void CheckPacketIsDelayed(QuicTime::Delta delay) { 85 // In order for the packet to be sendable, the underlying sender must 86 // permit it to be sent immediately. 87 for (int i = 0; i < 2; ++i) { 88 EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(), 89 kBytesInFlight, 90 HAS_RETRANSMITTABLE_DATA)) 91 .WillOnce(Return(zero_time_)); 92 // Verify that the packet is delayed. 93 EXPECT_EQ(delay.ToMicroseconds(), 94 pacing_sender_->TimeUntilSend( 95 clock_.Now(), kBytesInFlight, 96 HAS_RETRANSMITTABLE_DATA).ToMicroseconds()); 97 } 98 } 99 100 const QuicTime::Delta zero_time_; 101 const QuicTime::Delta infinite_time_; 102 MockClock clock_; 103 QuicPacketSequenceNumber sequence_number_; 104 StrictMock<MockSendAlgorithm>* mock_sender_; 105 scoped_ptr<PacingSender> pacing_sender_; 106 }; 107 108 TEST_F(PacingSenderTest, NoSend) { 109 for (int i = 0; i < 2; ++i) { 110 EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(), 111 kBytesInFlight, 112 HAS_RETRANSMITTABLE_DATA)) 113 .WillOnce(Return(infinite_time_)); 114 EXPECT_EQ(infinite_time_, 115 pacing_sender_->TimeUntilSend(clock_.Now(), 116 kBytesInFlight, 117 HAS_RETRANSMITTABLE_DATA)); 118 } 119 } 120 121 TEST_F(PacingSenderTest, SendNow) { 122 for (int i = 0; i < 2; ++i) { 123 EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(), 124 kBytesInFlight, 125 HAS_RETRANSMITTABLE_DATA)) 126 .WillOnce(Return(zero_time_)); 127 EXPECT_EQ(zero_time_, 128 pacing_sender_->TimeUntilSend(clock_.Now(), 129 kBytesInFlight, 130 HAS_RETRANSMITTABLE_DATA)); 131 } 132 } 133 134 TEST_F(PacingSenderTest, VariousSending) { 135 // Configure bandwith of 1 packet per 2 ms, for which the pacing rate 136 // will be 1 packet per 1 ms. 137 EXPECT_CALL(*mock_sender_, BandwidthEstimate()) 138 .WillRepeatedly(Return(QuicBandwidth::FromBytesAndTimeDelta( 139 kMaxPacketSize, QuicTime::Delta::FromMilliseconds(2)))); 140 141 // Send a whole pile of packets, and verify that they are not paced. 142 for (int i = 0 ; i < 1000; ++i) { 143 CheckPacketIsSentImmediately(); 144 } 145 146 // Now update the RTT and verify that packets are actually paced. 147 EXPECT_CALL(*mock_sender_, OnCongestionEvent(true, kBytesInFlight, _, _)); 148 SendAlgorithmInterface::CongestionMap empty_map; 149 pacing_sender_->OnCongestionEvent(true, kBytesInFlight, empty_map, empty_map); 150 151 CheckPacketIsSentImmediately(); 152 CheckPacketIsSentImmediately(); 153 CheckPacketIsSentImmediately(); 154 155 // The first packet was a "make up", then we sent two packets "into the 156 // future", so the delay should be 2. 157 CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2)); 158 159 // Wake up on time. 160 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(2)); 161 CheckPacketIsSentImmediately(); 162 CheckPacketIsSentImmediately(); 163 CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2)); 164 CheckAckIsSentImmediately(); 165 166 // Wake up late. 167 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(4)); 168 CheckPacketIsSentImmediately(); 169 CheckPacketIsSentImmediately(); 170 CheckPacketIsSentImmediately(); 171 CheckPacketIsSentImmediately(); 172 CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2)); 173 174 // Wake up really late. 175 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(8)); 176 CheckPacketIsSentImmediately(); 177 CheckPacketIsSentImmediately(); 178 CheckPacketIsSentImmediately(); 179 CheckPacketIsSentImmediately(); 180 CheckPacketIsSentImmediately(); 181 CheckPacketIsSentImmediately(); 182 CheckPacketIsSentImmediately(); 183 CheckPacketIsSentImmediately(); 184 CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2)); 185 186 // Wake up really late again, but application pause partway through. 187 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(8)); 188 CheckPacketIsSentImmediately(); 189 CheckPacketIsSentImmediately(); 190 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(100)); 191 CheckPacketIsSentImmediately(); 192 CheckPacketIsSentImmediately(); 193 CheckPacketIsSentImmediately(); 194 CheckPacketIsSentImmediately(); 195 CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2)); 196 197 // Wake up too early. 198 CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2)); 199 200 // Wake up early, but after enough time has passed to permit a send. 201 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1)); 202 CheckPacketIsSentImmediately(); 203 CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2)); 204 } 205 206 } // namespace test 207 } // namespace net 208
