diff options
Diffstat (limited to 'webrtc/modules/pacing/paced_sender_unittest.cc')
| -rw-r--r-- | webrtc/modules/pacing/paced_sender_unittest.cc | 100 |
1 files changed, 87 insertions, 13 deletions
diff --git a/webrtc/modules/pacing/paced_sender_unittest.cc b/webrtc/modules/pacing/paced_sender_unittest.cc index c27444c5ac..588bf3b669 100644 --- a/webrtc/modules/pacing/paced_sender_unittest.cc +++ b/webrtc/modules/pacing/paced_sender_unittest.cc @@ -12,7 +12,7 @@ #include "testing/gmock/include/gmock/gmock.h" #include "testing/gtest/include/gtest/gtest.h" -#include "webrtc/modules/pacing/include/paced_sender.h" +#include "webrtc/modules/pacing/paced_sender.h" #include "webrtc/system_wrappers/include/clock.h" using testing::_; @@ -471,13 +471,15 @@ TEST_F(PacedSenderTest, Priority) { sequence_number++, capture_time_ms, 250, false); send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, capture_time_ms, 250, false); + send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, + sequence_number++, capture_time_ms, 250, false); send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc, sequence_number++, capture_time_ms, 250, false); // Expect all high and normal priority to be sent out first. EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, capture_time_ms, false)) - .Times(3) + .Times(4) .WillRepeatedly(Return(true)); EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); @@ -497,6 +499,37 @@ TEST_F(PacedSenderTest, Priority) { EXPECT_EQ(0, send_bucket_->Process()); } +TEST_F(PacedSenderTest, HighPrioDoesntAffectBudget) { + uint32_t ssrc = 12346; + uint16_t sequence_number = 1234; + int64_t capture_time_ms = 56789; + + // As high prio packets doesn't affect the budget, we should be able to send + // a high number of them at once. + for (int i = 0; i < 25; ++i) { + SendAndExpectPacket(PacedSender::kHighPriority, ssrc, sequence_number++, + capture_time_ms, 250, false); + } + send_bucket_->Process(); + // Low prio packets does affect the budget, so we should only be able to send + // 3 at once, the 4th should be queued. + for (int i = 0; i < 3; ++i) { + SendAndExpectPacket(PacedSender::kLowPriority, ssrc, sequence_number++, + capture_time_ms, 250, false); + } + send_bucket_->InsertPacket(PacedSender::kLowPriority, ssrc, sequence_number, + capture_time_ms, 250, false); + EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); + clock_.AdvanceTimeMilliseconds(5); + send_bucket_->Process(); + EXPECT_CALL(callback_, + TimeToSendPacket(ssrc, sequence_number++, capture_time_ms, false)) + .Times(1); + EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); + clock_.AdvanceTimeMilliseconds(5); + send_bucket_->Process(); +} + TEST_F(PacedSenderTest, Pause) { uint32_t ssrc_low_priority = 12345; uint32_t ssrc = 12346; @@ -560,20 +593,16 @@ TEST_F(PacedSenderTest, Pause) { EXPECT_CALL(callback_, TimeToSendPacket(_, _, capture_time_ms, false)) .Times(3) .WillRepeatedly(Return(true)); - send_bucket_->Resume(); - - EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); - clock_.AdvanceTimeMilliseconds(5); - EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); - EXPECT_EQ(0, send_bucket_->Process()); - EXPECT_CALL(callback_, TimeToSendPacket(_, _, second_capture_time_ms, false)) .Times(1) .WillRepeatedly(Return(true)); + send_bucket_->Resume(); + EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); clock_.AdvanceTimeMilliseconds(5); EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); EXPECT_EQ(0, send_bucket_->Process()); + EXPECT_EQ(0, send_bucket_->QueueInMs()); } @@ -664,10 +693,9 @@ TEST_F(PacedSenderTest, ExpectedQueueTimeMs) { EXPECT_EQ(0, send_bucket_->ExpectedQueueTimeMs()); - // Allow for aliasing, duration should be in [expected(n - 1), expected(n)]. - EXPECT_LE(duration, queue_in_ms); - EXPECT_GE(duration, - queue_in_ms - static_cast<int64_t>(kPacketSize * 8 / kMaxBitrate)); + // Allow for aliasing, duration should be within one pack of max time limit. + EXPECT_NEAR(duration, PacedSender::kMaxQueueLengthMs, + static_cast<int64_t>(kPacketSize * 8 / kMaxBitrate)); } TEST_F(PacedSenderTest, QueueTimeGrowsOverTime) { @@ -830,5 +858,51 @@ TEST_F(PacedSenderTest, PaddingOveruse) { send_bucket_->Process(); } +TEST_F(PacedSenderTest, AverageQueueTime) { + uint32_t ssrc = 12346; + uint16_t sequence_number = 1234; + const size_t kPacketSize = 1200; + const int kBitrateBps = 10 * kPacketSize * 8; // 10 packets per second. + const int kBitrateKbps = (kBitrateBps + 500) / 1000; + + send_bucket_->UpdateBitrate(kBitrateKbps, kBitrateKbps, kBitrateKbps); + + EXPECT_EQ(0, send_bucket_->AverageQueueTimeMs()); + + int64_t first_capture_time = clock_.TimeInMilliseconds(); + send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, + sequence_number, first_capture_time, kPacketSize, + false); + clock_.AdvanceTimeMilliseconds(10); + send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, + sequence_number + 1, clock_.TimeInMilliseconds(), + kPacketSize, false); + clock_.AdvanceTimeMilliseconds(10); + + EXPECT_EQ((20 + 10) / 2, send_bucket_->AverageQueueTimeMs()); + + // Only first packet (queued for 20ms) should be removed, leave the second + // packet (queued for 10ms) alone in the queue. + EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number, + first_capture_time, false)) + .Times(1) + .WillRepeatedly(Return(true)); + send_bucket_->Process(); + + EXPECT_EQ(10, send_bucket_->AverageQueueTimeMs()); + + clock_.AdvanceTimeMilliseconds(10); + EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number + 1, + first_capture_time + 10, false)) + .Times(1) + .WillRepeatedly(Return(true)); + for (int i = 0; i < 3; ++i) { + clock_.AdvanceTimeMilliseconds(30); // Max delta. + send_bucket_->Process(); + } + + EXPECT_EQ(0, send_bucket_->AverageQueueTimeMs()); +} + } // namespace test } // namespace webrtc |