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 "net/quic/congestion_control/channel_estimator.h" 7 #include "net/quic/test_tools/mock_clock.h" 8 #include "testing/gtest/include/gtest/gtest.h" 9 10 namespace net { 11 namespace test { 12 13 class ChannelEstimatorTest : public ::testing::Test { 14 protected: 15 virtual void SetUp() { 16 srand(1234); 17 packet_size_ = 1200; 18 sequence_number_ = 1; 19 } 20 21 QuicPacketSequenceNumber sequence_number_; 22 QuicByteCount packet_size_; 23 MockClock send_clock_; 24 MockClock receive_clock_; 25 ChannelEstimator channel_estimator_; 26 }; 27 28 TEST_F(ChannelEstimatorTest, SimpleNonDetect) { 29 // In this test, the send times differ by the same delta as the receive times, 30 // so we haven't sent packets closely enough to detect "spreading," or 31 // effective bandwidth. 32 QuicTime::Delta delta = QuicTime::Delta::FromMilliseconds(10); 33 34 for (int i = 0; i < 1000; ++i) { 35 QuicTime send_time = send_clock_.ApproximateNow(); 36 QuicTime receive_time = receive_clock_.ApproximateNow(); 37 channel_estimator_.OnAcknowledgedPacket(sequence_number_++, 38 packet_size_, 39 send_time, 40 receive_time); 41 send_clock_.AdvanceTime(delta); 42 receive_clock_.AdvanceTime(delta); 43 } 44 QuicBandwidth estimate = QuicBandwidth::Zero(); 45 EXPECT_EQ(kChannelEstimateUnknown, 46 channel_estimator_.GetChannelEstimate(&estimate)); 47 EXPECT_TRUE(estimate.IsZero()); 48 } 49 50 TEST_F(ChannelEstimatorTest, SimplePacketPairDetect) { 51 // In this test, we start by sending packet pairs back-to-back and 52 // add a receive side spreading that indicate an effective bandwidth. 53 // We do 2 testes with different effective bandwidth to make sure that we 54 // detect the new effective bandwidth. 55 QuicTime::Delta received_delta = QuicTime::Delta::FromMilliseconds(5); 56 QuicTime::Delta send_delta = QuicTime::Delta::FromMilliseconds(10); 57 58 for (int i = 0; i < 100; ++i) { 59 receive_clock_.AdvanceTime(received_delta); 60 QuicTime receive_time = receive_clock_.ApproximateNow(); 61 QuicTime send_time = send_clock_.ApproximateNow(); 62 63 channel_estimator_.OnAcknowledgedPacket(sequence_number_++, 64 packet_size_, 65 send_time, 66 receive_time); 67 receive_clock_.AdvanceTime(received_delta); 68 receive_time = receive_clock_.ApproximateNow(); 69 channel_estimator_.OnAcknowledgedPacket(sequence_number_++, 70 packet_size_, 71 send_time, 72 receive_time); 73 send_clock_.AdvanceTime(send_delta); 74 } 75 QuicBandwidth estimate = QuicBandwidth::Zero(); 76 EXPECT_EQ(kChannelEstimateGood, 77 channel_estimator_.GetChannelEstimate(&estimate)); 78 EXPECT_EQ(QuicBandwidth::FromBytesAndTimeDelta(packet_size_, received_delta), 79 estimate); 80 received_delta = QuicTime::Delta::FromMilliseconds(1); 81 for (int i = 0; i < 100; ++i) { 82 receive_clock_.AdvanceTime(received_delta); 83 QuicTime receive_time = receive_clock_.ApproximateNow(); 84 QuicTime send_time = send_clock_.ApproximateNow(); 85 channel_estimator_.OnAcknowledgedPacket(sequence_number_++, 86 packet_size_, 87 send_time, 88 receive_time); 89 receive_clock_.AdvanceTime(received_delta); 90 receive_time = receive_clock_.ApproximateNow(); 91 channel_estimator_.OnAcknowledgedPacket(sequence_number_++, 92 packet_size_, 93 send_time, 94 receive_time); 95 send_clock_.AdvanceTime(send_delta); 96 } 97 EXPECT_EQ(kChannelEstimateGood, 98 channel_estimator_.GetChannelEstimate(&estimate)); 99 EXPECT_EQ(QuicBandwidth::FromBytesAndTimeDelta(packet_size_, received_delta), 100 estimate); 101 } 102 103 TEST_F(ChannelEstimatorTest, SimpleFlatSlope) { 104 // In this test, we send packet pairs back-to-back and add a slowly increasing 105 // receive side spreading. We expect the estimate to be good and that our 106 // mean receive side spreading is returned as the estimate. 107 QuicTime::Delta initial_received_delta = QuicTime::Delta::FromMilliseconds(5); 108 QuicTime::Delta received_delta = initial_received_delta; 109 QuicTime::Delta send_delta = QuicTime::Delta::FromMilliseconds(10); 110 111 for (int i = 0; i < 100; ++i) { 112 receive_clock_.AdvanceTime(received_delta); 113 QuicTime receive_time = receive_clock_.ApproximateNow(); 114 QuicTime send_time = send_clock_.ApproximateNow(); 115 channel_estimator_.OnAcknowledgedPacket(sequence_number_++, 116 packet_size_, 117 send_time, 118 receive_time); 119 receive_clock_.AdvanceTime(received_delta); 120 receive_time = receive_clock_.ApproximateNow(); 121 channel_estimator_.OnAcknowledgedPacket(sequence_number_++, 122 packet_size_, 123 send_time, 124 receive_time); 125 send_clock_.AdvanceTime(send_delta); 126 received_delta = received_delta.Add(QuicTime::Delta::FromMicroseconds(10)); 127 } 128 QuicBandwidth estimate = QuicBandwidth::Zero(); 129 EXPECT_EQ(kChannelEstimateGood, 130 channel_estimator_.GetChannelEstimate(&estimate)); 131 132 // Calculate our mean receive delta. 133 QuicTime::Delta increased_received_delta = 134 received_delta.Subtract(initial_received_delta); 135 QuicTime::Delta mean_received_delta = initial_received_delta.Add( 136 QuicTime::Delta::FromMicroseconds( 137 increased_received_delta.ToMicroseconds() / 2)); 138 139 EXPECT_EQ(QuicBandwidth::FromBytesAndTimeDelta(packet_size_, 140 mean_received_delta), estimate); 141 } 142 143 TEST_F(ChannelEstimatorTest, SimpleMediumSlope) { 144 // In this test, we send packet pairs back-to-back and add an increasing 145 // receive side spreading. We expect the estimate to be uncertaint and that 146 // our mean receive side spreading is returned as the estimate. 147 QuicTime::Delta initial_received_delta = QuicTime::Delta::FromMilliseconds(5); 148 QuicTime::Delta received_delta = initial_received_delta; 149 QuicTime::Delta send_delta = QuicTime::Delta::FromMilliseconds(10); 150 151 for (int i = 0; i < 100; ++i) { 152 receive_clock_.AdvanceTime(received_delta); 153 QuicTime receive_time = receive_clock_.ApproximateNow(); 154 QuicTime send_time = send_clock_.ApproximateNow(); 155 channel_estimator_.OnAcknowledgedPacket(sequence_number_++, 156 packet_size_, 157 send_time, 158 receive_time); 159 receive_clock_.AdvanceTime(received_delta); 160 receive_time = receive_clock_.ApproximateNow(); 161 channel_estimator_.OnAcknowledgedPacket(sequence_number_++, 162 packet_size_, 163 send_time, 164 receive_time); 165 send_clock_.AdvanceTime(send_delta); 166 received_delta = received_delta.Add(QuicTime::Delta::FromMicroseconds(50)); 167 } 168 QuicBandwidth estimate = QuicBandwidth::Zero(); 169 EXPECT_EQ(kChannelEstimateUncertain, 170 channel_estimator_.GetChannelEstimate(&estimate)); 171 172 // Calculate our mean receive delta. 173 QuicTime::Delta increased_received_delta = 174 received_delta.Subtract(initial_received_delta); 175 QuicTime::Delta mean_received_delta = initial_received_delta.Add( 176 QuicTime::Delta::FromMicroseconds( 177 increased_received_delta.ToMicroseconds() / 2)); 178 179 EXPECT_EQ(QuicBandwidth::FromBytesAndTimeDelta(packet_size_, 180 mean_received_delta), estimate); 181 } 182 183 TEST_F(ChannelEstimatorTest, SimpleSteepSlope) { 184 // In this test, we send packet pairs back-to-back and add a rapidly 185 // increasing receive side spreading. We expect the estimate to be uncertain 186 // and that our mean receive side spreading is returned as the estimate. 187 QuicTime::Delta initial_received_delta = QuicTime::Delta::FromMilliseconds(5); 188 QuicTime::Delta received_delta = initial_received_delta; 189 QuicTime::Delta send_delta = QuicTime::Delta::FromMilliseconds(10); 190 191 for (int i = 0; i < 100; ++i) { 192 receive_clock_.AdvanceTime(received_delta); 193 QuicTime receive_time = receive_clock_.ApproximateNow(); 194 QuicTime send_time = send_clock_.ApproximateNow(); 195 channel_estimator_.OnAcknowledgedPacket(sequence_number_++, 196 packet_size_, 197 send_time, 198 receive_time); 199 receive_clock_.AdvanceTime(received_delta); 200 receive_time = receive_clock_.ApproximateNow(); 201 channel_estimator_.OnAcknowledgedPacket(sequence_number_++, 202 packet_size_, 203 send_time, 204 receive_time); 205 send_clock_.AdvanceTime(send_delta); 206 received_delta = received_delta.Add(QuicTime::Delta::FromMicroseconds(100)); 207 } 208 QuicBandwidth estimate = QuicBandwidth::Zero(); 209 EXPECT_EQ(kChannelEstimateUncertain, 210 channel_estimator_.GetChannelEstimate(&estimate)); 211 212 // Calculate our mean receive delta. 213 QuicTime::Delta increased_received_delta = 214 received_delta.Subtract(initial_received_delta); 215 QuicTime::Delta mean_received_delta = initial_received_delta.Add( 216 QuicTime::Delta::FromMicroseconds( 217 increased_received_delta.ToMicroseconds() / 2)); 218 219 EXPECT_EQ(QuicBandwidth::FromBytesAndTimeDelta(packet_size_, 220 mean_received_delta), estimate); 221 } 222 223 } // namespace test 224 } // namespace net 225
