src/net/quic/congestion_control/channel_estimator_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 "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