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 "gtest/gtest.h"
  16 #include "webrtc/system_wrappers/interface/constructor_magic.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) {
 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(((kPacketCount - 1) * reorder_percent) / 100, distance, near);
 537 }
 538
 539 TEST(BweTestFramework_ReorderFilterTest, Reorder0) {
 540   // For 0% reordering, no packets should have been moved, so result is exact.
 541   TestReorderFilter(0, 0);
 542 }
 543
 544 TEST(BweTestFramework_ReorderFilterTest, Reorder10) {
 545   TestReorderFilter(10, 30);
 546 }
 547
 548 TEST(BweTestFramework_ReorderFilterTest, Reorder20) {
 549   TestReorderFilter(20, 20);
 550 }
 551
 552 TEST(BweTestFramework_ReorderFilterTest, Reorder50) {
 553   TestReorderFilter(50, 20);
 554 }
 555
 556 TEST(BweTestFramework_ReorderFilterTest, Reorder70) {
 557   TestReorderFilter(70, 20);
 558 }
 559
 560 TEST(BweTestFramework_ReorderFilterTest, Reorder100) {
 561   // Note that because the implementation works by optionally swapping two
 562   // adjacent packets, when the likelihood of a swap is 1.0, a swap will always
 563   // occur, so the stream will be in order except for the first packet, which
 564   // has been moved to the end. Therefore we expect the result to be exact here.
 565   TestReorderFilter(100.0, 0);
 566 }
 567
 568 class BweTestFramework_ChokeFilterTest : public ::testing::Test {
 569  public:
 570   BweTestFramework_ChokeFilterTest()
 571     : now_ms_(0),
 572       sequence_number_(0),
 573       output_packets_(),
 574       send_times_us_() {
 575   }
 576   virtual ~BweTestFramework_ChokeFilterTest() {}
 577
 578  protected:
 579   void TestChoke(PacketProcessor* filter,
 580                  int64_t run_for_ms,
 581                  uint32_t packets_to_generate,
 582                  uint32_t expected_kbit_transmitted) {
 583     // Generate a bunch of packets, apply choke, verify output is ordered.
 584     Packets packets;
 585     RTPHeader header;
 586     for (uint32_t i = 0; i < packets_to_generate; ++i) {
 587       int64_t send_time_ms = now_ms_ + (i * run_for_ms) / packets_to_generate;
 588       header.sequenceNumber = sequence_number_++;
 589       // Payload is 1000 bits.
 590       packets.push_back(Packet(0, send_time_ms * 1000, 125, header));
 591       send_times_us_.push_back(send_time_ms * 1000);
 592     }
 593     ASSERT_TRUE(IsTimeSorted(packets));
 594     filter->RunFor(run_for_ms, &packets);
 595     now_ms_ += run_for_ms;
 596     output_packets_.splice(output_packets_.end(), packets);
 597     ASSERT_TRUE(IsTimeSorted(output_packets_));
 598     ASSERT_TRUE(IsSequenceNumberSorted(output_packets_));
 599
 600     // Sum up the transmitted bytes up until the current time.
 601     uint32_t bytes_transmitted = 0;
 602     while (!output_packets_.empty()) {
 603       const Packet& packet = output_packets_.front();
 604       if (packet.send_time_us() > now_ms_ * 1000) {
 605         break;
 606       }
 607       bytes_transmitted += packet.payload_size();
 608       output_packets_.pop_front();
 609     }
 610     EXPECT_EQ(expected_kbit_transmitted, (bytes_transmitted * 8) / 1000);
 611   }
 612
 613   void CheckMaxDelay(int64_t max_delay_ms) {
 614     for (PacketsIt it = output_packets_.begin(); it != output_packets_.end();
 615         ++it) {
 616       const Packet& packet = *it;
 617       int64_t delay_us = packet.send_time_us() -
 618           send_times_us_[packet.header().sequenceNumber];
 619       EXPECT_GE(max_delay_ms * 1000, delay_us);
 620     }
 621   }
 622
 623  private:
 624   int64_t now_ms_;
 625   uint32_t sequence_number_;
 626   Packets output_packets_;
 627   std::vector<int64_t> send_times_us_;
 628
 629   DISALLOW_COPY_AND_ASSIGN(BweTestFramework_ChokeFilterTest);
 630 };
 631
 632 TEST_F(BweTestFramework_ChokeFilterTest, Short) {
 633   // 100ms, 100 packets, 10 kbps choke -> 1 kbit of data should have propagated.
 634   // That is actually just a single packet, since each packet has 1000 bits of
 635   // payload.
 636   ChokeFilter filter(NULL);
 637   filter.SetCapacity(10);
 638   TestChoke(&filter, 100, 100, 1);
 639 }
 640
 641 TEST_F(BweTestFramework_ChokeFilterTest, Medium) {
 642   // 100ms, 10 packets, 10 kbps choke -> 1 packet through, or 1 kbit.
 643   ChokeFilter filter(NULL);
 644   filter.SetCapacity(10);
 645   TestChoke(&filter, 100, 10, 1);
 646   // 200ms, no new packets -> another packet through.
 647   TestChoke(&filter, 100, 0, 1);
 648   // 1000ms, no new packets -> 8 more packets.
 649   TestChoke(&filter, 800, 0, 8);
 650   // 2000ms, no new packets -> queue is empty so no output.
 651   TestChoke(&filter, 1000, 0, 0);
 652 }
 653
 654 TEST_F(BweTestFramework_ChokeFilterTest, Long) {
 655   // 100ms, 100 packets in queue, 10 kbps choke -> 1 packet through, or 1 kbit.
 656   ChokeFilter filter(NULL);
 657   filter.SetCapacity(10);
 658   TestChoke(&filter, 100, 100, 1);
 659   // 200ms, no input, another packet through.
 660   TestChoke(&filter, 100, 0, 1);
 661   // 1000ms, no input, 8 packets through.
 662   TestChoke(&filter, 800, 0, 8);
 663   // 10000ms, no input, raise choke to 100 kbps. Remaining 90 packets in queue
 664   // should be propagated, for a total of 90 kbps.
 665   filter.SetCapacity(100);
 666   TestChoke(&filter, 9000, 0, 90);
 667   // 10100ms, 20 more packets -> 10 packets or 10 kbit through.
 668   TestChoke(&filter, 100, 20, 10);
 669   // 10300ms, 10 more packets -> 20 packets out.
 670   TestChoke(&filter, 200, 10, 20);
 671   // 11300ms, no input, queue should be empty.
 672   filter.SetCapacity(10);
 673   TestChoke(&filter, 1000, 0, 0);
 674 }
 675
 676 TEST_F(BweTestFramework_ChokeFilterTest, MaxDelay) {
 677   // 10 kbps choke, 500 ms delay cap
 678   ChokeFilter filter(NULL);
 679   filter.SetCapacity(10);
 680   filter.SetMaxDelay(500);
 681   // 100ms, 100 packets in queue, 10 kbps choke -> 1 packet through, or 1 kbit.
 682   TestChoke(&filter, 100, 100, 1);
 683   CheckMaxDelay(500);
 684   // 500ms, no input, 4 more packets through.
 685   TestChoke(&filter, 400, 0, 4);
 686   // 10000ms, no input, remaining packets should have been dropped.
 687   TestChoke(&filter, 9500, 0, 0);
 688
 689   // 100 ms delay cap
 690   filter.SetMaxDelay(100);
 691   // 10100ms, 50 more packets -> 2 packets or 2 kbit through.
 692   TestChoke(&filter, 100, 50, 2);
 693   CheckMaxDelay(100);
 694   // 20000ms, no input, remaining packets in queue should have been dropped.
 695   TestChoke(&filter, 9900, 0, 0);
 696
 697   // Reset delay cap (0 is no cap) and verify no packets are dropped.
 698   filter.SetCapacity(10);
 699   filter.SetMaxDelay(0);
 700   TestChoke(&filter, 100, 100, 2);
 701   TestChoke(&filter, 9900, 0, 98);
 702 }
 703
 704 TEST_F(BweTestFramework_ChokeFilterTest, ShortTrace) {
 705   // According to the input file 6 packets should be transmitted within
 706   // 100 milliseconds.
 707   TraceBasedDeliveryFilter filter(NULL);
 708   ASSERT_TRUE(filter.Init(test::ResourcePath("synthetic-trace", "rx")));
 709   TestChoke(&filter, 100, 100, 6);
 710 }
 711
 712 TEST_F(BweTestFramework_ChokeFilterTest, ShortTraceTwoWraps) {
 713   // According to the input file 19 packets should be transmitted within
 714   // 280 milliseconds (at the wrapping point two packets are sent back to back).
 715   TraceBasedDeliveryFilter filter(NULL);
 716   ASSERT_TRUE(filter.Init(test::ResourcePath("synthetic-trace", "rx")));
 717   TestChoke(&filter, 280, 100, 19);
 718 }
 719
 720 TEST_F(BweTestFramework_ChokeFilterTest, ShortTraceMaxDelay) {
 721   TraceBasedDeliveryFilter filter(NULL);
 722   filter.SetMaxDelay(25);
 723   ASSERT_TRUE(filter.Init(test::ResourcePath("synthetic-trace", "rx")));
 724   // Uses all slots up to 110 ms. Several packets are being dropped.
 725   TestChoke(&filter, 110, 20, 9);
 726   CheckMaxDelay(25);
 727   // Simulate enough time for the next slot (at 135 ms) to be used. This makes
 728   // sure that a slot isn't missed between runs.
 729   TestChoke(&filter, 25, 1, 1);
 730 }
 731
 732 void TestVideoSender(VideoSender* sender, int64_t run_for_ms,
 733                      uint32_t expected_packets,
 734                      uint32_t expected_payload_size,
 735                      uint32_t expected_total_payload_size) {
 736   assert(sender);
 737   Packets packets;
 738   sender->RunFor(run_for_ms, &packets);
 739   ASSERT_TRUE(IsTimeSorted(packets));
 740   ASSERT_TRUE(IsSequenceNumberSorted(packets));
 741   EXPECT_EQ(expected_packets, packets.size());
 742   int64_t send_time_us = -1;
 743   uint32_t total_payload_size = 0;
 744   uint32_t absolute_send_time = 0;
 745   uint32_t absolute_send_time_wraps = 0;
 746   uint32_t rtp_timestamp = 0;
 747   uint32_t rtp_timestamp_wraps = 0;
 748   for (PacketsIt it = packets.begin(); it != packets.end(); ++it) {
 749     EXPECT_LE(send_time_us, it->send_time_us());
 750     send_time_us = it->send_time_us();
 751     if (sender->max_payload_size_bytes() != it->payload_size()) {
 752       EXPECT_EQ(expected_payload_size, it->payload_size());
 753     }
 754     total_payload_size += it->payload_size();
 755     if (absolute_send_time > it->header().extension.absoluteSendTime) {
 756       absolute_send_time_wraps++;
 757     }
 758     absolute_send_time = it->header().extension.absoluteSendTime;
 759     if (rtp_timestamp > it->header().timestamp) {
 760       rtp_timestamp_wraps++;
 761     }
 762     rtp_timestamp = it->header().timestamp;
 763   }
 764   EXPECT_EQ(expected_total_payload_size, total_payload_size);
 765   EXPECT_GE(1u, absolute_send_time_wraps);
 766   EXPECT_GE(1u, rtp_timestamp_wraps);
 767 }
 768
 769 TEST(BweTestFramework_VideoSenderTest, Fps1Kbps80_1s) {
 770   // 1 fps, 80 kbps
 771   VideoSender sender(0, NULL, 1.0f, 80, 0x1234, 0);
 772   EXPECT_EQ(10000u, sender.bytes_per_second());
 773   // We're at 1 fps, so all packets should be generated on first call, giving 10
 774   // packets of each 1000 bytes, total 10000 bytes.
 775   TestVideoSender(&sender, 1, 9, 400, 10000);
 776   // 999ms, should see no output here.
 777   TestVideoSender(&sender, 998, 0, 0, 0);
 778   // 1999ms, should get data for one more frame.
 779   TestVideoSender(&sender, 1000, 9, 400, 10000);
 780   // 2000ms, one more frame.
 781   TestVideoSender(&sender, 1, 9, 400, 10000);
 782   // 2999ms, should see nothing.
 783   TestVideoSender(&sender, 999, 0, 0, 0);
 784 }
 785
 786 TEST(BweTestFramework_VideoSenderTest, Fps1Kbps80_1s_Offset) {
 787   // 1 fps, 80 kbps, offset 0.5 of a frame period, ==0.5s in this case.
 788   VideoSender sender(0, NULL, 1.0f, 80, 0x1234, 0.5f);
 789   EXPECT_EQ(10000u, sender.bytes_per_second());
 790   // 499ms, no output.
 791   TestVideoSender(&sender, 499, 0, 0, 0);
 792   // 500ms, first frame (this is the offset we set), 10 packets of 1000 bytes.
 793   TestVideoSender(&sender, 1, 9, 400, 10000);
 794   // 1499ms, nothing.
 795   TestVideoSender(&sender, 999, 0, 0, 0);
 796   // 1999ms, second frame.
 797   TestVideoSender(&sender, 500, 9, 400, 10000);
 798   // 2499ms, nothing.
 799   TestVideoSender(&sender, 500, 0, 0, 0);
 800   // 2500ms, third frame.
 801   TestVideoSender(&sender, 1, 9, 400, 10000);
 802   // 3499ms, nothing.
 803   TestVideoSender(&sender, 999, 0, 0, 0);
 804 }
 805
 806 TEST(BweTestFramework_VideoSenderTest, Fps50Kpbs80_11s) {
 807   // 50 fps, 80 kbps.
 808   VideoSender sender(0, NULL, 50.0f, 80, 0x1234, 0);
 809   EXPECT_EQ(10000u, sender.bytes_per_second());
 810   // 9998ms, should see 500 frames, 200 byte payloads, total 100000 bytes.
 811   TestVideoSender(&sender, 9998, 500, 200, 100000);
 812   // 9999ms, nothing.
 813   TestVideoSender(&sender, 1, 0, 0, 0);
 814   // 10000ms, 501st frame as a single packet.
 815   TestVideoSender(&sender, 1, 1, 200, 200);
 816   // 10998ms, 49 more frames.
 817   TestVideoSender(&sender, 998, 49, 200, 9800);
 818   // 10999ms, nothing.
 819   TestVideoSender(&sender, 1, 0, 0, 0);
 820 }
 821
 822 TEST(BweTestFramework_VideoSenderTest, Fps10Kpbs120_1s) {
 823   // 20 fps, 120 kbps.
 824   VideoSender sender(0, NULL, 20.0f, 120, 0x1234, 0);
 825   EXPECT_EQ(15000u, sender.bytes_per_second());
 826   // 498ms, 10 frames with 750 byte payloads, total 7500 bytes.
 827   TestVideoSender(&sender, 498, 10, 750, 7500);
 828   // 499ms, nothing.
 829   TestVideoSender(&sender, 1, 0, 0, 0);
 830   // 500ms, one more frame.
 831   TestVideoSender(&sender, 1, 1, 750, 750);
 832   // 998ms, 9 more frames.
 833   TestVideoSender(&sender, 498, 9, 750, 6750);
 834   // 999ms, nothing.
 835   TestVideoSender(&sender, 1, 0, 0, 0);
 836 }
 837
 838 TEST(BweTestFramework_VideoSenderTest, Fps30Kbps800_20s) {
 839   // 20 fps, 820 kbps.
 840   VideoSender sender(0, NULL, 25.0f, 820, 0x1234, 0);
 841   EXPECT_EQ(102500u, sender.bytes_per_second());
 842   // 9998ms, 250 frames. 820 kbps = 102500 bytes/s, so total should be 1025000.
 843   // Each frame is 102500/25=4100 bytes, or 5 packets (4 @1000 bytes, 1 @100),
 844   // so packet count should be 5*250=1250 and last packet of each frame has
 845   // 100 bytes of payload.
 846   TestVideoSender(&sender, 9998, 1000, 500, 1025000);
 847   // 9999ms, nothing.
 848   TestVideoSender(&sender, 1, 0, 0, 0);
 849   // 19998ms, 250 more frames.
 850   TestVideoSender(&sender, 9999, 1000, 500, 1025000);
 851   // 19999ms, nothing.
 852   TestVideoSender(&sender, 1, 0, 0, 0);
 853   // 20038ms, one more frame, as described above (25fps == 40ms/frame).
 854   TestVideoSender(&sender, 39, 4, 500, 4100);
 855   // 20039ms, nothing.
 856   TestVideoSender(&sender, 1, 0, 0, 0);
 857 }
 858
 859 TEST(BweTestFramework_VideoSenderTest, TestAppendInOrder) {
 860   // 1 fps, 80 kbps, 250ms offset.
 861   VideoSender sender1(0, NULL, 1.0f, 80, 0x1234, 0.25f);
 862   EXPECT_EQ(10000u, sender1.bytes_per_second());
 863   Packets packets;
 864   // Generate some packets, verify they are sorted.
 865   sender1.RunFor(999, &packets);
 866   ASSERT_TRUE(IsTimeSorted(packets));
 867   ASSERT_TRUE(IsSequenceNumberSorted(packets));
 868   EXPECT_EQ(9u, packets.size());
 869   // Generate some more packets and verify they are appended to end of list.
 870   sender1.RunFor(1000, &packets);
 871   ASSERT_TRUE(IsTimeSorted(packets));
 872   ASSERT_TRUE(IsSequenceNumberSorted(packets));
 873   EXPECT_EQ(18u, packets.size());
 874
 875   // Another sender, 2 fps, 160 kpbs, 150ms offset
 876   VideoSender sender2(0, NULL, 2.0f, 160, 0x2234, 0.30f);
 877   EXPECT_EQ(20000u, sender2.bytes_per_second());
 878   // Generate some packets, verify that they are merged with the packets already
 879   // on the list.
 880   sender2.RunFor(999, &packets);
 881   ASSERT_TRUE(IsTimeSorted(packets));
 882   EXPECT_EQ(36u, packets.size());
 883   // Generate some more.
 884   sender2.RunFor(1000, &packets);
 885   ASSERT_TRUE(IsTimeSorted(packets));
 886   EXPECT_EQ(54u, packets.size());
 887 }
 888
 889 TEST(BweTestFramework_VideoSenderTest, FeedbackIneffective) {
 890   VideoSender sender(0, NULL, 25.0f, 820, 0x1234, 0);
 891   EXPECT_EQ(102500u, sender.bytes_per_second());
 892   TestVideoSender(&sender, 9998, 1000, 500, 1025000);
 893
 894   // Make sure feedback has no effect on a regular video sender.
 895   PacketSender::Feedback feedback = { 512000 };
 896   sender.GiveFeedback(feedback);
 897   EXPECT_EQ(102500u, sender.bytes_per_second());
 898   TestVideoSender(&sender, 9998, 1000, 500, 1025000);
 899 }
 900
 901 TEST(BweTestFramework_AdaptiveVideoSenderTest, FeedbackChangesBitrate) {
 902   AdaptiveVideoSender sender(0, NULL, 25.0f, 820, 0x1234, 0);
 903   EXPECT_EQ(102500u, sender.bytes_per_second());
 904   TestVideoSender(&sender, 9998, 1000, 500, 1025000);
 905
 906   // Make sure we can reduce the bitrate.
 907   PacketSender::Feedback feedback = { 512000 };
 908   sender.GiveFeedback(feedback);
 909   EXPECT_EQ(64000u, sender.bytes_per_second());
 910   TestVideoSender(&sender, 9998, 750, 160, 640000);
 911
 912   // Increase the bitrate to the initial bitrate and verify that the output is
 913   // the same.
 914   feedback.estimated_bps = 820000;
 915   sender.GiveFeedback(feedback);
 916   EXPECT_EQ(102500u, sender.bytes_per_second());
 917   TestVideoSender(&sender, 9998, 1000, 500, 1025000);
 918 }
 919 }  // namespace bwe
 920 }  // namespace testing
 921 }  // namespace webrtc