src/net/quic/congestion_control/inter_arrival_overuse_detector_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 <stdlib.h>
   6
   7 #include <cmath>
   8
   9 #include "base/logging.h"
  10 #include "base/rand_util.h"
  11 #include "net/quic/congestion_control/inter_arrival_overuse_detector.h"
  12 #include "net/quic/test_tools/mock_clock.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 static const double kPi = 3.14159265;
  16
  17 namespace net {
  18 namespace test {
  19
  20 class InterArrivalOveruseDetectorTest : public ::testing::Test {
  21  protected:
  22   InterArrivalOveruseDetectorTest();
  23
  24   QuicTime::Delta GaussianRandom(QuicTime::Delta mean,
  25                                  QuicTime::Delta standard_deviation);
  26
  27   int Run100000Samples(int packets_per_burst,
  28                        QuicTime::Delta mean,
  29                        QuicTime::Delta standard_deviation);
  30
  31   int RunUntilOveruse(int packets_per_burst,
  32                       QuicTime::Delta mean,
  33                       QuicTime::Delta standard_deviation,
  34                       QuicTime::Delta drift_per_burst,
  35                       QuicTime::Delta *estimated_buffer_delay);
  36
  37   int RunUntilSteady(int packets_per_burst,
  38                      QuicTime::Delta mean,
  39                      QuicTime::Delta standard_deviation,
  40                      QuicTime::Delta drift_per_burst);
  41
  42   int RunUntilNotDraining(int packets_per_burst,
  43                           QuicTime::Delta mean,
  44                           QuicTime::Delta standard_deviation,
  45                           QuicTime::Delta drift_per_burst);
  46
  47   int RunUntilUnderusing(int packets_per_burst,
  48                          QuicTime::Delta mean,
  49                          QuicTime::Delta standard_deviation,
  50                          QuicTime::Delta drift_per_burst);
  51
  52   void RunXBursts(int bursts,
  53                   int packets_per_burst,
  54                   QuicTime::Delta mean,
  55                   QuicTime::Delta standard_deviation,
  56                   QuicTime::Delta drift_per_burst);
  57
  58   QuicPacketSequenceNumber sequence_number_;
  59   MockClock send_clock_;
  60   MockClock receive_clock_;
  61   QuicTime::Delta drift_from_mean_;
  62   InterArrivalOveruseDetector overuse_detector_;
  63   unsigned int seed_;
  64 };
  65
  66 InterArrivalOveruseDetectorTest::InterArrivalOveruseDetectorTest()
  67     : sequence_number_(1),
  68       drift_from_mean_(QuicTime::Delta::Zero()),
  69       seed_(1234) {
  70 }
  71
  72 QuicTime::Delta InterArrivalOveruseDetectorTest::GaussianRandom(
  73     QuicTime::Delta mean,
  74     QuicTime::Delta standard_deviation) {
  75   // Creating a Normal distribution variable from two independent uniform
  76   // variables based on the Box-Muller transform.
  77   double uniform1 = base::RandDouble();
  78   double uniform2 = base::RandDouble();
  79
  80   QuicTime::Delta random = QuicTime::Delta::FromMicroseconds(
  81       static_cast<int>(standard_deviation.ToMicroseconds() *
  82           sqrt(-2 * log(uniform1)) * cos(2 * kPi * uniform2))).
  83               Add(mean).Subtract(drift_from_mean_);
  84   if (random < QuicTime::Delta::Zero()) {
  85     // Don't do negative deltas.
  86     drift_from_mean_ = drift_from_mean_.Subtract(mean);
  87     return QuicTime::Delta::Zero();
  88   }
  89   drift_from_mean_ = drift_from_mean_.Add(random).Subtract(mean);
  90   return random;
  91 }
  92
  93 int InterArrivalOveruseDetectorTest::Run100000Samples(
  94     int packets_per_burst,
  95     QuicTime::Delta mean,
  96     QuicTime::Delta standard_deviation) {
  97   int unique_overuse = 0;
  98   int last_overuse = -1;
  99   for (int i = 0; i < 100000; ++i) {
 100     // Assume that we send out the packets with perfect pacing.
 101     send_clock_.AdvanceTime(mean);
 102     QuicTime send_time = send_clock_.ApproximateNow();
 103     // Do only one random delta for all packets in a burst.
 104     receive_clock_.AdvanceTime(GaussianRandom(mean, standard_deviation));
 105     QuicTime receive_time = receive_clock_.ApproximateNow();
 106     for (int j = 0; j <= packets_per_burst; ++j) {
 107       overuse_detector_.OnAcknowledgedPacket(sequence_number_++,
 108                                              send_time,
 109                                              (j == packets_per_burst),
 110                                              receive_time);
 111     }
 112     // We expect to randomly hit a few false detects, count the unique
 113     // overuse events, hence not multiple signals in a row.
 114     QuicTime::Delta estimated_buffer_delay(QuicTime::Delta::Zero());
 115     if (kBandwidthOverUsing == overuse_detector_.GetState(
 116         &estimated_buffer_delay)) {
 117       if (last_overuse + 1 != i) {
 118         unique_overuse++;
 119       }
 120       last_overuse = i;
 121     }
 122   }
 123   return unique_overuse;
 124 }
 125
 126 int InterArrivalOveruseDetectorTest::RunUntilOveruse(
 127     int packets_per_burst,
 128     QuicTime::Delta mean,
 129     QuicTime::Delta standard_deviation,
 130     QuicTime::Delta drift_per_burst,
 131     QuicTime::Delta *estimated_buffer_delay) {
 132   // Simulate a higher send pace, that is too high.
 133   for (int i = 0; i < 1000; ++i) {
 134     send_clock_.AdvanceTime(mean);
 135     QuicTime send_time = send_clock_.ApproximateNow();
 136     // Do only one random delta for all packets in a burst.
 137     receive_clock_.AdvanceTime(GaussianRandom(mean.Add(drift_per_burst),
 138                                               standard_deviation));
 139     QuicTime receive_time = receive_clock_.ApproximateNow();
 140     for (int j = 0; j <= packets_per_burst; ++j) {
 141       overuse_detector_.OnAcknowledgedPacket(sequence_number_++,
 142                                              send_time,
 143                                              (j == packets_per_burst),
 144                                              receive_time);
 145     }
 146     if (kBandwidthOverUsing == overuse_detector_.GetState(
 147         estimated_buffer_delay)) {
 148       return i + 1;
 149     }
 150   }
 151   return -1;
 152 }
 153
 154 int InterArrivalOveruseDetectorTest::RunUntilSteady(
 155     int packets_per_burst,
 156     QuicTime::Delta mean,
 157     QuicTime::Delta standard_deviation,
 158     QuicTime::Delta drift_per_burst) {
 159   // Simulate a lower send pace, that is lower than the capacity.
 160   for (int i = 0; i < 1000; ++i) {
 161     send_clock_.AdvanceTime(mean);
 162     QuicTime send_time = send_clock_.ApproximateNow();
 163     // Do only one random delta for all packets in a burst.
 164     receive_clock_.AdvanceTime(GaussianRandom(mean.Subtract(drift_per_burst),
 165                                               standard_deviation));
 166     QuicTime receive_time = receive_clock_.ApproximateNow();
 167     for (int j = 0; j <= packets_per_burst; ++j) {
 168       overuse_detector_.OnAcknowledgedPacket(sequence_number_++,
 169                                              send_time,
 170                                              (j == packets_per_burst),
 171                                              receive_time);
 172     }
 173     QuicTime::Delta estimated_buffer_delay(QuicTime::Delta::Zero());
 174     if (kBandwidthSteady ==
 175         overuse_detector_.GetState(&estimated_buffer_delay)) {
 176       return i + 1;
 177     }
 178   }
 179   return -1;
 180 }
 181
 182 int InterArrivalOveruseDetectorTest::RunUntilNotDraining(
 183     int packets_per_burst,
 184     QuicTime::Delta mean,
 185     QuicTime::Delta standard_deviation,
 186     QuicTime::Delta drift_per_burst) {
 187   // Simulate a lower send pace, that is lower than the capacity.
 188   for (int i = 0; i < 1000; ++i) {
 189     send_clock_.AdvanceTime(mean);
 190     QuicTime send_time = send_clock_.ApproximateNow();
 191     // Do only one random delta for all packets in a burst.
 192     receive_clock_.AdvanceTime(GaussianRandom(mean.Subtract(drift_per_burst),
 193                                               standard_deviation));
 194     QuicTime receive_time = receive_clock_.ApproximateNow();
 195     for (int j = 0; j <= packets_per_burst; ++j) {
 196       overuse_detector_.OnAcknowledgedPacket(sequence_number_++,
 197                                              send_time,
 198                                              (j == packets_per_burst),
 199                                              receive_time);
 200     }
 201     QuicTime::Delta estimated_buffer_delay(QuicTime::Delta::Zero());
 202     if (kBandwidthDraining >
 203         overuse_detector_.GetState(&estimated_buffer_delay)) {
 204       return i + 1;
 205     }
 206   }
 207   return -1;
 208 }
 209
 210 int InterArrivalOveruseDetectorTest::RunUntilUnderusing(
 211     int packets_per_burst,
 212     QuicTime::Delta mean,
 213     QuicTime::Delta standard_deviation,
 214     QuicTime::Delta drift_per_burst) {
 215   // Simulate a lower send pace, that is lower than the capacity.
 216   for (int i = 0; i < 1000; ++i) {
 217     send_clock_.AdvanceTime(mean);
 218     QuicTime send_time = send_clock_.ApproximateNow();
 219     // Do only one random delta for all packets in a burst.
 220     receive_clock_.AdvanceTime(GaussianRandom(mean.Subtract(drift_per_burst),
 221                                               standard_deviation));
 222     QuicTime receive_time = receive_clock_.ApproximateNow();
 223     for (int j = 0; j <= packets_per_burst; ++j) {
 224       overuse_detector_.OnAcknowledgedPacket(sequence_number_++,
 225                                              send_time,
 226                                              (j == packets_per_burst),
 227                                              receive_time);
 228     }
 229     QuicTime::Delta estimated_buffer_delay(QuicTime::Delta::Zero());
 230     if (kBandwidthUnderUsing == overuse_detector_.GetState(
 231         &estimated_buffer_delay)) {
 232       return i + 1;
 233     }
 234   }
 235   return -1;
 236 }
 237
 238 void InterArrivalOveruseDetectorTest::RunXBursts(
 239     int bursts,
 240     int packets_per_burst,
 241     QuicTime::Delta mean,
 242     QuicTime::Delta standard_deviation,
 243     QuicTime::Delta drift_per_burst) {
 244   for (int i = 0; i < bursts; ++i) {
 245     send_clock_.AdvanceTime(mean);
 246     QuicTime send_time = send_clock_.ApproximateNow();
 247     // Do only one random delta for all packets in a burst.
 248     receive_clock_.AdvanceTime(GaussianRandom(mean.Add(drift_per_burst),
 249                                               standard_deviation));
 250     QuicTime receive_time = receive_clock_.ApproximateNow();
 251     for (int j = 0; j <= packets_per_burst; ++j) {
 252       overuse_detector_.OnAcknowledgedPacket(sequence_number_++,
 253                                              send_time,
 254                                              (j == packets_per_burst),
 255                                              receive_time);
 256     }
 257   }
 258 }
 259
 260 // TODO(pwestin): test packet loss impact on accuracy.
 261 // TODO(pwestin): test colored noise by dropping late frames.
 262
 263 TEST_F(InterArrivalOveruseDetectorTest, DISABLED_TestNoise) {
 264   int count[100];
 265   memset(count, 0, sizeof(count));
 266   for (int i = 0; i < 10000; ++i) {
 267     QuicTime::Delta mean = QuicTime::Delta::FromMilliseconds(30);
 268     QuicTime::Delta standard_deviation = QuicTime::Delta::FromMilliseconds(10);
 269     count[GaussianRandom(mean, standard_deviation).ToMilliseconds()]++;
 270   }
 271   for (int j = 0; j < 100; ++j) {
 272     DLOG(INFO) << j << ":" << count[j];
 273   }
 274 }
 275
 276 TEST_F(InterArrivalOveruseDetectorTest, DISABLED_SimpleNonOveruse) {
 277   QuicPacketSequenceNumber sequence_number = 1;
 278   QuicTime::Delta delta = QuicTime::Delta::FromMilliseconds(10);
 279
 280   for (int i = 0; i < 1000; ++i) {
 281     QuicTime send_time = send_clock_.ApproximateNow();
 282     QuicTime receive_time = receive_clock_.ApproximateNow();
 283     overuse_detector_.OnAcknowledgedPacket(sequence_number++,
 284                                            send_time,
 285                                            true,
 286                                            receive_time);
 287     send_clock_.AdvanceTime(delta);
 288     receive_clock_.AdvanceTime(delta);
 289     QuicTime::Delta estimated_buffer_delay(QuicTime::Delta::Zero());
 290     EXPECT_EQ(kBandwidthSteady,
 291               overuse_detector_.GetState(&estimated_buffer_delay));
 292   }
 293 }
 294
 295 TEST_F(InterArrivalOveruseDetectorTest,
 296        DISABLED_SimpleNonOveruseSendClockAhead) {
 297   QuicPacketSequenceNumber sequence_number = 1;
 298   QuicTime::Delta delta = QuicTime::Delta::FromMilliseconds(10);
 299   send_clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1234));
 300
 301   for (int i = 0; i < 1000; ++i) {
 302     QuicTime send_time = send_clock_.ApproximateNow();
 303     QuicTime receive_time = receive_clock_.ApproximateNow();
 304     overuse_detector_.OnAcknowledgedPacket(sequence_number++,
 305                                            send_time,
 306                                            true,
 307                                            receive_time);
 308     send_clock_.AdvanceTime(delta);
 309     receive_clock_.AdvanceTime(delta);
 310     QuicTime::Delta estimated_buffer_delay(QuicTime::Delta::Zero());
 311     EXPECT_EQ(kBandwidthSteady,
 312               overuse_detector_.GetState(&estimated_buffer_delay));
 313   }
 314 }
 315
 316 TEST_F(InterArrivalOveruseDetectorTest,
 317        DISABLED_SimpleNonOveruseSendClockBehind) {
 318   QuicPacketSequenceNumber sequence_number = 1;
 319   QuicTime::Delta delta = QuicTime::Delta::FromMilliseconds(10);
 320   receive_clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1234));
 321
 322   for (int i = 0; i < 1000; ++i) {
 323     QuicTime send_time = send_clock_.ApproximateNow();
 324     QuicTime receive_time = receive_clock_.ApproximateNow();
 325     overuse_detector_.OnAcknowledgedPacket(sequence_number++,
 326                                            send_time,
 327                                            true,
 328                                            receive_time);
 329     send_clock_.AdvanceTime(delta);
 330     receive_clock_.AdvanceTime(delta);
 331     QuicTime::Delta estimated_buffer_delay(QuicTime::Delta::Zero());
 332     EXPECT_EQ(kBandwidthSteady,
 333               overuse_detector_.GetState(&estimated_buffer_delay));
 334   }
 335 }
 336
 337 TEST_F(InterArrivalOveruseDetectorTest, DISABLED_SimpleNonOveruseWithVariance) {
 338   QuicPacketSequenceNumber sequence_number = 1;
 339   for (int i = 0; i < 1000; ++i) {
 340     if (i % 2) {
 341       receive_clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
 342     } else {
 343       receive_clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(15));
 344     }
 345     QuicTime send_time = send_clock_.ApproximateNow();
 346     QuicTime receive_time = receive_clock_.ApproximateNow();
 347     overuse_detector_.OnAcknowledgedPacket(sequence_number++,
 348                                            send_time,
 349                                            true,
 350                                            receive_time);
 351     send_clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
 352     QuicTime::Delta estimated_buffer_delay(QuicTime::Delta::Zero());
 353     EXPECT_EQ(kBandwidthSteady,
 354               overuse_detector_.GetState(&estimated_buffer_delay));
 355   }
 356 }
 357
 358 TEST_F(InterArrivalOveruseDetectorTest, DISABLED_SimpleOveruse) {
 359   QuicPacketSequenceNumber sequence_number = 1;
 360   QuicTime::Delta send_delta = QuicTime::Delta::FromMilliseconds(10);
 361   QuicTime::Delta received_delta = QuicTime::Delta::FromMilliseconds(5);
 362   QuicTime::Delta estimated_buffer_delay(QuicTime::Delta::Zero());
 363
 364   for (int i = 0; i < 100000; ++i) {
 365     send_clock_.AdvanceTime(send_delta);
 366     receive_clock_.AdvanceTime(received_delta);
 367     QuicTime send_time = send_clock_.ApproximateNow();
 368     QuicTime receive_time = receive_clock_.ApproximateNow();
 369     // Sending 2 packets the same time as that is what we expect to do.
 370     overuse_detector_.OnAcknowledgedPacket(sequence_number++,
 371                                            send_time,
 372                                            false,
 373                                            receive_time);
 374     receive_clock_.AdvanceTime(received_delta);
 375     receive_time = receive_clock_.ApproximateNow();
 376     overuse_detector_.OnAcknowledgedPacket(sequence_number++,
 377                                            send_time,
 378                                            true,
 379                                            receive_time);
 380
 381     EXPECT_EQ(kBandwidthSteady,
 382               overuse_detector_.GetState(&estimated_buffer_delay));
 383   }
 384   // Simulate a higher send pace, that is too high by receiving 1 millisecond
 385   // late per packet.
 386   received_delta = QuicTime::Delta::FromMilliseconds(6);
 387   send_clock_.AdvanceTime(send_delta);
 388   receive_clock_.AdvanceTime(received_delta);
 389   QuicTime send_time = send_clock_.ApproximateNow();
 390   QuicTime receive_time = receive_clock_.ApproximateNow();
 391   overuse_detector_.OnAcknowledgedPacket(sequence_number++,
 392                                          send_time,
 393                                          false,
 394                                          receive_time);
 395   receive_clock_.AdvanceTime(received_delta);
 396   receive_time = receive_clock_.ApproximateNow();
 397   overuse_detector_.OnAcknowledgedPacket(sequence_number++,
 398                                          send_time,
 399                                          true,
 400                                          receive_time);
 401   EXPECT_EQ(kBandwidthOverUsing,
 402             overuse_detector_.GetState(&estimated_buffer_delay));
 403 }
 404
 405 TEST_F(InterArrivalOveruseDetectorTest, DISABLED_LowVariance10Kbit) {
 406   int packets_per_burst = 1;
 407   QuicTime::Delta mean = QuicTime::Delta::FromMilliseconds(1000);
 408   QuicTime::Delta standard_deviation = QuicTime::Delta::FromMilliseconds(5);
 409   QuicTime::Delta drift_per_burst = QuicTime::Delta::FromMilliseconds(5);
 410
 411   int overuse_signals = Run100000Samples(packets_per_burst,
 412                                          mean,
 413                                          standard_deviation);
 414   EXPECT_GE(1, overuse_signals);
 415
 416   // Simulate a higher send pace, that is too high.
 417   // With current tuning we require 6 updates with 5 milliseconds before
 418   // detection.
 419   // Resulting in a minimal buffer build up of 30 milliseconds.
 420   QuicTime::Delta estimated_buffer_delay(QuicTime::Delta::Zero());
 421   int bursts_until_overuse = RunUntilOveruse(packets_per_burst,
 422                                              mean,
 423                                              standard_deviation,
 424                                              drift_per_burst,
 425                                              &estimated_buffer_delay);
 426   EXPECT_GE(6, bursts_until_overuse);
 427   EXPECT_NEAR(40, estimated_buffer_delay.ToMilliseconds(), 15);
 428
 429   // After draining the buffers we are back in a normal state.
 430   int bursts_until_not_draining = RunUntilNotDraining(packets_per_burst,
 431                                                       mean,
 432                                                       standard_deviation,
 433                                                       drift_per_burst);
 434   EXPECT_GE(6, bursts_until_not_draining);
 435
 436   // After draining the buffer additionally we detect an underuse.
 437   int bursts_until_underusing = RunUntilUnderusing(packets_per_burst,
 438                                                    mean,
 439                                                    standard_deviation,
 440                                                    drift_per_burst);
 441   EXPECT_GE(7, bursts_until_underusing);
 442 }
 443
 444 TEST_F(InterArrivalOveruseDetectorTest, DISABLED_HighVariance10Kbit) {
 445   int packets_per_burst = 1;
 446   QuicTime::Delta mean = QuicTime::Delta::FromMilliseconds(1000);
 447   QuicTime::Delta standard_deviation = QuicTime::Delta::FromMilliseconds(50);
 448   QuicTime::Delta drift_per_burst = QuicTime::Delta::FromMilliseconds(50);
 449
 450   int overuse_signals = Run100000Samples(packets_per_burst,
 451                                          mean,
 452                                          standard_deviation);
 453   EXPECT_GE(1, overuse_signals);
 454
 455   // Simulate a higher send pace, that is too high.
 456   // With current tuning we require 6 updates with 50 milliseconds before
 457   // detection.
 458   // Resulting in a minimal buffer build up of 300 milliseconds.
 459   QuicTime::Delta estimated_buffer_delay(QuicTime::Delta::Zero());
 460   int bursts_until_overuse = RunUntilOveruse(packets_per_burst,
 461                                              mean,
 462                                              standard_deviation,
 463                                              drift_per_burst,
 464                                              &estimated_buffer_delay);
 465   EXPECT_GE(6, bursts_until_overuse);
 466   EXPECT_NEAR(400, estimated_buffer_delay.ToMilliseconds(), 150);
 467
 468   // After draining the buffers we are back in a normal state.
 469   int bursts_until_not_draining = RunUntilNotDraining(packets_per_burst,
 470                                                       mean,
 471                                                       standard_deviation,
 472                                                       drift_per_burst);
 473   EXPECT_GE(6, bursts_until_not_draining);
 474
 475   // After draining the buffer additionally we detect an underuse.
 476   int bursts_until_underusing = RunUntilUnderusing(packets_per_burst,
 477                                                    mean,
 478                                                    standard_deviation,
 479                                                    drift_per_burst);
 480   EXPECT_GE(7, bursts_until_underusing);
 481 }
 482
 483 TEST_F(InterArrivalOveruseDetectorTest, DISABLED_LowVariance100Kbit) {
 484   int packets_per_burst = 1;
 485   QuicTime::Delta mean = QuicTime::Delta::FromMilliseconds(100);
 486   QuicTime::Delta standard_deviation = QuicTime::Delta::FromMilliseconds(5);
 487   QuicTime::Delta drift_per_burst = QuicTime::Delta::FromMilliseconds(5);
 488
 489   int overuse_signals = Run100000Samples(packets_per_burst,
 490                                          mean,
 491                                          standard_deviation);
 492   EXPECT_GE(1, overuse_signals);
 493
 494   // Simulate a higher send pace, that is too high.
 495   // With current tuning we require 6 updates with 5 milliseconds
 496   // before detection.
 497   // Resulting in a minimal buffer build up of 30 ms.
 498   QuicTime::Delta estimated_buffer_delay(QuicTime::Delta::Zero());
 499   int bursts_until_overuse = RunUntilOveruse(packets_per_burst,
 500                                              mean,
 501                                              standard_deviation,
 502                                              drift_per_burst,
 503                                              &estimated_buffer_delay);
 504   EXPECT_GE(6, bursts_until_overuse);
 505   EXPECT_NEAR(40, estimated_buffer_delay.ToMilliseconds(), 15);
 506
 507   // Simulate an RTT of 100 ms. Hence overusing for additional 100 ms before
 508   // detection.
 509   RunXBursts(1,
 510              packets_per_burst,
 511              mean,
 512              standard_deviation,
 513              drift_per_burst);
 514
 515   // After draining the buffers we are back in a normal state.
 516   int bursts_until_not_draining = RunUntilNotDraining(packets_per_burst,
 517                                                       mean,
 518                                                       standard_deviation,
 519                                                       drift_per_burst);
 520   EXPECT_GE(7, bursts_until_not_draining);
 521
 522   // After draining the buffer additionally we detect an underuse.
 523   int bursts_until_underusing = RunUntilUnderusing(packets_per_burst,
 524                                                    mean,
 525                                                    standard_deviation,
 526                                                    drift_per_burst);
 527   EXPECT_GE(5, bursts_until_underusing);
 528 }
 529
 530 TEST_F(InterArrivalOveruseDetectorTest, DISABLED_HighVariance100Kbit) {
 531   int packets_per_burst = 1;
 532   QuicTime::Delta mean = QuicTime::Delta::FromMilliseconds(100);
 533   QuicTime::Delta standard_deviation = QuicTime::Delta::FromMilliseconds(50);
 534   QuicTime::Delta drift_per_burst = QuicTime::Delta::FromMilliseconds(50);
 535
 536   int overuse_signals = Run100000Samples(packets_per_burst,
 537                                          mean,
 538                                          standard_deviation);
 539   EXPECT_GE(1, overuse_signals);
 540
 541   // Simulate a higher send pace, that is too high.
 542   // With current tuning we require 4 updates with 50 milliseconds
 543   // before detection.
 544   // Resulting in a minimal buffer build up of 200 ms.
 545   QuicTime::Delta estimated_buffer_delay(QuicTime::Delta::Zero());
 546   int bursts_until_overuse = RunUntilOveruse(packets_per_burst,
 547                                              mean,
 548                                              standard_deviation,
 549                                              drift_per_burst,
 550                                              &estimated_buffer_delay);
 551   EXPECT_GE(4, bursts_until_overuse);
 552   EXPECT_NEAR(300, estimated_buffer_delay.ToMilliseconds(), 150);
 553
 554   // Simulate an RTT of 100 ms. Hence overusing for additional 100 ms before
 555   // detection.
 556   RunXBursts(1,
 557              packets_per_burst,
 558              mean,
 559              standard_deviation,
 560              drift_per_burst);
 561
 562   // After draining the buffers we are back in a normal state.
 563   int bursts_until_not_draining = RunUntilNotDraining(packets_per_burst,
 564                                                       mean,
 565                                                       standard_deviation,
 566                                                       drift_per_burst);
 567   EXPECT_GE(5, bursts_until_not_draining);
 568
 569   // After draining the buffer additionally we detect an underuse.
 570   int bursts_until_underusing = RunUntilUnderusing(packets_per_burst,
 571                                                    mean,
 572                                                    standard_deviation,
 573                                                    drift_per_burst);
 574   EXPECT_GE(5, bursts_until_underusing);
 575 }
 576
 577 TEST_F(InterArrivalOveruseDetectorTest, DISABLED_HighVariance1Mbit) {
 578   int packets_per_burst = 1;
 579   QuicTime::Delta mean = QuicTime::Delta::FromMilliseconds(10);
 580   QuicTime::Delta standard_deviation = QuicTime::Delta::FromMilliseconds(5);
 581   QuicTime::Delta drift_per_burst = QuicTime::Delta::FromMilliseconds(5);
 582
 583   int overuse_signals = Run100000Samples(packets_per_burst,
 584                                          mean,
 585                                          standard_deviation);
 586   EXPECT_GE(1, overuse_signals);
 587
 588   // Simulate a higher send pace, that is too high.
 589   // With current tuning we require 4 updates with 5 millisecond
 590   // before detection.
 591   // Resulting in a minimal buffer build up of 20 ms.
 592   QuicTime::Delta estimated_buffer_delay(QuicTime::Delta::Zero());
 593   int bursts_until_overuse = RunUntilOveruse(packets_per_burst,
 594                                              mean,
 595                                              standard_deviation,
 596                                              drift_per_burst,
 597                                              &estimated_buffer_delay);
 598   EXPECT_GE(4, bursts_until_overuse);
 599   EXPECT_NEAR(30, estimated_buffer_delay.ToMilliseconds(), 15);
 600
 601   // Simulate an RTT of 100 ms. Hence overusing for additional 100 ms before
 602   // detection.
 603   RunXBursts(10,
 604              packets_per_burst,
 605              mean,
 606              standard_deviation,
 607              drift_per_burst);
 608
 609   // After draining the buffers we are back in a normal state.
 610   int bursts_until_not_draining = RunUntilNotDraining(packets_per_burst,
 611                                                       mean,
 612                                                       standard_deviation,
 613                                                       drift_per_burst);
 614   EXPECT_GE(14, bursts_until_not_draining);
 615
 616   // After draining the buffer additionally we detect an underuse.
 617   int bursts_until_underusing = RunUntilUnderusing(packets_per_burst,
 618                                                    mean,
 619                                                    standard_deviation,
 620                                                    drift_per_burst);
 621   EXPECT_GE(4, bursts_until_underusing);
 622 }
 623
 624 TEST_F(InterArrivalOveruseDetectorTest, DISABLED_LowVariance1Mbit) {
 625   int packets_per_burst = 1;
 626   QuicTime::Delta mean = QuicTime::Delta::FromMilliseconds(10);
 627   QuicTime::Delta standard_deviation = QuicTime::Delta::FromMilliseconds(1);
 628   QuicTime::Delta drift_per_burst = QuicTime::Delta::FromMilliseconds(1);
 629
 630   int overuse_signals = Run100000Samples(packets_per_burst,
 631                                          mean,
 632                                          standard_deviation);
 633   EXPECT_GE(1, overuse_signals);
 634
 635   // Simulate a higher send pace, that is too high.
 636   // With current tuning we require 6 updates with 1 millisecond
 637   // before detection.
 638   // Resulting in a minimal buffer build up of 6 ms.
 639   QuicTime::Delta estimated_buffer_delay(QuicTime::Delta::Zero());
 640   int bursts_until_overuse = RunUntilOveruse(packets_per_burst,
 641                                              mean,
 642                                              standard_deviation,
 643                                              drift_per_burst,
 644                                              &estimated_buffer_delay);
 645   EXPECT_GE(6, bursts_until_overuse);
 646   EXPECT_NEAR(8, estimated_buffer_delay.ToMilliseconds(), 3);
 647
 648   // Simulate an RTT of 100 ms. Hence overusing for additional 100 ms before
 649   // detection.
 650   RunXBursts(10,
 651              packets_per_burst,
 652              mean,
 653              standard_deviation,
 654              drift_per_burst);
 655
 656   // After draining the buffers we are back in a normal state.
 657   int bursts_until_not_draining = RunUntilNotDraining(packets_per_burst,
 658                                                       mean,
 659                                                       standard_deviation,
 660                                                       drift_per_burst);
 661   EXPECT_GE(16, bursts_until_not_draining);
 662
 663   // After draining the buffer additionally we detect an underuse.
 664   int bursts_until_underusing = RunUntilUnderusing(packets_per_burst,
 665                                                    mean,
 666                                                    standard_deviation,
 667                                                    drift_per_burst);
 668   EXPECT_GE(4, bursts_until_underusing);
 669 }
 670
 671 TEST_F(InterArrivalOveruseDetectorTest, DISABLED_HighVariance20Mbit) {
 672   int packets_per_burst = 2;
 673   QuicTime::Delta mean = QuicTime::Delta::FromMilliseconds(1);
 674   QuicTime::Delta standard_deviation = QuicTime::Delta::FromMicroseconds(500);
 675   QuicTime::Delta drift_per_burst = QuicTime::Delta::FromMicroseconds(500);
 676
 677   int overuse_signals = Run100000Samples(packets_per_burst,
 678                                          mean,
 679                                          standard_deviation);
 680   EXPECT_GE(1, overuse_signals);
 681
 682   // Simulate a higher send pace, that is too high.
 683   // With current tuning we require 4 updates with 500 microsecond
 684   // before detection.
 685   // Resulting in a minimal buffer build up of 2 ms.
 686   QuicTime::Delta estimated_buffer_delay(QuicTime::Delta::Zero());
 687   int bursts_until_overuse = RunUntilOveruse(packets_per_burst,
 688                                              mean,
 689                                              standard_deviation,
 690                                              drift_per_burst,
 691                                              &estimated_buffer_delay);
 692   EXPECT_GE(4, bursts_until_overuse);
 693   EXPECT_NEAR(3, estimated_buffer_delay.ToMilliseconds(), 2);
 694
 695   // Simulate an RTT of 100 ms. Hence overusing for additional 100 ms before
 696   // detection.
 697   RunXBursts(100,
 698              packets_per_burst,
 699              mean,
 700              standard_deviation,
 701              drift_per_burst);
 702
 703   // After draining the buffers we are back in a normal state.
 704   int bursts_until_not_draining = RunUntilNotDraining(packets_per_burst,
 705                                                       mean,
 706                                                       standard_deviation,
 707                                                       drift_per_burst);
 708   EXPECT_NEAR(100, bursts_until_not_draining, 10);
 709
 710   // After draining the buffer additionally we detect an underuse.
 711   int bursts_until_underusing = RunUntilUnderusing(packets_per_burst,
 712                                                    mean,
 713                                                    standard_deviation,
 714                                                    drift_per_burst);
 715   EXPECT_GE(1, bursts_until_underusing);
 716 }
 717
 718 TEST_F(InterArrivalOveruseDetectorTest, DISABLED_HighVariance100Mbit) {
 719   int packets_per_burst = 10;
 720   QuicTime::Delta mean = QuicTime::Delta::FromMilliseconds(1);
 721   QuicTime::Delta standard_deviation = QuicTime::Delta::FromMicroseconds(500);
 722   QuicTime::Delta drift_per_burst = QuicTime::Delta::FromMicroseconds(500);
 723
 724   int overuse_signals = Run100000Samples(packets_per_burst,
 725                                          mean,
 726                                          standard_deviation);
 727   EXPECT_GE(1, overuse_signals);
 728
 729   // Simulate a higher send pace, that is too high.
 730   // With current tuning we require 4 updates with 500 microsecond
 731   // before detection.
 732   // Resulting in a minimal buffer build up of 2 ms.
 733   QuicTime::Delta estimated_buffer_delay(QuicTime::Delta::Zero());
 734   int bursts_until_overuse = RunUntilOveruse(packets_per_burst,
 735                                              mean,
 736                                              standard_deviation,
 737                                              drift_per_burst,
 738                                              &estimated_buffer_delay);
 739   EXPECT_GE(4, bursts_until_overuse);
 740   EXPECT_NEAR(3, estimated_buffer_delay.ToMilliseconds(), 2);
 741
 742   // Simulate an RTT of 100 ms. Hence overusing for additional 100 ms before
 743   // detection.
 744   RunXBursts(100,
 745              packets_per_burst,
 746              mean,
 747              standard_deviation,
 748              drift_per_burst);
 749
 750   // After draining the buffers we are back in a normal state.
 751   int bursts_until_not_draining = RunUntilNotDraining(packets_per_burst,
 752                                                       mean,
 753                                                       standard_deviation,
 754                                                       drift_per_burst);
 755   EXPECT_NEAR(100, bursts_until_not_draining, 10);
 756
 757   // After draining the buffer additionally we detect an underuse.
 758   int bursts_until_underusing = RunUntilUnderusing(packets_per_burst,
 759                                                    mean,
 760                                                    standard_deviation,
 761                                                    drift_per_burst);
 762   EXPECT_GE(1, bursts_until_underusing);
 763 }
 764
 765 TEST_F(InterArrivalOveruseDetectorTest, DISABLED_VeryHighVariance100Mbit) {
 766   int packets_per_burst = 10;
 767   QuicTime::Delta mean = QuicTime::Delta::FromMilliseconds(1);
 768   QuicTime::Delta standard_deviation = QuicTime::Delta::FromMilliseconds(5);
 769   QuicTime::Delta drift_per_burst = QuicTime::Delta::FromMicroseconds(500);
 770
 771   // We get false overuse in this scenario due to that the standard deviation is
 772   // higher than our mean and the fact that a delta time can't be negative. This
 773   // results in an under estimated standard deviation in the estimator causing
 774   // false detects.
 775   int overuse_signals = Run100000Samples(packets_per_burst,
 776                                          mean,
 777                                          standard_deviation);
 778   EXPECT_GE(2000, overuse_signals);
 779
 780   // Simulate a higher send pace, that is too high.
 781   // With current tuning we require 25 updates with 500 microsecond
 782   // before detection.
 783   // Resulting in a minimal buffer build up of 12.5 ms.
 784   QuicTime::Delta estimated_buffer_delay(QuicTime::Delta::Zero());
 785   int bursts_until_overuse = RunUntilOveruse(packets_per_burst,
 786                                              mean,
 787                                              standard_deviation,
 788                                              drift_per_burst,
 789                                              &estimated_buffer_delay);
 790   EXPECT_GE(17, bursts_until_overuse);
 791   EXPECT_NEAR(22, estimated_buffer_delay.ToMilliseconds(), 15);
 792
 793   // Simulate an RTT of 100 ms. Hence overusing for additional 100 ms before
 794   // detection.
 795   RunXBursts(100,
 796              packets_per_burst,
 797              mean,
 798              standard_deviation,
 799              drift_per_burst);
 800
 801   // After draining the buffers we are back in a normal state.
 802   int bursts_until_not_draining = RunUntilNotDraining(packets_per_burst,
 803                                                       mean,
 804                                                       standard_deviation,
 805                                                       drift_per_burst);
 806   EXPECT_GE(117, bursts_until_not_draining);
 807
 808   // After draining the buffer additionally we detect an underuse.
 809   int bursts_until_underusing = RunUntilUnderusing(packets_per_burst,
 810                                                    mean,
 811                                                    standard_deviation,
 812                                                    drift_per_burst);
 813   EXPECT_GE(1, bursts_until_underusing);
 814 }
 815
 816 //
 817 //  Tests simulating big drop in bitrate.
 818 //
 819
 820 TEST_F(InterArrivalOveruseDetectorTest, DISABLED_LowVariance1MbitTo100Kbit) {
 821   int packets_per_burst = 1;
 822   QuicTime::Delta mean = QuicTime::Delta::FromMilliseconds(10);
 823   QuicTime::Delta standard_deviation = QuicTime::Delta::FromMilliseconds(1);
 824   QuicTime::Delta drift_per_burst = QuicTime::Delta::FromMilliseconds(100);
 825
 826   int overuse_signals = Run100000Samples(packets_per_burst,
 827                                          mean,
 828                                          standard_deviation);
 829   EXPECT_GE(1, overuse_signals);
 830
 831   // Simulate a higher send pace, that is too high.
 832   // With current tuning we require 1 update with 100 millisecond
 833   // before detection.
 834   // Resulting in a minimal buffer build up of 100 ms.
 835   QuicTime::Delta estimated_buffer_delay(QuicTime::Delta::Zero());
 836   int bursts_until_overuse = RunUntilOveruse(packets_per_burst,
 837                                              mean,
 838                                              standard_deviation,
 839                                              drift_per_burst,
 840                                              &estimated_buffer_delay);
 841   EXPECT_GE(1, bursts_until_overuse);
 842   EXPECT_NEAR(104, estimated_buffer_delay.ToMilliseconds(), 3);
 843
 844   // Back off 20% lower than estimate to drain.
 845   mean = QuicTime::Delta::FromMilliseconds(100);
 846   drift_per_burst = QuicTime::Delta::FromMilliseconds(20);
 847
 848   // After draining the buffers we are back in a normal state.
 849   int bursts_until_not_draining = RunUntilNotDraining(packets_per_burst,
 850                                                       mean,
 851                                                       standard_deviation,
 852                                                       drift_per_burst);
 853   EXPECT_GE(5, bursts_until_not_draining);
 854
 855   // After draining the buffer additionally we detect an underuse.
 856   int bursts_until_underusing = RunUntilUnderusing(packets_per_burst,
 857                                                    mean,
 858                                                    standard_deviation,
 859                                                    drift_per_burst);
 860   EXPECT_GE(3, bursts_until_underusing);
 861 }
 862
 863 TEST_F(InterArrivalOveruseDetectorTest, DISABLED_HighVariance20MbitTo1Mbit) {
 864   int packets_per_burst = 2;
 865   QuicTime::Delta mean = QuicTime::Delta::FromMilliseconds(1);
 866   QuicTime::Delta standard_deviation = QuicTime::Delta::FromMicroseconds(500);
 867   QuicTime::Delta drift_per_burst = QuicTime::Delta::FromMilliseconds(10);
 868
 869   int overuse_signals = Run100000Samples(packets_per_burst,
 870                                          mean,
 871                                          standard_deviation);
 872   EXPECT_GE(1, overuse_signals);
 873
 874   // Simulate a higher send pace, that is too high.
 875   // With current tuning we require 1 update with 10 milliseconds
 876   // before detection.
 877   // Resulting in a minimal buffer build up of 10 ms.
 878   QuicTime::Delta estimated_buffer_delay(QuicTime::Delta::Zero());
 879   int bursts_until_overuse = RunUntilOveruse(packets_per_burst,
 880                                              mean,
 881                                              standard_deviation,
 882                                              drift_per_burst,
 883                                              &estimated_buffer_delay);
 884   EXPECT_GE(1, bursts_until_overuse);
 885   EXPECT_NEAR(12, estimated_buffer_delay.ToMilliseconds(), 2);
 886
 887   // Back off 20% lower than estimate to drain.
 888   mean = QuicTime::Delta::FromMilliseconds(10);
 889   drift_per_burst = QuicTime::Delta::FromMilliseconds(2);
 890
 891   // After draining the buffers we are back in a normal state.
 892   int bursts_until_not_draining = RunUntilNotDraining(packets_per_burst,
 893                                                       mean,
 894                                                       standard_deviation,
 895                                                       drift_per_burst);
 896   EXPECT_GE(5, bursts_until_not_draining);
 897
 898   // After draining the buffer additionally we detect an underuse.
 899   int bursts_until_underusing = RunUntilUnderusing(packets_per_burst,
 900                                                    mean,
 901                                                    standard_deviation,
 902                                                    drift_per_burst);
 903   EXPECT_GE(3, bursts_until_underusing);
 904 }
 905
 906 //
 907 //  Tests that we can detect slow drifts.
 908 //
 909
 910 TEST_F(InterArrivalOveruseDetectorTest, DISABLED_LowVariance1MbitSmallSteps) {
 911   int packets_per_burst = 1;
 912   QuicTime::Delta mean = QuicTime::Delta::FromMilliseconds(10);
 913   QuicTime::Delta standard_deviation = QuicTime::Delta::FromMilliseconds(1);
 914   QuicTime::Delta drift_per_burst = QuicTime::Delta::FromMicroseconds(100);
 915
 916   int overuse_signals = Run100000Samples(packets_per_burst,
 917                                          mean,
 918                                          standard_deviation);
 919   EXPECT_GE(1, overuse_signals);
 920
 921   // Simulate a higher send pace, that is too high.
 922   // With current tuning we require 41 updates with 100 microseconds before
 923   // detection.
 924   // Resulting in a minimal buffer build up of 4.1 ms.
 925   QuicTime::Delta estimated_buffer_delay(QuicTime::Delta::Zero());
 926   int bursts_until_overuse = RunUntilOveruse(packets_per_burst,
 927                                              mean,
 928                                              standard_deviation,
 929                                              drift_per_burst,
 930                                              &estimated_buffer_delay);
 931   EXPECT_GE(41, bursts_until_overuse);
 932   EXPECT_NEAR(7, estimated_buffer_delay.ToMilliseconds(), 3);
 933
 934   // Simulate an RTT of 100 ms. Hence overusing for additional 100 ms before
 935   // detection.
 936   RunXBursts(10,
 937              packets_per_burst,
 938              mean,
 939              standard_deviation,
 940              drift_per_burst);
 941
 942   // After draining the buffers we are back in a normal state.
 943   int bursts_until_not_draining = RunUntilNotDraining(packets_per_burst,
 944                                                       mean,
 945                                                       standard_deviation,
 946                                                       drift_per_burst);
 947   EXPECT_GE(29, bursts_until_not_draining);
 948
 949   // After draining the buffer additionally we detect an underuse.
 950   int bursts_until_underusing = RunUntilUnderusing(packets_per_burst,
 951                                                    mean,
 952                                                    standard_deviation,
 953                                                    drift_per_burst);
 954   EXPECT_GE(71, bursts_until_underusing);
 955 }
 956
 957 TEST_F(InterArrivalOveruseDetectorTest, DISABLED_LowVariance1MbitTinySteps) {
 958   int packets_per_burst = 1;
 959   QuicTime::Delta mean = QuicTime::Delta::FromMilliseconds(10);
 960   QuicTime::Delta standard_deviation = QuicTime::Delta::FromMilliseconds(1);
 961   QuicTime::Delta drift_per_burst = QuicTime::Delta::FromMicroseconds(10);
 962
 963   int overuse_signals = Run100000Samples(packets_per_burst,
 964                                          mean,
 965                                          standard_deviation);
 966   EXPECT_GE(1, overuse_signals);
 967
 968   // Simulate a higher send pace, that is too high.
 969   // With current tuning we require 345 updates with 10 microseconds before
 970   // detection.
 971   // Resulting in a minimal buffer build up of 3.45 ms.
 972   QuicTime::Delta estimated_buffer_delay(QuicTime::Delta::Zero());
 973   int bursts_until_overuse = RunUntilOveruse(packets_per_burst,
 974                                              mean,
 975                                              standard_deviation,
 976                                              drift_per_burst,
 977                                              &estimated_buffer_delay);
 978   EXPECT_GE(345, bursts_until_overuse);
 979   EXPECT_NEAR(7, estimated_buffer_delay.ToMilliseconds(), 3);
 980
 981   // Simulate an RTT of 100 ms. Hence overusing for additional 100 ms before
 982   // detection.
 983   RunXBursts(10,
 984              packets_per_burst,
 985              mean,
 986              standard_deviation,
 987              drift_per_burst);
 988
 989   // After draining the buffers we are back in a normal state.
 990   int bursts_until_not_draining = RunUntilNotDraining(packets_per_burst,
 991                                                       mean,
 992                                                       standard_deviation,
 993                                                       drift_per_burst);
 994   EXPECT_GE(18, bursts_until_not_draining);
 995
 996   // After draining the buffer additionally we detect an underuse.
 997   int bursts_until_underusing = RunUntilUnderusing(packets_per_burst,
 998                                                    mean,
 999                                                    standard_deviation,
1000                                                    drift_per_burst);
1001   EXPECT_GE(683, bursts_until_underusing);
1002 }
1003
1004 //
1005 //  Tests simulating starting with full buffers.
1006 //
1007
1008 TEST_F(InterArrivalOveruseDetectorTest,
1009        DISABLED_StartedWithFullBuffersHighVariance1Mbit) {
1010   int packets_per_burst = 1;
1011   QuicTime::Delta mean = QuicTime::Delta::FromMilliseconds(10);
1012   QuicTime::Delta standard_deviation = QuicTime::Delta::FromMilliseconds(5);
1013   QuicTime::Delta drift_per_burst = QuicTime::Delta::FromMilliseconds(5);
1014
1015   int overuse_signals = Run100000Samples(packets_per_burst,
1016                                          mean,
1017                                          standard_deviation);
1018   EXPECT_GE(1, overuse_signals);
1019
1020   // Simulate a lower send pace.
1021   // Draining the buffer until we detect an underuse.
1022   int bursts_until_underusing = RunUntilUnderusing(packets_per_burst,
1023                                                    mean,
1024                                                    standard_deviation,
1025                                                    drift_per_burst);
1026   EXPECT_GE(6, bursts_until_underusing);
1027
1028   // After draining the buffers we are back in a normal state.
1029   drift_per_burst = QuicTime::Delta::FromMilliseconds(0);
1030   int bursts_until_steady = RunUntilSteady(packets_per_burst,
1031                                            mean,
1032                                            standard_deviation,
1033                                            drift_per_burst);
1034   EXPECT_GE(6, bursts_until_steady);
1035 }
1036
1037 TEST_F(InterArrivalOveruseDetectorTest,
1038        DISABLED_StartedWithFullBuffersHighVariance1MbitSlowDrift) {
1039   int packets_per_burst = 1;
1040   QuicTime::Delta mean = QuicTime::Delta::FromMilliseconds(10);
1041   QuicTime::Delta standard_deviation = QuicTime::Delta::FromMilliseconds(5);
1042   QuicTime::Delta drift_per_burst = QuicTime::Delta::FromMilliseconds(1);
1043
1044   int overuse_signals = Run100000Samples(packets_per_burst,
1045                                          mean,
1046                                          standard_deviation);
1047   EXPECT_GE(1, overuse_signals);
1048
1049   // Simulate a faster receive pace.
1050   // Draining the buffer until we detect an underuse.
1051   int bursts_until_underusing = RunUntilUnderusing(packets_per_burst,
1052                                                    mean,
1053                                                    standard_deviation,
1054                                                    drift_per_burst);
1055   EXPECT_GE(21, bursts_until_underusing);
1056
1057   // Simulate an RTT of 100 ms. Hence underusing for additional 100 ms before
1058   // detection.
1059   drift_per_burst = QuicTime::Delta::FromMilliseconds(-1);
1060   RunXBursts(10,
1061              packets_per_burst,
1062              mean,
1063              standard_deviation,
1064              drift_per_burst);
1065
1066   // After draining the buffers we are back in a normal state.
1067   drift_per_burst = QuicTime::Delta::FromMilliseconds(0);
1068   int bursts_until_steady = RunUntilSteady(packets_per_burst,
1069                                            mean,
1070                                            standard_deviation,
1071                                            drift_per_burst);
1072   EXPECT_GE(4, bursts_until_steady);
1073 }
1074
1075 TEST_F(InterArrivalOveruseDetectorTest,
1076        DISABLED_StartedWithFullBuffersLowVariance1Mbit) {
1077   int packets_per_burst = 1;
1078   QuicTime::Delta mean = QuicTime::Delta::FromMilliseconds(10);
1079   QuicTime::Delta standard_deviation = QuicTime::Delta::FromMilliseconds(1);
1080   QuicTime::Delta drift_per_burst = QuicTime::Delta::FromMilliseconds(1);
1081
1082   int overuse_signals = Run100000Samples(packets_per_burst,
1083                                          mean,
1084                                          standard_deviation);
1085   EXPECT_GE(1, overuse_signals);
1086
1087   // Simulate a lower send pace.
1088   // Draining the buffer until we detect an underuse.
1089   int bursts_until_underusing = RunUntilUnderusing(packets_per_burst,
1090                                                    mean,
1091                                                    standard_deviation,
1092                                                    drift_per_burst);
1093   EXPECT_GE(5, bursts_until_underusing);
1094
1095   // Simulate an RTT of 100 ms. Hence underusing for additional 100 ms before
1096   // detection.
1097   drift_per_burst = QuicTime::Delta::FromMilliseconds(-1);
1098   RunXBursts(10,
1099              packets_per_burst,
1100              mean,
1101              standard_deviation,
1102              drift_per_burst);
1103
1104   // After draining the buffers we are back in a normal state.
1105   drift_per_burst = QuicTime::Delta::FromMilliseconds(0);
1106   int bursts_until_steady = RunUntilSteady(packets_per_burst,
1107                                            mean,
1108                                            standard_deviation,
1109                                            drift_per_burst);
1110   EXPECT_GE(41, bursts_until_steady);
1111 }
1112
1113 }  // namespace test
1114 }  // namespace net