src/third_party/webrtc/modules/remote_bitrate_estimator/test/bwe_test_framework_unittest.cc

   1 /*
   2  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #include "webrtc/modules/remote_bitrate_estimator/test/bwe_test_framework.h"
  12
  13 #include <numeric>
  14
  15 #include "testing/gtest/include/gtest/gtest.h"
  16 #include "webrtc/base/constructormagic.h"
  17 #include "webrtc/test/testsupport/fileutils.h"
  18
  19 using std::vector;
  20
  21 namespace webrtc {
  22 namespace testing {
  23 namespace bwe {
  24
  25 TEST(BweTestFramework_RandomTest, Gaussian) {
  26   enum {
  27     kN = 100000,
  28     kBuckets = 100,
  29     kMean = 49,
  30     kStddev = 10
  31   };
  32
  33   Random random(0x12345678);
  34
  35   int buckets[kBuckets] = {0};
  36   for (int i = 0; i < kN; ++i) {
  37     int index = random.Gaussian(kMean, kStddev);
  38     if (index >= 0 && index < kBuckets) {
  39       buckets[index]++;
  40     }
  41   }
  42
  43   const double kPi = 3.14159265358979323846;
  44   const double kScale = kN / (kStddev * sqrt(2.0 * kPi));
  45   const double kDiv = -2.0 * kStddev * kStddev;
  46   double self_corr = 0.0;
  47   double bucket_corr = 0.0;
  48   for (int n = 0; n < kBuckets; ++n) {
  49     double normal_dist = kScale * exp((n - kMean) * (n - kMean) / kDiv);
  50     self_corr += normal_dist * normal_dist;
  51     bucket_corr += normal_dist * buckets[n];
  52   }
  53   printf("Correlation: %f (random sample), %f (self), %f (quotient)\n",
  54          bucket_corr, self_corr, bucket_corr / self_corr);
  55   EXPECT_NEAR(1.0, bucket_corr / self_corr, 0.0004);
  56 }
  57
  58 static bool IsSequenceNumberSorted(const Packets& packets) {
  59   PacketsConstIt last_it = packets.begin();
  60   for (PacketsConstIt it = last_it; it != packets.end(); ++it) {
  61     if (IsNewerSequenceNumber(last_it->header().sequenceNumber,
  62                               it->header().sequenceNumber)) {
  63       return false;
  64     }
  65     last_it = it;
  66   }
  67   return true;
  68 }
  69
  70 TEST(BweTestFramework_PacketTest, IsTimeSorted) {
  71   Packets packets;
  72   // Insert some packets in order...
  73   EXPECT_TRUE(IsTimeSorted(packets));
  74
  75   packets.push_back(Packet(100, 0));
  76   EXPECT_TRUE(IsTimeSorted(packets));
  77
  78   packets.push_back(Packet(110, 0));
  79   EXPECT_TRUE(IsTimeSorted(packets));
  80
  81   // ...and one out-of-order...
  82   packets.push_back(Packet(100, 0));
  83   EXPECT_FALSE(IsTimeSorted(packets));
  84
  85   // ...remove the out-of-order packet, insert another in-order packet.
  86   packets.pop_back();
  87   packets.push_back(Packet(120, 0));
  88   EXPECT_TRUE(IsTimeSorted(packets));
  89 }
  90
  91 TEST(BweTestFramework_PacketTest, IsSequenceNumberSorted) {
  92   Packets packets;
  93   // Insert some packets in order...
  94   EXPECT_TRUE(IsSequenceNumberSorted(packets));
  95
  96   packets.push_back(Packet(0, 100));
  97   EXPECT_TRUE(IsSequenceNumberSorted(packets));
  98
  99   packets.push_back(Packet(0, 110));
 100   EXPECT_TRUE(IsSequenceNumberSorted(packets));
 101
 102   // ...and one out-of-order...
 103   packets.push_back(Packet(0, 100));
 104   EXPECT_FALSE(IsSequenceNumberSorted(packets));
 105
 106   // ...remove the out-of-order packet, insert another in-order packet.
 107   packets.pop_back();
 108   packets.push_back(Packet(0, 120));
 109   EXPECT_TRUE(IsSequenceNumberSorted(packets));
 110 }
 111
 112 TEST(BweTestFramework_StatsTest, Mean) {
 113   Stats<int32_t> stats;
 114   EXPECT_EQ(0, stats.GetMean());
 115
 116   stats.Push(1);
 117   stats.Push(3);
 118   EXPECT_EQ(2, stats.GetMean());
 119
 120   // Integer division rounds (1+3-3)/3 to 0.
 121   stats.Push(-3);
 122   EXPECT_EQ(0, stats.GetMean());
 123 }
 124
 125 TEST(BweTestFramework_StatsTest, Variance) {
 126   Stats<int32_t> stats;
 127   EXPECT_EQ(0, stats.GetVariance());
 128
 129   // Mean is 2 ; ((1-2)*(1-2)+(3-2)*(3-2))/2 = (1+1)/2 = 1
 130   stats.Push(1);
 131   stats.Push(3);
 132   EXPECT_EQ(1, stats.GetVariance());
 133
 134   // Integer division rounds 26/3 to 8
 135   // Mean is 0 ; (1*1+3*3+(-4)*(-4))/3 = (1+9+16)/3 = 8
 136   stats.Push(-4);
 137   EXPECT_EQ(8, stats.GetVariance());
 138 }
 139
 140 TEST(BweTestFramework_StatsTest, StdDev) {
 141   Stats<int32_t> stats;
 142   EXPECT_EQ(0, stats.GetStdDev());
 143
 144   // Variance is 1 ; sqrt(1) = 1
 145   stats.Push(1);
 146   stats.Push(3);
 147   EXPECT_EQ(1, stats.GetStdDev());
 148
 149   // Variance is 8 ; sqrt(8) = 2 with integers.
 150   stats.Push(-4);
 151   EXPECT_EQ(2, stats.GetStdDev());
 152 }
 153
 154 TEST(BweTestFramework_StatsTest, MinMax) {
 155   Stats<int32_t> stats;
 156   EXPECT_EQ(0, stats.GetMin());
 157   EXPECT_EQ(0, stats.GetMax());
 158
 159   stats.Push(1);
 160   EXPECT_EQ(1, stats.GetMin());
 161   EXPECT_EQ(1, stats.GetMax());
 162
 163   stats.Push(3);
 164   EXPECT_EQ(1, stats.GetMin());
 165   EXPECT_EQ(3, stats.GetMax());
 166
 167   stats.Push(-4);
 168   EXPECT_EQ(-4, stats.GetMin());
 169   EXPECT_EQ(3, stats.GetMax());
 170 }
 171
 172 class BweTestFramework_RateCounterFilterTest : public ::testing::Test {
 173  public:
 174   BweTestFramework_RateCounterFilterTest()
 175     : filter_(NULL),
 176       now_ms_(0) {
 177   }
 178   virtual ~BweTestFramework_RateCounterFilterTest() {}
 179
 180  protected:
 181   void TestRateCounter(int64_t run_for_ms, uint32_t payload_bits,
 182                        uint32_t expected_pps, uint32_t expected_bps) {
 183     Packets packets;
 184     RTPHeader header;
 185     // "Send" a packet every 10 ms.
 186     for (int64_t i = 0; i < run_for_ms; i += 10, now_ms_ += 10) {
 187       packets.push_back(Packet(0, now_ms_ * 1000, payload_bits / 8, header));
 188     }
 189     filter_.RunFor(run_for_ms, &packets);
 190     ASSERT_TRUE(IsTimeSorted(packets));
 191     EXPECT_EQ(expected_pps, filter_.packets_per_second());
 192     EXPECT_EQ(expected_bps, filter_.bits_per_second());
 193   }
 194
 195  private:
 196   RateCounterFilter filter_;
 197   int64_t now_ms_;
 198
 199   DISALLOW_COPY_AND_ASSIGN(BweTestFramework_RateCounterFilterTest);
 200 };
 201
 202 TEST_F(BweTestFramework_RateCounterFilterTest, Short) {
 203   // 100ms, 100 bytes per packet, should result in 10 pps and 8 kbps. We're
 204   // generating one packet every 10 ms ; 10 * 800 = 8k
 205   TestRateCounter(100, 800, 10, 8000);
 206 }
 207
 208 TEST_F(BweTestFramework_RateCounterFilterTest, Medium) {
 209   // 100ms, like above.
 210   TestRateCounter(100, 800, 10, 8000);
 211   // 1000ms, 100 bpp, should result in 100 pps and 80 kbps. We're still
 212   // generating packets every 10 ms.
 213   TestRateCounter(900, 800, 100, 80000);
 214 }
 215
 216 TEST_F(BweTestFramework_RateCounterFilterTest, Long) {
 217   // 100ms, 1000ms, like above.
 218   TestRateCounter(100, 800, 10, 8000);
 219   TestRateCounter(900, 800, 100, 80000);
 220   // 2000ms, should only see rate of last second, so 100 pps, and 40 kbps now.
 221   TestRateCounter(1000, 400, 100, 40000);
 222   // 2500ms, half a second with zero payload size. We should get same pps as
 223   // before, but kbps should drop to half of previous rate.
 224   TestRateCounter(500, 0, 100, 20000);
 225   // Another half second with zero payload size. Now the kbps rate should drop
 226   // to zero.
 227   TestRateCounter(500, 0, 100, 0);
 228   // Increate payload size again. 200 * 100 * 0.5 = 10 kbps.
 229   TestRateCounter(500, 200, 100, 10000);
 230 }
 231
 232 static void TestLossFilter(float loss_percent, bool zero_tolerance) {
 233   LossFilter filter(NULL);
 234   filter.SetLoss(loss_percent);
 235   Packets::size_type sent_packets = 0;
 236   Packets::size_type remaining_packets = 0;
 237
 238   // No input should yield no output
 239   {
 240     Packets packets;
 241     sent_packets += packets.size();
 242     filter.RunFor(0, &packets);
 243     ASSERT_TRUE(IsTimeSorted(packets));
 244     ASSERT_TRUE(IsSequenceNumberSorted(packets));
 245     remaining_packets += packets.size();
 246     EXPECT_EQ(0u, sent_packets);
 247     EXPECT_EQ(0u, remaining_packets);
 248   }
 249
 250   // Generate and process 10000 packets in different batch sizes (some empty)
 251   for (int i = 0; i < 2225; ++i) {
 252     Packets packets;
 253     packets.insert(packets.end(), i % 10, Packet());
 254     sent_packets += packets.size();
 255     filter.RunFor(0, &packets);
 256     ASSERT_TRUE(IsTimeSorted(packets));
 257     ASSERT_TRUE(IsSequenceNumberSorted(packets));
 258     remaining_packets += packets.size();
 259   }
 260
 261   float loss_fraction = 0.01f * (100.0f - loss_percent);
 262   Packets::size_type expected_packets = loss_fraction * sent_packets;
 263   if (zero_tolerance) {
 264     EXPECT_EQ(expected_packets, remaining_packets);
 265   } else {
 266     // Require within 1% of expected
 267     EXPECT_NEAR(expected_packets, remaining_packets, 100);
 268   }
 269 }
 270
 271 TEST(BweTestFramework_LossFilterTest, Loss0) {
 272   // With 0% loss, the result should be exact (no loss).
 273   TestLossFilter(0.0f, true);
 274 }
 275
 276 TEST(BweTestFramework_LossFilterTest, Loss10) {
 277   TestLossFilter(10.0f, false);
 278 }
 279
 280 TEST(BweTestFramework_LossFilterTest, Loss50) {
 281   TestLossFilter(50.0f, false);
 282 }
 283
 284 TEST(BweTestFramework_LossFilterTest, Loss100) {
 285   // With 100% loss, the result should be exact (no packets out).
 286   TestLossFilter(100.0f, true);
 287 }
 288
 289 class BweTestFramework_DelayFilterTest : public ::testing::Test {
 290  public:
 291   BweTestFramework_DelayFilterTest()
 292     : filter_(NULL),
 293       now_ms_(0),
 294       sequence_number_(0) {
 295   }
 296   virtual ~BweTestFramework_DelayFilterTest() {}
 297
 298  protected:
 299   void TestDelayFilter(int64_t run_for_ms, uint32_t in_packets,
 300                        uint32_t out_packets) {
 301     Packets packets;
 302     for (uint32_t i = 0; i < in_packets; ++i) {
 303       packets.push_back(Packet(now_ms_ * 1000 + (sequence_number_ >> 4),
 304                                   sequence_number_));
 305       sequence_number_++;
 306     }
 307     filter_.RunFor(run_for_ms, &packets);
 308     ASSERT_TRUE(IsTimeSorted(packets));
 309     ASSERT_TRUE(IsSequenceNumberSorted(packets));
 310     for (PacketsConstIt it = packets.begin(); it != packets.end(); ++it) {
 311       EXPECT_LE(now_ms_ * 1000, it->send_time_us());
 312     }
 313     EXPECT_EQ(out_packets, packets.size());
 314     accumulated_packets_.splice(accumulated_packets_.end(), packets);
 315     now_ms_ += run_for_ms;
 316   }
 317
 318   void TestDelayFilter(int64_t delay_ms) {
 319     filter_.SetDelay(delay_ms);
 320     TestDelayFilter(1, 0, 0);    // No input should yield no output
 321
 322     // Single packet
 323     TestDelayFilter(0, 1, 1);
 324     TestDelayFilter(delay_ms, 0, 0);
 325
 326     for (int i = 0; i < delay_ms; ++i) {
 327       filter_.SetDelay(i);
 328       TestDelayFilter(1, 10, 10);
 329     }
 330     TestDelayFilter(0, 0, 0);
 331     TestDelayFilter(delay_ms, 0, 0);
 332
 333     // Wait a little longer - should still see no output
 334     TestDelayFilter(delay_ms, 0, 0);
 335
 336     for (int i = 1; i < delay_ms + 1; ++i) {
 337       filter_.SetDelay(i);
 338       TestDelayFilter(1, 5, 5);
 339     }
 340     TestDelayFilter(0, 0, 0);
 341     filter_.SetDelay(2 * delay_ms);
 342     TestDelayFilter(1, 0, 0);
 343     TestDelayFilter(delay_ms, 13, 13);
 344     TestDelayFilter(delay_ms, 0, 0);
 345
 346     // Wait a little longer - should still see no output
 347     TestDelayFilter(delay_ms, 0, 0);
 348
 349     for (int i = 0; i < 2 * delay_ms; ++i) {
 350       filter_.SetDelay(2 * delay_ms - i - 1);
 351       TestDelayFilter(1, 5, 5);
 352     }
 353     TestDelayFilter(0, 0, 0);
 354     filter_.SetDelay(0);
 355     TestDelayFilter(0, 7, 7);
 356
 357     ASSERT_TRUE(IsTimeSorted(accumulated_packets_));
 358     ASSERT_TRUE(IsSequenceNumberSorted(accumulated_packets_));
 359   }
 360
 361   DelayFilter filter_;
 362   Packets accumulated_packets_;
 363
 364  private:
 365   int64_t now_ms_;
 366   uint32_t sequence_number_;
 367
 368   DISALLOW_COPY_AND_ASSIGN(BweTestFramework_DelayFilterTest);
 369 };
 370
 371 TEST_F(BweTestFramework_DelayFilterTest, Delay0) {
 372   TestDelayFilter(1, 0, 0);    // No input should yield no output
 373   TestDelayFilter(1, 10, 10);  // Expect no delay (delay time is zero)
 374   TestDelayFilter(1, 0, 0);    // Check no packets are still in buffer
 375   filter_.SetDelay(0);
 376   TestDelayFilter(1, 5, 5);    // Expect no delay (delay time is zero)
 377   TestDelayFilter(1, 0, 0);    // Check no packets are still in buffer
 378 }
 379
 380 TEST_F(BweTestFramework_DelayFilterTest, Delay1) {
 381   TestDelayFilter(1);
 382 }
 383
 384 TEST_F(BweTestFramework_DelayFilterTest, Delay2) {
 385   TestDelayFilter(2);
 386 }
 387
 388 TEST_F(BweTestFramework_DelayFilterTest, Delay20) {
 389   TestDelayFilter(20);
 390 }
 391
 392 TEST_F(BweTestFramework_DelayFilterTest, Delay100) {
 393   TestDelayFilter(100);
 394 }
 395
 396 TEST_F(BweTestFramework_DelayFilterTest, JumpToZeroDelay) {
 397   DelayFilter delay(NULL);
 398   Packets acc;
 399   Packets packets;
 400
 401   // Delay a bunch of packets, accumulate them to the 'acc' list.
 402   delay.SetDelay(100.0f);
 403   for (uint32_t i = 0; i < 10; ++i) {
 404     packets.push_back(Packet(i * 100, i));
 405   }
 406   delay.RunFor(1000, &packets);
 407   acc.splice(acc.end(), packets);
 408   ASSERT_TRUE(IsTimeSorted(acc));
 409   ASSERT_TRUE(IsSequenceNumberSorted(acc));
 410
 411   // Drop delay to zero, send a few more packets through the delay, append them
 412   // to the 'acc' list and verify that it is all sorted.
 413   delay.SetDelay(0.0f);
 414   for (uint32_t i = 10; i < 50; ++i) {
 415     packets.push_back(Packet(i * 100, i));
 416   }
 417   delay.RunFor(1000, &packets);
 418   acc.splice(acc.end(), packets);
 419   ASSERT_TRUE(IsTimeSorted(acc));
 420   ASSERT_TRUE(IsSequenceNumberSorted(acc));
 421 }
 422
 423 TEST_F(BweTestFramework_DelayFilterTest, IncreasingDelay) {
 424   // Gradually increase delay.
 425   for (int i = 1; i < 50; i += 4) {
 426     TestDelayFilter(i);
 427   }
 428   // Reach a steady state.
 429   filter_.SetDelay(100);
 430   TestDelayFilter(1, 20, 20);
 431   TestDelayFilter(2, 0, 0);
 432   TestDelayFilter(99, 20, 20);
 433   // Drop delay back down to zero.
 434   filter_.SetDelay(0);
 435   TestDelayFilter(1, 100, 100);
 436   TestDelayFilter(23010, 0, 0);
 437   ASSERT_TRUE(IsTimeSorted(accumulated_packets_));
 438   ASSERT_TRUE(IsSequenceNumberSorted(accumulated_packets_));
 439 }
 440
 441 static void TestJitterFilter(int64_t stddev_jitter_ms) {
 442   JitterFilter filter(NULL);
 443   filter.SetJitter(stddev_jitter_ms);
 444
 445   int64_t now_ms = 0;
 446   uint32_t sequence_number = 0;
 447
 448   // Generate packets, add jitter to them, accumulate the altered packets.
 449   Packets original;
 450   Packets jittered;
 451   for (uint32_t i = 0; i < 1000; ++i) {
 452     Packets packets;
 453     for (uint32_t j = 0; j < i % 100; ++j) {
 454       packets.push_back(Packet(now_ms * 1000, sequence_number++));
 455       now_ms += 5 * stddev_jitter_ms;
 456     }
 457     original.insert(original.end(), packets.begin(), packets.end());
 458     filter.RunFor(stddev_jitter_ms, &packets);
 459     jittered.splice(jittered.end(), packets);
 460   }
 461
 462   // Jittered packets should still be in order.
 463   ASSERT_TRUE(IsTimeSorted(original));
 464   ASSERT_TRUE(IsTimeSorted(jittered));
 465   ASSERT_TRUE(IsSequenceNumberSorted(original));
 466   ASSERT_TRUE(IsSequenceNumberSorted(jittered));
 467   EXPECT_EQ(original.size(), jittered.size());
 468
 469   // Make sure jittered and original packets are in same order. Collect time
 470   // difference (jitter) in stats, then check that mean jitter is close to zero
 471   // and standard deviation of jitter is what we set it to.
 472   Stats<double> jitter_us;
 473   for (PacketsIt it1 = original.begin(), it2 = jittered.begin();
 474        it1 != original.end() && it2 != jittered.end(); ++it1, ++it2) {
 475     EXPECT_EQ(it1->header().sequenceNumber, it2->header().sequenceNumber);
 476     jitter_us.Push(it2->send_time_us() - it1->send_time_us());
 477   }
 478   EXPECT_NEAR(0.0, jitter_us.GetMean(), stddev_jitter_ms * 1000.0 * 0.008);
 479   EXPECT_NEAR(stddev_jitter_ms * 1000.0, jitter_us.GetStdDev(),
 480               stddev_jitter_ms * 1000.0 * 0.02);
 481 }
 482
 483 TEST(BweTestFramework_JitterFilterTest, Jitter0) {
 484   TestJitterFilter(0);
 485 }
 486
 487 TEST(BweTestFramework_JitterFilterTest, Jitter1) {
 488   TestJitterFilter(1);
 489 }
 490
 491 TEST(BweTestFramework_JitterFilterTest, Jitter5) {
 492   TestJitterFilter(5);
 493 }
 494
 495 TEST(BweTestFramework_JitterFilterTest, Jitter10) {
 496   TestJitterFilter(10);
 497 }
 498
 499 TEST(BweTestFramework_JitterFilterTest, Jitter1031) {
 500   TestJitterFilter(1031);
 501 }
 502
 503 static void TestReorderFilter(uint32_t reorder_percent, uint32_t near_value) {
 504   const uint32_t kPacketCount = 10000;
 505
 506   // Generate packets with 10 ms interval.
 507   Packets packets;
 508   int64_t now_ms = 0;
 509   uint32_t sequence_number = 1;
 510   for (uint32_t i = 0; i < kPacketCount; ++i, now_ms += 10) {
 511     packets.push_back(Packet(now_ms * 1000, sequence_number++));
 512   }
 513   ASSERT_TRUE(IsTimeSorted(packets));
 514   ASSERT_TRUE(IsSequenceNumberSorted(packets));
 515
 516   // Reorder packets, verify that send times are still in order.
 517   ReorderFilter filter(NULL);
 518   filter.SetReorder(reorder_percent);
 519   filter.RunFor(now_ms, &packets);
 520   ASSERT_TRUE(IsTimeSorted(packets));
 521
 522   // We measure the amount of reordering by summing the distance by which out-
 523   // of-order packets have been moved in the stream.
 524   uint32_t distance = 0;
 525   uint32_t last_sequence_number = 0;
 526   for (PacketsIt it = packets.begin(); it != packets.end(); ++it) {
 527     uint32_t sequence_number = it->header().sequenceNumber;
 528     if (sequence_number < last_sequence_number) {
 529       distance += last_sequence_number - sequence_number;
 530     }
 531     last_sequence_number = sequence_number;
 532   }
 533
 534   // Because reordering is random, we allow a threshold when comparing. The
 535   // maximum distance a packet can be moved is PacketCount - 1.
 536   EXPECT_NEAR(
 537     ((kPacketCount - 1) * reorder_percent) / 100, distance, near_value);
 538 }
 539
 540 TEST(BweTestFramework_ReorderFilterTest, Reorder0) {
 541   // For 0% reordering, no packets should have been moved, so result is exact.
 542   TestReorderFilter(0, 0);
 543 }
 544
 545 TEST(BweTestFramework_ReorderFilterTest, Reorder10) {
 546   TestReorderFilter(10, 30);
 547 }
 548
 549 TEST(BweTestFramework_ReorderFilterTest, Reorder20) {
 550   TestReorderFilter(20, 20);
 551 }
 552
 553 TEST(BweTestFramework_ReorderFilterTest, Reorder50) {
 554   TestReorderFilter(50, 20);
 555 }
 556
 557 TEST(BweTestFramework_ReorderFilterTest, Reorder70) {
 558   TestReorderFilter(70, 20);
 559 }
 560
 561 TEST(BweTestFramework_ReorderFilterTest, Reorder100) {
 562   // Note that because the implementation works by optionally swapping two
 563   // adjacent packets, when the likelihood of a swap is 1.0, a swap will always
 564   // occur, so the stream will be in order except for the first packet, which
 565   // has been moved to the end. Therefore we expect the result to be exact here.
 566   TestReorderFilter(100.0, 0);
 567 }
 568
 569 class BweTestFramework_ChokeFilterTest : public ::testing::Test {
 570  public:
 571   BweTestFramework_ChokeFilterTest()
 572     : now_ms_(0),
 573       sequence_number_(0),
 574       output_packets_(),
 575       send_times_us_() {
 576   }
 577   virtual ~BweTestFramework_ChokeFilterTest() {}
 578
 579  protected:
 580   void TestChoke(PacketProcessor* filter,
 581                  int64_t run_for_ms,
 582                  uint32_t packets_to_generate,
 583                  uint32_t expected_kbit_transmitted) {
 584     // Generate a bunch of packets, apply choke, verify output is ordered.
 585     Packets packets;
 586     RTPHeader header;
 587     for (uint32_t i = 0; i < packets_to_generate; ++i) {
 588       int64_t send_time_ms = now_ms_ + (i * run_for_ms) / packets_to_generate;
 589       header.sequenceNumber = sequence_number_++;
 590       // Payload is 1000 bits.
 591       packets.push_back(Packet(0, send_time_ms * 1000, 125, header));
 592       send_times_us_.push_back(send_time_ms * 1000);
 593     }
 594     ASSERT_TRUE(IsTimeSorted(packets));
 595     filter->RunFor(run_for_ms, &packets);
 596     now_ms_ += run_for_ms;
 597     output_packets_.splice(output_packets_.end(), packets);
 598     ASSERT_TRUE(IsTimeSorted(output_packets_));
 599     ASSERT_TRUE(IsSequenceNumberSorted(output_packets_));
 600
 601     // Sum up the transmitted bytes up until the current time.
 602     uint32_t bytes_transmitted = 0;
 603     while (!output_packets_.empty()) {
 604       const Packet& packet = output_packets_.front();
 605       if (packet.send_time_us() > now_ms_ * 1000) {
 606         break;
 607       }
 608       bytes_transmitted += packet.payload_size();
 609       output_packets_.pop_front();
 610     }
 611     EXPECT_EQ(expected_kbit_transmitted, (bytes_transmitted * 8) / 1000);
 612   }
 613
 614   void CheckMaxDelay(int64_t max_delay_ms) {
 615     for (PacketsIt it = output_packets_.begin(); it != output_packets_.end();
 616         ++it) {
 617       const Packet& packet = *it;
 618       int64_t delay_us = packet.send_time_us() -
 619           send_times_us_[packet.header().sequenceNumber];
 620       EXPECT_GE(max_delay_ms * 1000, delay_us);
 621     }
 622   }
 623
 624  private:
 625   int64_t now_ms_;
 626   uint32_t sequence_number_;
 627   Packets output_packets_;
 628   std::vector<int64_t> send_times_us_;
 629
 630   DISALLOW_COPY_AND_ASSIGN(BweTestFramework_ChokeFilterTest);
 631 };
 632
 633 TEST_F(BweTestFramework_ChokeFilterTest, Short) {
 634   // 100ms, 100 packets, 10 kbps choke -> 1 kbit of data should have propagated.
 635   // That is actually just a single packet, since each packet has 1000 bits of
 636   // payload.
 637   ChokeFilter filter(NULL);
 638   filter.SetCapacity(10);
 639   TestChoke(&filter, 100, 100, 1);
 640 }
 641
 642 TEST_F(BweTestFramework_ChokeFilterTest, Medium) {
 643   // 100ms, 10 packets, 10 kbps choke -> 1 packet through, or 1 kbit.
 644   ChokeFilter filter(NULL);
 645   filter.SetCapacity(10);
 646   TestChoke(&filter, 100, 10, 1);
 647   // 200ms, no new packets -> another packet through.
 648   TestChoke(&filter, 100, 0, 1);
 649   // 1000ms, no new packets -> 8 more packets.
 650   TestChoke(&filter, 800, 0, 8);
 651   // 2000ms, no new packets -> queue is empty so no output.
 652   TestChoke(&filter, 1000, 0, 0);
 653 }
 654
 655 TEST_F(BweTestFramework_ChokeFilterTest, Long) {
 656   // 100ms, 100 packets in queue, 10 kbps choke -> 1 packet through, or 1 kbit.
 657   ChokeFilter filter(NULL);
 658   filter.SetCapacity(10);
 659   TestChoke(&filter, 100, 100, 1);
 660   // 200ms, no input, another packet through.
 661   TestChoke(&filter, 100, 0, 1);
 662   // 1000ms, no input, 8 packets through.
 663   TestChoke(&filter, 800, 0, 8);
 664   // 10000ms, no input, raise choke to 100 kbps. Remaining 90 packets in queue
 665   // should be propagated, for a total of 90 kbps.
 666   filter.SetCapacity(100);
 667   TestChoke(&filter, 9000, 0, 90);
 668   // 10100ms, 20 more packets -> 10 packets or 10 kbit through.
 669   TestChoke(&filter, 100, 20, 10);
 670   // 10300ms, 10 more packets -> 20 packets out.
 671   TestChoke(&filter, 200, 10, 20);
 672   // 11300ms, no input, queue should be empty.
 673   filter.SetCapacity(10);
 674   TestChoke(&filter, 1000, 0, 0);
 675 }
 676
 677 TEST_F(BweTestFramework_ChokeFilterTest, MaxDelay) {
 678   // 10 kbps choke, 500 ms delay cap
 679   ChokeFilter filter(NULL);
 680   filter.SetCapacity(10);
 681   filter.SetMaxDelay(500);
 682   // 100ms, 100 packets in queue, 10 kbps choke -> 1 packet through, or 1 kbit.
 683   TestChoke(&filter, 100, 100, 1);
 684   CheckMaxDelay(500);
 685   // 500ms, no input, 4 more packets through.
 686   TestChoke(&filter, 400, 0, 4);
 687   // 10000ms, no input, remaining packets should have been dropped.
 688   TestChoke(&filter, 9500, 0, 0);
 689
 690   // 100 ms delay cap
 691   filter.SetMaxDelay(100);
 692   // 10100ms, 50 more packets -> 2 packets or 2 kbit through.
 693   TestChoke(&filter, 100, 50, 2);
 694   CheckMaxDelay(100);
 695   // 20000ms, no input, remaining packets in queue should have been dropped.
 696   TestChoke(&filter, 9900, 0, 0);
 697
 698   // Reset delay cap (0 is no cap) and verify no packets are dropped.
 699   filter.SetCapacity(10);
 700   filter.SetMaxDelay(0);
 701   TestChoke(&filter, 100, 100, 2);
 702   TestChoke(&filter, 9900, 0, 98);
 703 }
 704
 705 TEST_F(BweTestFramework_ChokeFilterTest, ShortTrace) {
 706   // According to the input file 6 packets should be transmitted within
 707   // 100 milliseconds.
 708   TraceBasedDeliveryFilter filter(NULL);
 709   ASSERT_TRUE(filter.Init(test::ResourcePath("synthetic-trace", "rx")));
 710   TestChoke(&filter, 100, 100, 6);
 711 }
 712
 713 TEST_F(BweTestFramework_ChokeFilterTest, ShortTraceTwoWraps) {
 714   // According to the input file 19 packets should be transmitted within
 715   // 280 milliseconds (at the wrapping point two packets are sent back to back).
 716   TraceBasedDeliveryFilter filter(NULL);
 717   ASSERT_TRUE(filter.Init(test::ResourcePath("synthetic-trace", "rx")));
 718   TestChoke(&filter, 280, 100, 19);
 719 }
 720
 721 TEST_F(BweTestFramework_ChokeFilterTest, ShortTraceMaxDelay) {
 722   TraceBasedDeliveryFilter filter(NULL);
 723   filter.SetMaxDelay(25);
 724   ASSERT_TRUE(filter.Init(test::ResourcePath("synthetic-trace", "rx")));
 725   // Uses all slots up to 110 ms. Several packets are being dropped.
 726   TestChoke(&filter, 110, 20, 9);
 727   CheckMaxDelay(25);
 728   // Simulate enough time for the next slot (at 135 ms) to be used. This makes
 729   // sure that a slot isn't missed between runs.
 730   TestChoke(&filter, 25, 1, 1);
 731 }
 732
 733 void TestVideoSender(VideoSender* sender, int64_t run_for_ms,
 734                      uint32_t expected_packets,
 735                      uint32_t expected_payload_size,
 736                      uint32_t expected_total_payload_size) {
 737   assert(sender);
 738   Packets packets;
 739   sender->RunFor(run_for_ms, &packets);
 740   ASSERT_TRUE(IsTimeSorted(packets));
 741   ASSERT_TRUE(IsSequenceNumberSorted(packets));
 742   EXPECT_EQ(expected_packets, packets.size());
 743   int64_t send_time_us = -1;
 744   uint32_t total_payload_size = 0;
 745   uint32_t absolute_send_time = 0;
 746   uint32_t absolute_send_time_wraps = 0;
 747   uint32_t rtp_timestamp = 0;
 748   uint32_t rtp_timestamp_wraps = 0;
 749   for (PacketsIt it = packets.begin(); it != packets.end(); ++it) {
 750     EXPECT_LE(send_time_us, it->send_time_us());
 751     send_time_us = it->send_time_us();
 752     if (sender->max_payload_size_bytes() != it->payload_size()) {
 753       EXPECT_EQ(expected_payload_size, it->payload_size());
 754     }
 755     total_payload_size += it->payload_size();
 756     if (absolute_send_time > it->header().extension.absoluteSendTime) {
 757       absolute_send_time_wraps++;
 758     }
 759     absolute_send_time = it->header().extension.absoluteSendTime;
 760     if (rtp_timestamp > it->header().timestamp) {
 761       rtp_timestamp_wraps++;
 762     }
 763     rtp_timestamp = it->header().timestamp;
 764   }
 765   EXPECT_EQ(expected_total_payload_size, total_payload_size);
 766   EXPECT_GE(1u, absolute_send_time_wraps);
 767   EXPECT_GE(1u, rtp_timestamp_wraps);
 768 }
 769
 770 TEST(BweTestFramework_VideoSenderTest, Fps1Kbps80_1s) {
 771   // 1 fps, 80 kbps
 772   VideoSender sender(0, NULL, 1.0f, 80, 0x1234, 0);
 773   EXPECT_EQ(10000u, sender.bytes_per_second());
 774   // We're at 1 fps, so all packets should be generated on first call, giving 10
 775   // packets of each 1000 bytes, total 10000 bytes.
 776   TestVideoSender(&sender, 1, 9, 400, 10000);
 777   // 999ms, should see no output here.
 778   TestVideoSender(&sender, 998, 0, 0, 0);
 779   // 1999ms, should get data for one more frame.
 780   TestVideoSender(&sender, 1000, 9, 400, 10000);
 781   // 2000ms, one more frame.
 782   TestVideoSender(&sender, 1, 9, 400, 10000);
 783   // 2999ms, should see nothing.
 784   TestVideoSender(&sender, 999, 0, 0, 0);
 785 }
 786
 787 TEST(BweTestFramework_VideoSenderTest, Fps1Kbps80_1s_Offset) {
 788   // 1 fps, 80 kbps, offset 0.5 of a frame period, ==0.5s in this case.
 789   VideoSender sender(0, NULL, 1.0f, 80, 0x1234, 0.5f);
 790   EXPECT_EQ(10000u, sender.bytes_per_second());
 791   // 499ms, no output.
 792   TestVideoSender(&sender, 499, 0, 0, 0);
 793   // 500ms, first frame (this is the offset we set), 10 packets of 1000 bytes.
 794   TestVideoSender(&sender, 1, 9, 400, 10000);
 795   // 1499ms, nothing.
 796   TestVideoSender(&sender, 999, 0, 0, 0);
 797   // 1999ms, second frame.
 798   TestVideoSender(&sender, 500, 9, 400, 10000);
 799   // 2499ms, nothing.
 800   TestVideoSender(&sender, 500, 0, 0, 0);
 801   // 2500ms, third frame.
 802   TestVideoSender(&sender, 1, 9, 400, 10000);
 803   // 3499ms, nothing.
 804   TestVideoSender(&sender, 999, 0, 0, 0);
 805 }
 806
 807 TEST(BweTestFramework_VideoSenderTest, Fps50Kpbs80_11s) {
 808   // 50 fps, 80 kbps.
 809   VideoSender sender(0, NULL, 50.0f, 80, 0x1234, 0);
 810   EXPECT_EQ(10000u, sender.bytes_per_second());
 811   // 9998ms, should see 500 frames, 200 byte payloads, total 100000 bytes.
 812   TestVideoSender(&sender, 9998, 500, 200, 100000);
 813   // 9999ms, nothing.
 814   TestVideoSender(&sender, 1, 0, 0, 0);
 815   // 10000ms, 501st frame as a single packet.
 816   TestVideoSender(&sender, 1, 1, 200, 200);
 817   // 10998ms, 49 more frames.
 818   TestVideoSender(&sender, 998, 49, 200, 9800);
 819   // 10999ms, nothing.
 820   TestVideoSender(&sender, 1, 0, 0, 0);
 821 }
 822
 823 TEST(BweTestFramework_VideoSenderTest, Fps10Kpbs120_1s) {
 824   // 20 fps, 120 kbps.
 825   VideoSender sender(0, NULL, 20.0f, 120, 0x1234, 0);
 826   EXPECT_EQ(15000u, sender.bytes_per_second());
 827   // 498ms, 10 frames with 750 byte payloads, total 7500 bytes.
 828   TestVideoSender(&sender, 498, 10, 750, 7500);
 829   // 499ms, nothing.
 830   TestVideoSender(&sender, 1, 0, 0, 0);
 831   // 500ms, one more frame.
 832   TestVideoSender(&sender, 1, 1, 750, 750);
 833   // 998ms, 9 more frames.
 834   TestVideoSender(&sender, 498, 9, 750, 6750);
 835   // 999ms, nothing.
 836   TestVideoSender(&sender, 1, 0, 0, 0);
 837 }
 838
 839 TEST(BweTestFramework_VideoSenderTest, Fps30Kbps800_20s) {
 840   // 20 fps, 820 kbps.
 841   VideoSender sender(0, NULL, 25.0f, 820, 0x1234, 0);
 842   EXPECT_EQ(102500u, sender.bytes_per_second());
 843   // 9998ms, 250 frames. 820 kbps = 102500 bytes/s, so total should be 1025000.
 844   // Each frame is 102500/25=4100 bytes, or 5 packets (4 @1000 bytes, 1 @100),
 845   // so packet count should be 5*250=1250 and last packet of each frame has
 846   // 100 bytes of payload.
 847   TestVideoSender(&sender, 9998, 1000, 500, 1025000);
 848   // 9999ms, nothing.
 849   TestVideoSender(&sender, 1, 0, 0, 0);
 850   // 19998ms, 250 more frames.
 851   TestVideoSender(&sender, 9999, 1000, 500, 1025000);
 852   // 19999ms, nothing.
 853   TestVideoSender(&sender, 1, 0, 0, 0);
 854   // 20038ms, one more frame, as described above (25fps == 40ms/frame).
 855   TestVideoSender(&sender, 39, 4, 500, 4100);
 856   // 20039ms, nothing.
 857   TestVideoSender(&sender, 1, 0, 0, 0);
 858 }
 859
 860 TEST(BweTestFramework_VideoSenderTest, TestAppendInOrder) {
 861   // 1 fps, 80 kbps, 250ms offset.
 862   VideoSender sender1(0, NULL, 1.0f, 80, 0x1234, 0.25f);
 863   EXPECT_EQ(10000u, sender1.bytes_per_second());
 864   Packets packets;
 865   // Generate some packets, verify they are sorted.
 866   sender1.RunFor(999, &packets);
 867   ASSERT_TRUE(IsTimeSorted(packets));
 868   ASSERT_TRUE(IsSequenceNumberSorted(packets));
 869   EXPECT_EQ(9u, packets.size());
 870   // Generate some more packets and verify they are appended to end of list.
 871   sender1.RunFor(1000, &packets);
 872   ASSERT_TRUE(IsTimeSorted(packets));
 873   ASSERT_TRUE(IsSequenceNumberSorted(packets));
 874   EXPECT_EQ(18u, packets.size());
 875
 876   // Another sender, 2 fps, 160 kpbs, 150ms offset
 877   VideoSender sender2(0, NULL, 2.0f, 160, 0x2234, 0.30f);
 878   EXPECT_EQ(20000u, sender2.bytes_per_second());
 879   // Generate some packets, verify that they are merged with the packets already
 880   // on the list.
 881   sender2.RunFor(999, &packets);
 882   ASSERT_TRUE(IsTimeSorted(packets));
 883   EXPECT_EQ(36u, packets.size());
 884   // Generate some more.
 885   sender2.RunFor(1000, &packets);
 886   ASSERT_TRUE(IsTimeSorted(packets));
 887   EXPECT_EQ(54u, packets.size());
 888 }
 889
 890 TEST(BweTestFramework_VideoSenderTest, FeedbackIneffective) {
 891   VideoSender sender(0, NULL, 25.0f, 820, 0x1234, 0);
 892   EXPECT_EQ(102500u, sender.bytes_per_second());
 893   TestVideoSender(&sender, 9998, 1000, 500, 1025000);
 894
 895   // Make sure feedback has no effect on a regular video sender.
 896   PacketSender::Feedback feedback = { 512000 };
 897   sender.GiveFeedback(feedback);
 898   EXPECT_EQ(102500u, sender.bytes_per_second());
 899   TestVideoSender(&sender, 9998, 1000, 500, 1025000);
 900 }
 901
 902 TEST(BweTestFramework_AdaptiveVideoSenderTest, FeedbackChangesBitrate) {
 903   AdaptiveVideoSender sender(0, NULL, 25.0f, 820, 0x1234, 0);
 904   EXPECT_EQ(102500u, sender.bytes_per_second());
 905   TestVideoSender(&sender, 9998, 1000, 500, 1025000);
 906
 907   // Make sure we can reduce the bitrate.
 908   PacketSender::Feedback feedback = { 512000 };
 909   sender.GiveFeedback(feedback);
 910   EXPECT_EQ(64000u, sender.bytes_per_second());
 911   TestVideoSender(&sender, 9998, 750, 160, 640000);
 912
 913   // Increase the bitrate to the initial bitrate and verify that the output is
 914   // the same.
 915   feedback.estimated_bps = 820000;
 916   sender.GiveFeedback(feedback);
 917   EXPECT_EQ(102500u, sender.bytes_per_second());
 918   TestVideoSender(&sender, 9998, 1000, 500, 1025000);
 919 }
 920 }  // namespace bwe
 921 }  // namespace testing
 922 }  // namespace webrtc