More Simulation Framework features

webrtc/modules/remote_bitrate_estimator/test/bwe_test_framework_unittest.cc

 /*
  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 314 matching lines @@
     ASSERT_TRUE(IsSequenceNumberSorted(packets));
     for (PacketsConstIt it = packets.begin(); it != packets.end(); ++it) {
       EXPECT_LE(now_ms_ * 1000, (*it)->send_time_us());
     }
     EXPECT_EQ(out_packets, packets.size());
     accumulated_packets_.splice(accumulated_packets_.end(), packets);
     now_ms_ += run_for_ms;
   }
 
   void TestDelayFilter(int64_t delay_ms) {
-    filter_.SetDelayMs(delay_ms);
+    filter_.SetOneWayDelayMs(delay_ms);
     TestDelayFilter(1, 0, 0);    // No input should yield no output
 
     // Single packet
     TestDelayFilter(0, 1, 1);
     TestDelayFilter(delay_ms, 0, 0);
 
     for (int i = 0; i < delay_ms; ++i) {
-      filter_.SetDelayMs(i);
+      filter_.SetOneWayDelayMs(i);
       TestDelayFilter(1, 10, 10);
     }
     TestDelayFilter(0, 0, 0);
     TestDelayFilter(delay_ms, 0, 0);
 
     // Wait a little longer - should still see no output
     TestDelayFilter(delay_ms, 0, 0);
 
     for (int i = 1; i < delay_ms + 1; ++i) {
-      filter_.SetDelayMs(i);
+      filter_.SetOneWayDelayMs(i);
       TestDelayFilter(1, 5, 5);
     }
     TestDelayFilter(0, 0, 0);
-    filter_.SetDelayMs(2 * delay_ms);
+    filter_.SetOneWayDelayMs(2 * delay_ms);
     TestDelayFilter(1, 0, 0);
     TestDelayFilter(delay_ms, 13, 13);
     TestDelayFilter(delay_ms, 0, 0);
 
     // Wait a little longer - should still see no output
     TestDelayFilter(delay_ms, 0, 0);
 
     for (int i = 0; i < 2 * delay_ms; ++i) {
-      filter_.SetDelayMs(2 * delay_ms - i - 1);
+      filter_.SetOneWayDelayMs(2 * delay_ms - i - 1);
       TestDelayFilter(1, 5, 5);
     }
     TestDelayFilter(0, 0, 0);
-    filter_.SetDelayMs(0);
+    filter_.SetOneWayDelayMs(0);
     TestDelayFilter(0, 7, 7);
 
     ASSERT_TRUE(IsTimeSorted(accumulated_packets_));
     ASSERT_TRUE(IsSequenceNumberSorted(accumulated_packets_));
   }
 
   DelayFilter filter_;
   Packets accumulated_packets_;
 
  private:
   int64_t now_ms_;
   uint32_t sequence_number_;
 
   DISALLOW_COPY_AND_ASSIGN(BweTestFramework_DelayFilterTest);
 };
 
 TEST_F(BweTestFramework_DelayFilterTest, Delay0) {
   TestDelayFilter(1, 0, 0);    // No input should yield no output
   TestDelayFilter(1, 10, 10);  // Expect no delay (delay time is zero)
   TestDelayFilter(1, 0, 0);    // Check no packets are still in buffer
-  filter_.SetDelayMs(0);
+  filter_.SetOneWayDelayMs(0);
   TestDelayFilter(1, 5, 5);    // Expect no delay (delay time is zero)
   TestDelayFilter(1, 0, 0);    // Check no packets are still in buffer
 }
 
 TEST_F(BweTestFramework_DelayFilterTest, Delay1) {
   TestDelayFilter(1);
 }
 
 TEST_F(BweTestFramework_DelayFilterTest, Delay2) {
   TestDelayFilter(2);
 }
 
 TEST_F(BweTestFramework_DelayFilterTest, Delay20) {
   TestDelayFilter(20);
 }
 
 TEST_F(BweTestFramework_DelayFilterTest, Delay100) {
   TestDelayFilter(100);
 }
 
 TEST_F(BweTestFramework_DelayFilterTest, JumpToZeroDelay) {
   DelayFilter delay(NULL, 0);
   Packets acc;
   Packets packets;
 
   // Delay a bunch of packets, accumulate them to the 'acc' list.
-  delay.SetDelayMs(100.0f);
+  delay.SetOneWayDelayMs(100.0f);
   for (uint32_t i = 0; i < 10; ++i) {
     packets.push_back(new MediaPacket(i * 100, i));
   }
   delay.RunFor(1000, &packets);
   acc.splice(acc.end(), packets);
   ASSERT_TRUE(IsTimeSorted(acc));
   ASSERT_TRUE(IsSequenceNumberSorted(acc));
 
   // Drop delay to zero, send a few more packets through the delay, append them
   // to the 'acc' list and verify that it is all sorted.
-  delay.SetDelayMs(0.0f);
+  delay.SetOneWayDelayMs(0.0f);
   for (uint32_t i = 10; i < 50; ++i) {
     packets.push_back(new MediaPacket(i * 100, i));
   }
   delay.RunFor(1000, &packets);
   acc.splice(acc.end(), packets);
   ASSERT_TRUE(IsTimeSorted(acc));
   ASSERT_TRUE(IsSequenceNumberSorted(acc));
 
   for (auto* packet : acc)
     delete packet;
 }
 
 TEST_F(BweTestFramework_DelayFilterTest, IncreasingDelay) {
   // Gradually increase delay.
   for (int i = 1; i < 50; i += 4) {
     TestDelayFilter(i);
   }
   // Reach a steady state.
-  filter_.SetDelayMs(100);
+  filter_.SetOneWayDelayMs(100);
   TestDelayFilter(1, 20, 20);
   TestDelayFilter(2, 0, 0);
   TestDelayFilter(99, 20, 20);
   // Drop delay back down to zero.
-  filter_.SetDelayMs(0);
+  filter_.SetOneWayDelayMs(0);
   TestDelayFilter(1, 100, 100);
   TestDelayFilter(23010, 0, 0);
   ASSERT_TRUE(IsTimeSorted(accumulated_packets_));
   ASSERT_TRUE(IsSequenceNumberSorted(accumulated_packets_));
 }
 
 static void TestJitterFilter(int64_t stddev_jitter_ms) {
   JitterFilter filter(NULL, 0);
   filter.SetJitter(stddev_jitter_ms);
 
@@ skipping 172 matching lines @@
     size_t bytes_transmitted = 0;
     while (!output_packets_.empty()) {
       const Packet* packet = output_packets_.front();
       if (packet->send_time_us() > now_ms_ * 1000) {
         break;
       }
       bytes_transmitted += packet->payload_size();
       delete output_packets_.front();
       output_packets_.pop_front();
     }
-    EXPECT_EQ(expected_kbit_transmitted, (bytes_transmitted * 8) / 1000);
+    EXPECT_EQ(expected_kbit_transmitted, (bytes_transmitted * 8 + 500) / 1000);
   }
 
   void CheckMaxDelay(int64_t max_delay_ms) {
     for (const auto* packet : output_packets_) {
       const MediaPacket* media_packet = static_cast<const MediaPacket*>(packet);
       int64_t delay_us = media_packet->send_time_us() -
                          send_times_us_[media_packet->header().sequenceNumber];
       EXPECT_GE(max_delay_ms * 1000, delay_us);
     }
   }
 
  private:
   int64_t now_ms_;
   uint16_t sequence_number_;
   Packets output_packets_;
   std::vector<int64_t> send_times_us_;
 
   DISALLOW_COPY_AND_ASSIGN(BweTestFramework_ChokeFilterTest);
 };
 
 TEST_F(BweTestFramework_ChokeFilterTest, NoQueue) {
   const int kCapacityKbps = 10;
   const size_t kPacketSizeBytes = 125;
   const int64_t kExpectedSendTimeUs =
       (kPacketSizeBytes * 8 * 1000 + kCapacityKbps / 2) / kCapacityKbps;
   uint16_t sequence_number = 0;
   int64_t send_time_us = 0;
   ChokeFilter filter(NULL, 0);
-  filter.SetCapacity(10);
+  filter.set_capacity_kbps(10);
   Packets packets;
   RTPHeader header;
   for (int i = 0; i < 2; ++i) {
     header.sequenceNumber = sequence_number++;
     // Payload is 1000 bits.
     packets.push_back(
         new MediaPacket(0, send_time_us, kPacketSizeBytes, header));
     // Packets are sent far enough a part plus an extra millisecond so that they
     // will never be in the choke queue at the same time.
     send_time_us += kExpectedSendTimeUs + 1000;
   }
   ASSERT_TRUE(IsTimeSorted(packets));
   filter.RunFor(2 * kExpectedSendTimeUs + 1000, &packets);
   EXPECT_EQ(kExpectedSendTimeUs, packets.front()->send_time_us());
   delete packets.front();
   packets.pop_front();
   EXPECT_EQ(2 * kExpectedSendTimeUs + 1000, packets.front()->send_time_us());
   delete packets.front();
   packets.pop_front();
 }
 
 TEST_F(BweTestFramework_ChokeFilterTest, Short) {
   // 100ms, 100 packets, 10 kbps choke -> 1 kbit of data should have propagated.
   // That is actually just a single packet, since each packet has 1000 bits of
   // payload.
   ChokeFilter filter(NULL, 0);
-  filter.SetCapacity(10);
+  filter.set_capacity_kbps(10);
   TestChoke(&filter, 100, 100, 1);
 }
 
 TEST_F(BweTestFramework_ChokeFilterTest, Medium) {
   // 100ms, 10 packets, 10 kbps choke -> 1 packet through, or 1 kbit.
   ChokeFilter filter(NULL, 0);
-  filter.SetCapacity(10);
+  filter.set_capacity_kbps(10);
   TestChoke(&filter, 100, 10, 1);
   // 200ms, no new packets -> another packet through.
   TestChoke(&filter, 100, 0, 1);
   // 1000ms, no new packets -> 8 more packets.
   TestChoke(&filter, 800, 0, 8);
   // 2000ms, no new packets -> queue is empty so no output.
   TestChoke(&filter, 1000, 0, 0);
 }
 
 TEST_F(BweTestFramework_ChokeFilterTest, Long) {
   // 100ms, 100 packets in queue, 10 kbps choke -> 1 packet through, or 1 kbit.
   ChokeFilter filter(NULL, 0);
-  filter.SetCapacity(10);
+  filter.set_capacity_kbps(10);
   TestChoke(&filter, 100, 100, 1);
   // 200ms, no input, another packet through.
   TestChoke(&filter, 100, 0, 1);
   // 1000ms, no input, 8 packets through.
   TestChoke(&filter, 800, 0, 8);
   // 10000ms, no input, raise choke to 100 kbps. Remaining 90 packets in queue
   // should be propagated, for a total of 90 kbps.
-  filter.SetCapacity(100);
+  filter.set_capacity_kbps(100);
   TestChoke(&filter, 9000, 0, 90);
   // 10100ms, 20 more packets -> 10 packets or 10 kbit through.
   TestChoke(&filter, 100, 20, 10);
   // 10300ms, 10 more packets -> 20 packets out.
   TestChoke(&filter, 200, 10, 20);
   // 11300ms, no input, queue should be empty.
-  filter.SetCapacity(10);
+  filter.set_capacity_kbps(10);
   TestChoke(&filter, 1000, 0, 0);
 }
 
 TEST_F(BweTestFramework_ChokeFilterTest, MaxDelay) {
   // 10 kbps choke, 500 ms delay cap
   ChokeFilter filter(NULL, 0);
-  filter.SetCapacity(10);
-  filter.SetMaxDelay(500);
+  filter.set_capacity_kbps(10);
+  filter.set_max_delay_ms(500);
   // 100ms, 100 packets in queue, 10 kbps choke -> 1 packet through, or 1 kbit.
   TestChoke(&filter, 100, 100, 1);
   CheckMaxDelay(500);
   // 500ms, no input, 4 more packets through.
   TestChoke(&filter, 400, 0, 4);
   // 10000ms, no input, remaining packets should have been dropped.
   TestChoke(&filter, 9500, 0, 0);
 
   // 100 ms delay cap
-  filter.SetMaxDelay(100);
+  filter.set_max_delay_ms(100);
   // 10100ms, 50 more packets -> 1 packets or 1 kbit through.
   TestChoke(&filter, 100, 50, 1);
   CheckMaxDelay(100);
   // 20000ms, no input, remaining packets in queue should have been dropped.
   TestChoke(&filter, 9900, 0, 0);
 
   // Reset delay cap (0 is no cap) and verify no packets are dropped.
-  filter.SetCapacity(10);
-  filter.SetMaxDelay(0);
+  filter.set_capacity_kbps(10);
+  filter.set_max_delay_ms(0);
   TestChoke(&filter, 100, 100, 1);
   TestChoke(&filter, 9900, 0, 99);
 }
 
 TEST_F(BweTestFramework_ChokeFilterTest, ShortTrace) {
   // According to the input file 6 packets should be transmitted within
   // 100 milliseconds.
   TraceBasedDeliveryFilter filter(NULL, 0);
   ASSERT_TRUE(filter.Init(test::ResourcePath("synthetic-trace", "rx")));
   TestChoke(&filter, 100, 100, 6);
 }
 
 TEST_F(BweTestFramework_ChokeFilterTest, ShortTraceTwoWraps) {
   // According to the input file 19 packets should be transmitted within
   // 280 milliseconds (at the wrapping point two packets are sent back to back).
   TraceBasedDeliveryFilter filter(NULL, 0);
   ASSERT_TRUE(filter.Init(test::ResourcePath("synthetic-trace", "rx")));
   TestChoke(&filter, 280, 100, 19);
 }
 
 TEST_F(BweTestFramework_ChokeFilterTest, ShortTraceMaxDelay) {
   TraceBasedDeliveryFilter filter(NULL, 0);
-  filter.SetMaxDelay(25);
+  filter.set_max_delay_ms(25);
   ASSERT_TRUE(filter.Init(test::ResourcePath("synthetic-trace", "rx")));
   // Uses all slots up to 110 ms. Several packets are being dropped.
   TestChoke(&filter, 110, 20, 9);
   CheckMaxDelay(25);
   // Simulate enough time for the next slot (at 135 ms) to be used. This makes
   // sure that a slot isn't missed between runs.
   TestChoke(&filter, 25, 1, 1);
 }
 
 void TestVideoSender(VideoSender* sender,
                      int64_t run_for_ms,
                      uint32_t expected_packets,
                      uint32_t expected_payload_size,
                      size_t expected_total_payload_size) {
   assert(sender);
   Packets packets;
   sender->RunFor(run_for_ms, &packets);
   ASSERT_TRUE(IsTimeSorted(packets));
   ASSERT_TRUE(IsSequenceNumberSorted(packets));
   EXPECT_EQ(expected_packets, packets.size());
+
   int64_t send_time_us = -1;
   size_t total_payload_size = 0;
   uint32_t absolute_send_time = 0;
   uint32_t absolute_send_time_wraps = 0;
   uint32_t rtp_timestamp = 0;
   uint32_t rtp_timestamp_wraps = 0;
+
   for (const auto* packet : packets) {
     const MediaPacket* media_packet = static_cast<const MediaPacket*>(packet);
     EXPECT_LE(send_time_us, media_packet->send_time_us());
     send_time_us = media_packet->send_time_us();
     if (sender->source()->max_payload_size_bytes() !=
         media_packet->payload_size()) {
       EXPECT_EQ(expected_payload_size, media_packet->payload_size());
     }
     total_payload_size += media_packet->payload_size();
     if (absolute_send_time >
         media_packet->header().extension.absoluteSendTime) {
       absolute_send_time_wraps++;
     }
     absolute_send_time = media_packet->header().extension.absoluteSendTime;
     if (rtp_timestamp > media_packet->header().timestamp) {
       rtp_timestamp_wraps++;
     }
     rtp_timestamp = media_packet->header().timestamp;
   }
+
   EXPECT_EQ(expected_total_payload_size, total_payload_size);
   EXPECT_GE(1u, absolute_send_time_wraps);
   EXPECT_GE(1u, rtp_timestamp_wraps);
 
   for (auto* packet : packets)
     delete packet;
 }
 
+// Random {-1, 0, +1} ms was added to frame timestamps.
+
 TEST(BweTestFramework_VideoSenderTest, Fps1Kbps80_1s) {
   // 1 fps, 80 kbps
   VideoSource source(0, 1.0f, 80, 0x1234, 0);
   VideoSender sender(NULL, &source, kNullEstimator);
   EXPECT_EQ(80000u, source.bits_per_second());
   // We're at 1 fps, so all packets should be generated on first call, giving 10
   // packets of each 1000 bytes, total 10000 bytes.
   TestVideoSender(&sender, 1, 9, 400, 10000);
-  // 999ms, should see no output here.
-  TestVideoSender(&sender, 998, 0, 0, 0);
-  // 1999ms, should get data for one more frame.
-  TestVideoSender(&sender, 1000, 9, 400, 10000);
-  // 2000ms, one more frame.
-  TestVideoSender(&sender, 1, 9, 400, 10000);
-  // 2999ms, should see nothing.
-  TestVideoSender(&sender, 999, 0, 0, 0);
+  // 998ms, should see no output here.
+  TestVideoSender(&sender, 997, 0, 0, 0);
+  // 1001ms, should get data for one more frame.
+  TestVideoSender(&sender, 3, 9, 400, 10000);
+  // 1998ms, should see no output here.
+  TestVideoSender(&sender, 997, 0, 0, 0);
+  // 2001ms, one more frame.
+  TestVideoSender(&sender, 3, 9, 400, 10000);
+  // 2998ms, should see nothing.
+  TestVideoSender(&sender, 997, 0, 0, 0);
 }
 
 TEST(BweTestFramework_VideoSenderTest, Fps1Kbps80_1s_Offset) {
   // 1 fps, 80 kbps, offset 0.5 of a frame period, ==0.5s in this case.
   VideoSource source(0, 1.0f, 80, 0x1234, 500);
   VideoSender sender(NULL, &source, kNullEstimator);
   EXPECT_EQ(80000u, source.bits_per_second());
-  // 499ms, no output.
-  TestVideoSender(&sender, 499, 0, 0, 0);
-  // 500ms, first frame (this is the offset we set), 10 packets of 1000 bytes.
-  TestVideoSender(&sender, 1, 9, 400, 10000);
-  // 1499ms, nothing.
-  TestVideoSender(&sender, 999, 0, 0, 0);
-  // 1999ms, second frame.
-  TestVideoSender(&sender, 500, 9, 400, 10000);
-  // 2499ms, nothing.
-  TestVideoSender(&sender, 500, 0, 0, 0);
-  // 2500ms, third frame.
-  TestVideoSender(&sender, 1, 9, 400, 10000);
-  // 3499ms, nothing.
-  TestVideoSender(&sender, 999, 0, 0, 0);
+  // 498ms, no output.
+  TestVideoSender(&sender, 498, 0, 0, 0);
+  // 501ms, first frame (this is the offset we set), 10 packets of 1000 bytes.
+  TestVideoSender(&sender, 3, 9, 400, 10000);
+  // 1498ms, nothing.
+  TestVideoSender(&sender, 997, 0, 0, 0);
+  // 1501ms, second frame.
+  TestVideoSender(&sender, 3, 9, 400, 10000);
+  // 2498ms, nothing.
+  TestVideoSender(&sender, 997, 0, 0, 0);
+  // 2501ms, third frame.
+  TestVideoSender(&sender, 3, 9, 400, 10000);
+  // 3498ms, nothing.
+  TestVideoSender(&sender, 997, 0, 0, 0);
 }
 
 TEST(BweTestFramework_VideoSenderTest, Fps50Kpbs80_11s) {
   // 50 fps, 80 kbps.
   VideoSource source(0, 50.0f, 80, 0x1234, 0);
   VideoSender sender(NULL, &source, kNullEstimator);
   EXPECT_EQ(80000u, source.bits_per_second());
-  // 9998ms, should see 500 frames, 200 byte payloads, total 100000 bytes.
-  TestVideoSender(&sender, 9998, 500, 200, 100000);
-  // 9999ms, nothing.
-  TestVideoSender(&sender, 1, 0, 0, 0);
-  // 10000ms, 501st frame as a single packet.
-  TestVideoSender(&sender, 1, 1, 200, 200);
-  // 10998ms, 49 more frames.
-  TestVideoSender(&sender, 998, 49, 200, 9800);
-  // 10999ms, nothing.
-  TestVideoSender(&sender, 1, 0, 0, 0);
+  // 9981, should see 500 frames, 200 byte payloads, total 100000 bytes.
+  TestVideoSender(&sender, 9981, 500, 200, 100000);
+  // 9998ms, nothing.
+  TestVideoSender(&sender, 17, 0, 0, 0);
+  // 10001ms, 501st frame as a single packet.
+  TestVideoSender(&sender, 3, 1, 200, 200);
+  // 10981ms, 49 more frames.
+  TestVideoSender(&sender, 981, 49, 200, 9800);
+  // 10998ms, nothing.
+  TestVideoSender(&sender, 17, 0, 0, 0);
 }
 
-TEST(BweTestFramework_VideoSenderTest, Fps10Kpbs120_1s) {
+TEST(BweTestFramework_VideoSenderTest, Fps20Kpbs120_1s) {
   // 20 fps, 120 kbps.
   VideoSource source(0, 20.0f, 120, 0x1234, 0);
   VideoSender sender(NULL, &source, kNullEstimator);
   EXPECT_EQ(120000u, source.bits_per_second());
-  // 498ms, 10 frames with 750 byte payloads, total 7500 bytes.
-  TestVideoSender(&sender, 498, 10, 750, 7500);
-  // 499ms, nothing.
-  TestVideoSender(&sender, 1, 0, 0, 0);
-  // 500ms, one more frame.
-  TestVideoSender(&sender, 1, 1, 750, 750);
-  // 998ms, 9 more frames.
-  TestVideoSender(&sender, 498, 9, 750, 6750);
-  // 999ms, nothing.
-  TestVideoSender(&sender, 1, 0, 0, 0);
+  // 451ms, 10 frames with 750 byte payloads, total 7500 bytes.
+  TestVideoSender(&sender, 451, 10, 750, 7500);
+  // 498ms, nothing.
+  TestVideoSender(&sender, 47, 0, 0, 0);
+  // 501ms, one more frame.
+  TestVideoSender(&sender, 3, 1, 750, 750);
+  // 951ms, 9 more frames.
+  TestVideoSender(&sender, 450, 9, 750, 6750);
+  // 998ms, nothing.
+  TestVideoSender(&sender, 47, 0, 0, 0);
 }
 
-TEST(BweTestFramework_VideoSenderTest, Fps30Kbps800_20s) {
-  // 20 fps, 820 kbps.
+TEST(BweTestFramework_VideoSenderTest, Fps25Kbps820_20s) {
+  // 25 fps, 820 kbps.
   VideoSource source(0, 25.0f, 820, 0x1234, 0);
   VideoSender sender(NULL, &source, kNullEstimator);
   EXPECT_EQ(820000u, source.bits_per_second());
-  // 9998ms, 250 frames. 820 kbps = 102500 bytes/s, so total should be 1025000.
+  // 9961ms, 250 frames. 820 kbps = 102500 bytes/s, so total should be 1025000.
   // Each frame is 102500/25=4100 bytes, or 5 packets (4 @1000 bytes, 1 @100),
   // so packet count should be 5*250=1250 and last packet of each frame has
   // 100 bytes of payload.
-  TestVideoSender(&sender, 9998, 1000, 500, 1025000);
-  // 9999ms, nothing.
-  TestVideoSender(&sender, 1, 0, 0, 0);
-  // 19998ms, 250 more frames.
-  TestVideoSender(&sender, 9999, 1000, 500, 1025000);
-  // 19999ms, nothing.
-  TestVideoSender(&sender, 1, 0, 0, 0);
-  // 20038ms, one more frame, as described above (25fps == 40ms/frame).
-  TestVideoSender(&sender, 39, 4, 500, 4100);
-  // 20039ms, nothing.
-  TestVideoSender(&sender, 1, 0, 0, 0);
+  TestVideoSender(&sender, 9961, 1000, 500, 1025000);
+  // 9998ms, nothing.
+  TestVideoSender(&sender, 37, 0, 0, 0);
+  // 19961ms, 250 more frames.
+  TestVideoSender(&sender, 9963, 1000, 500, 1025000);
+  // 19998ms, nothing.
+  TestVideoSender(&sender, 37, 0, 0, 0);
+  // 20001ms, one more frame, as described above (25fps == 40ms/frame).
+  TestVideoSender(&sender, 3, 4, 500, 4100);
+  // 20038ms, nothing.
+  TestVideoSender(&sender, 37, 0, 0, 0);
 }
 
 TEST(BweTestFramework_VideoSenderTest, TestAppendInOrder) {
   // 1 fps, 80 kbps, 250ms offset.
   VideoSource source1(0, 1.0f, 80, 0x1234, 250);
   VideoSender sender1(NULL, &source1, kNullEstimator);
   EXPECT_EQ(80000u, source1.bits_per_second());
   Packets packets;
   // Generate some packets, verify they are sorted.
   sender1.RunFor(999, &packets);
@@ skipping 22 matching lines @@
 
   for (auto* packet : packets)
     delete packet;
 }
 
 TEST(BweTestFramework_VideoSenderTest, FeedbackIneffective) {
   VideoSource source(0, 25.0f, 820, 0x1234, 0);
   VideoSender sender(NULL, &source, kNullEstimator);
 
   EXPECT_EQ(820000u, source.bits_per_second());
-  TestVideoSender(&sender, 9998, 1000, 500, 1025000);
+  TestVideoSender(&sender, 9961, 1000, 500, 1025000);
 
   // Make sure feedback has no effect on a regular video sender.
   RembFeedback* feedback = new RembFeedback(0, 0, 0, 512000, RTCPReportBlock());
   Packets packets;
   packets.push_back(feedback);
   sender.RunFor(0, &packets);
   EXPECT_EQ(820000u, source.bits_per_second());
-  TestVideoSender(&sender, 9998, 1000, 500, 1025000);
+  TestVideoSender(&sender, 10000, 1000, 500, 1025000);
 }
 
 TEST(BweTestFramework_AdaptiveVideoSenderTest, FeedbackChangesBitrate) {
   AdaptiveVideoSource source(0, 25.0f, 820, 0x1234, 0);
   VideoSender sender(NULL, &source, kRembEstimator);
   EXPECT_EQ(820000u, source.bits_per_second());
-  TestVideoSender(&sender, 9998, 1000, 500, 1025000);
+  TestVideoSender(&sender, 9961, 1000, 500, 1025000);
 
   // Make sure we can reduce the bitrate.
   RembFeedback* feedback = new RembFeedback(0, 0, 0, 512000, RTCPReportBlock());
   Packets packets;
   packets.push_back(feedback);
   sender.RunFor(0, &packets);
   EXPECT_EQ(512000u, source.bits_per_second());
-  TestVideoSender(&sender, 9998, 750, 160, 640000);
+  TestVideoSender(&sender, 10000, 750, 160, 640000);
 
   // Increase the bitrate to the initial bitrate and verify that the output is
   // the same.
   feedback = new RembFeedback(0, 0, 0, 820000, RTCPReportBlock());
   packets.push_back(feedback);
   sender.RunFor(10000, &packets);
   EXPECT_EQ(820000u, source.bits_per_second());
 
   for (auto* packet : packets)
     delete packet;
 }
 
 TEST(BweTestFramework_AdaptiveVideoSenderTest, Paced_FeedbackChangesBitrate) {
   AdaptiveVideoSource source(0, 25.0f, 820, 0x1234, 0);
   PacedVideoSender sender(NULL, &source, kRembEstimator);
   EXPECT_EQ(820000u, source.bits_per_second());
   TestVideoSender(&sender, 9998, 1000, 500, 1025000);
 
   // Make sure we can reduce the bitrate.
   RembFeedback* feedback = new RembFeedback(0, 1, 0, 512000, RTCPReportBlock());
   Packets packets;
   packets.push_back(feedback);
   sender.RunFor(10000, &packets);
   ASSERT_EQ(512000u, source.bits_per_second());
-  TestVideoSender(&sender, 9998, 750, 160, 640000);
+  TestVideoSender(&sender, 10000, 750, 160, 640000);
 
   // Increase the bitrate to the initial bitrate and verify that the output is
   // the same.
   feedback = new RembFeedback(0, 0, 0, 820000, RTCPReportBlock());
   packets.push_back(feedback);
   sender.RunFor(10000, &packets);
   EXPECT_EQ(820000u, source.bits_per_second());
 
   for (auto* packet : packets)
     delete packet;
 }
 }  // namespace bwe
 }  // namespace testing
 }  // namespace webrtc