1 /* 2 * Copyright (c) 2012 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 "testing/gmock/include/gmock/gmock.h" 12 #include "testing/gtest/include/gtest/gtest.h" 13 14 #include "webrtc/modules/pacing/include/paced_sender.h" 15 #include "webrtc/system_wrappers/interface/clock.h" 16 17 using testing::_; 18 using testing::Return; 19 20 namespace webrtc { 21 namespace test { 22 23 static const int kTargetBitrate = 800; 24 static const float kPaceMultiplier = 1.5f; 25 26 class MockPacedSenderCallback : public PacedSender::Callback { 27 public: 28 MOCK_METHOD4(TimeToSendPacket, 29 bool(uint32_t ssrc, uint16_t sequence_number, int64_t capture_time_ms, 30 bool retransmission)); 31 MOCK_METHOD1(TimeToSendPadding, 32 int(int bytes)); 33 }; 34 35 class PacedSenderPadding : public PacedSender::Callback { 36 public: 37 PacedSenderPadding() : padding_sent_(0) {} 38 39 bool TimeToSendPacket(uint32_t ssrc, uint16_t sequence_number, 40 int64_t capture_time_ms, bool retransmission) { 41 return true; 42 } 43 44 int TimeToSendPadding(int bytes) { 45 const int kPaddingPacketSize = 224; 46 int num_packets = (bytes + kPaddingPacketSize - 1) / kPaddingPacketSize; 47 padding_sent_ += kPaddingPacketSize * num_packets; 48 return kPaddingPacketSize * num_packets; 49 } 50 51 int padding_sent() { return padding_sent_; } 52 53 private: 54 int padding_sent_; 55 }; 56 57 class PacedSenderTest : public ::testing::Test { 58 protected: 59 PacedSenderTest() : clock_(123456) { 60 srand(0); 61 // Need to initialize PacedSender after we initialize clock. 62 send_bucket_.reset( 63 new PacedSender( 64 &clock_, &callback_, kPaceMultiplier * kTargetBitrate, 0)); 65 } 66 67 void SendAndExpectPacket(PacedSender::Priority priority, 68 uint32_t ssrc, uint16_t sequence_number, 69 int64_t capture_time_ms, int size, 70 bool retransmission) { 71 EXPECT_FALSE(send_bucket_->SendPacket(priority, ssrc, 72 sequence_number, capture_time_ms, size, retransmission)); 73 EXPECT_CALL(callback_, TimeToSendPacket( 74 ssrc, sequence_number, capture_time_ms, false)) 75 .Times(1) 76 .WillRepeatedly(Return(true)); 77 } 78 79 SimulatedClock clock_; 80 MockPacedSenderCallback callback_; 81 scoped_ptr<PacedSender> send_bucket_; 82 }; 83 84 TEST_F(PacedSenderTest, QueuePacket) { 85 uint32_t ssrc = 12345; 86 uint16_t sequence_number = 1234; 87 // Due to the multiplicative factor we can send 3 packets not 2 packets. 88 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, 89 clock_.TimeInMilliseconds(), 250, false); 90 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, 91 clock_.TimeInMilliseconds(), 250, false); 92 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, 93 clock_.TimeInMilliseconds(), 250, false); 94 int64_t queued_packet_timestamp = clock_.TimeInMilliseconds(); 95 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc, 96 sequence_number, queued_packet_timestamp, 250, false)); 97 send_bucket_->Process(); 98 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); 99 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); 100 clock_.AdvanceTimeMilliseconds(4); 101 EXPECT_EQ(1, send_bucket_->TimeUntilNextProcess()); 102 clock_.AdvanceTimeMilliseconds(1); 103 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 104 EXPECT_CALL(callback_, TimeToSendPacket( 105 ssrc, sequence_number++, queued_packet_timestamp, false)) 106 .Times(1) 107 .WillRepeatedly(Return(true)); 108 send_bucket_->Process(); 109 sequence_number++; 110 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, 111 clock_.TimeInMilliseconds(), 250, false); 112 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, 113 clock_.TimeInMilliseconds(), 250, false); 114 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc, 115 sequence_number++, clock_.TimeInMilliseconds(), 250, false)); 116 send_bucket_->Process(); 117 } 118 119 TEST_F(PacedSenderTest, PaceQueuedPackets) { 120 uint32_t ssrc = 12345; 121 uint16_t sequence_number = 1234; 122 123 // Due to the multiplicative factor we can send 3 packets not 2 packets. 124 for (int i = 0; i < 3; ++i) { 125 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, 126 clock_.TimeInMilliseconds(), 250, false); 127 } 128 for (int j = 0; j < 30; ++j) { 129 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc, 130 sequence_number++, clock_.TimeInMilliseconds(), 250, false)); 131 } 132 send_bucket_->Process(); 133 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); 134 for (int k = 0; k < 10; ++k) { 135 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); 136 clock_.AdvanceTimeMilliseconds(5); 137 EXPECT_CALL(callback_, 138 TimeToSendPacket(ssrc, _, _, false)) 139 .Times(3) 140 .WillRepeatedly(Return(true)); 141 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 142 EXPECT_EQ(0, send_bucket_->Process()); 143 } 144 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); 145 clock_.AdvanceTimeMilliseconds(5); 146 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 147 EXPECT_EQ(0, send_bucket_->Process()); 148 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, 149 clock_.TimeInMilliseconds(), 250, false); 150 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, 151 clock_.TimeInMilliseconds(), 250, false); 152 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, 153 clock_.TimeInMilliseconds(), 250, false); 154 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc, 155 sequence_number, clock_.TimeInMilliseconds(), 250, false)); 156 send_bucket_->Process(); 157 } 158 159 TEST_F(PacedSenderTest, PaceQueuedPacketsWithDuplicates) { 160 uint32_t ssrc = 12345; 161 uint16_t sequence_number = 1234; 162 uint16_t queued_sequence_number; 163 164 // Due to the multiplicative factor we can send 3 packets not 2 packets. 165 for (int i = 0; i < 3; ++i) { 166 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, 167 clock_.TimeInMilliseconds(), 250, false); 168 } 169 queued_sequence_number = sequence_number; 170 171 for (int j = 0; j < 30; ++j) { 172 // Send in duplicate packets. 173 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc, 174 sequence_number, clock_.TimeInMilliseconds(), 250, false)); 175 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc, 176 sequence_number++, clock_.TimeInMilliseconds(), 250, false)); 177 } 178 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); 179 send_bucket_->Process(); 180 for (int k = 0; k < 10; ++k) { 181 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); 182 clock_.AdvanceTimeMilliseconds(5); 183 184 for (int i = 0; i < 3; ++i) { 185 EXPECT_CALL(callback_, TimeToSendPacket(ssrc, queued_sequence_number++, 186 _, 187 false)) 188 .Times(1) 189 .WillRepeatedly(Return(true)); 190 } 191 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 192 EXPECT_EQ(0, send_bucket_->Process()); 193 } 194 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); 195 clock_.AdvanceTimeMilliseconds(5); 196 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 197 EXPECT_EQ(0, send_bucket_->Process()); 198 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, 199 clock_.TimeInMilliseconds(), 250, false); 200 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, 201 clock_.TimeInMilliseconds(), 250, false); 202 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, 203 clock_.TimeInMilliseconds(), 250, false); 204 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc, 205 sequence_number++, clock_.TimeInMilliseconds(), 250, false)); 206 send_bucket_->Process(); 207 } 208 209 TEST_F(PacedSenderTest, CanQueuePacketsWithSameSequenceNumberOnDifferentSsrcs) { 210 uint32_t ssrc = 12345; 211 uint16_t sequence_number = 1234; 212 213 SendAndExpectPacket(PacedSender::kNormalPriority, 214 ssrc, 215 sequence_number, 216 clock_.TimeInMilliseconds(), 217 250, 218 false); 219 220 // Expect packet on second ssrc to be queued and sent as well. 221 SendAndExpectPacket(PacedSender::kNormalPriority, 222 ssrc + 1, 223 sequence_number, 224 clock_.TimeInMilliseconds(), 225 250, 226 false); 227 228 clock_.AdvanceTimeMilliseconds(1000); 229 send_bucket_->Process(); 230 } 231 232 TEST_F(PacedSenderTest, Padding) { 233 uint32_t ssrc = 12345; 234 uint16_t sequence_number = 1234; 235 236 send_bucket_->UpdateBitrate(kPaceMultiplier * kTargetBitrate, kTargetBitrate); 237 // Due to the multiplicative factor we can send 3 packets not 2 packets. 238 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, 239 clock_.TimeInMilliseconds(), 250, false); 240 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, 241 clock_.TimeInMilliseconds(), 250, false); 242 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, 243 clock_.TimeInMilliseconds(), 250, false); 244 // No padding is expected since we have sent too much already. 245 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); 246 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); 247 clock_.AdvanceTimeMilliseconds(5); 248 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 249 EXPECT_EQ(0, send_bucket_->Process()); 250 251 // 5 milliseconds later we have enough budget to send some padding. 252 EXPECT_CALL(callback_, TimeToSendPadding(250)).Times(1). 253 WillOnce(Return(250)); 254 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); 255 clock_.AdvanceTimeMilliseconds(5); 256 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 257 EXPECT_EQ(0, send_bucket_->Process()); 258 } 259 260 TEST_F(PacedSenderTest, NoPaddingWhenDisabled) { 261 send_bucket_->SetStatus(false); 262 send_bucket_->UpdateBitrate(kPaceMultiplier * kTargetBitrate, kTargetBitrate); 263 // No padding is expected since the pacer is disabled. 264 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); 265 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); 266 clock_.AdvanceTimeMilliseconds(5); 267 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 268 EXPECT_EQ(0, send_bucket_->Process()); 269 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); 270 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); 271 clock_.AdvanceTimeMilliseconds(5); 272 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 273 EXPECT_EQ(0, send_bucket_->Process()); 274 } 275 276 TEST_F(PacedSenderTest, VerifyPaddingUpToBitrate) { 277 uint32_t ssrc = 12345; 278 uint16_t sequence_number = 1234; 279 int64_t capture_time_ms = 56789; 280 const int kTimeStep = 5; 281 const int64_t kBitrateWindow = 100; 282 send_bucket_->UpdateBitrate(kPaceMultiplier * kTargetBitrate, kTargetBitrate); 283 int64_t start_time = clock_.TimeInMilliseconds(); 284 while (clock_.TimeInMilliseconds() - start_time < kBitrateWindow) { 285 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, 286 capture_time_ms, 250, false); 287 clock_.AdvanceTimeMilliseconds(kTimeStep); 288 EXPECT_CALL(callback_, TimeToSendPadding(250)).Times(1). 289 WillOnce(Return(250)); 290 send_bucket_->Process(); 291 } 292 } 293 294 TEST_F(PacedSenderTest, VerifyAverageBitrateVaryingMediaPayload) { 295 uint32_t ssrc = 12345; 296 uint16_t sequence_number = 1234; 297 int64_t capture_time_ms = 56789; 298 const int kTimeStep = 5; 299 const int64_t kBitrateWindow = 10000; 300 PacedSenderPadding callback; 301 send_bucket_.reset( 302 new PacedSender(&clock_, &callback, kPaceMultiplier * kTargetBitrate, 0)); 303 send_bucket_->UpdateBitrate(kPaceMultiplier * kTargetBitrate, kTargetBitrate); 304 int64_t start_time = clock_.TimeInMilliseconds(); 305 int media_bytes = 0; 306 while (clock_.TimeInMilliseconds() - start_time < kBitrateWindow) { 307 int media_payload = rand() % 100 + 200; // [200, 300] bytes. 308 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc, 309 sequence_number++, capture_time_ms, 310 media_payload, false)); 311 media_bytes += media_payload; 312 clock_.AdvanceTimeMilliseconds(kTimeStep); 313 send_bucket_->Process(); 314 } 315 EXPECT_NEAR(kTargetBitrate, 8 * (media_bytes + callback.padding_sent()) / 316 kBitrateWindow, 1); 317 } 318 319 TEST_F(PacedSenderTest, Priority) { 320 uint32_t ssrc_low_priority = 12345; 321 uint32_t ssrc = 12346; 322 uint16_t sequence_number = 1234; 323 int64_t capture_time_ms = 56789; 324 int64_t capture_time_ms_low_priority = 1234567; 325 326 // Due to the multiplicative factor we can send 3 packets not 2 packets. 327 SendAndExpectPacket(PacedSender::kLowPriority, ssrc, sequence_number++, 328 capture_time_ms, 250, false); 329 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, 330 capture_time_ms, 250, false); 331 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, 332 capture_time_ms, 250, false); 333 send_bucket_->Process(); 334 335 // Expect normal and low priority to be queued and high to pass through. 336 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kLowPriority, 337 ssrc_low_priority, sequence_number++, capture_time_ms_low_priority, 250, 338 false)); 339 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, 340 ssrc, sequence_number++, capture_time_ms, 250, false)); 341 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, 342 ssrc, sequence_number++, capture_time_ms, 250, false)); 343 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kHighPriority, 344 ssrc, sequence_number++, capture_time_ms, 250, false)); 345 346 // Expect all high and normal priority to be sent out first. 347 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); 348 EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, capture_time_ms, false)) 349 .Times(3) 350 .WillRepeatedly(Return(true)); 351 352 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); 353 clock_.AdvanceTimeMilliseconds(5); 354 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 355 EXPECT_EQ(0, send_bucket_->Process()); 356 357 EXPECT_CALL(callback_, TimeToSendPacket( 358 ssrc_low_priority, _, capture_time_ms_low_priority, false)) 359 .Times(1) 360 .WillRepeatedly(Return(true)); 361 362 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); 363 clock_.AdvanceTimeMilliseconds(5); 364 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 365 EXPECT_EQ(0, send_bucket_->Process()); 366 } 367 368 TEST_F(PacedSenderTest, Pause) { 369 uint32_t ssrc_low_priority = 12345; 370 uint32_t ssrc = 12346; 371 uint16_t sequence_number = 1234; 372 int64_t capture_time_ms = clock_.TimeInMilliseconds(); 373 374 EXPECT_EQ(0, send_bucket_->QueueInMs()); 375 376 // Due to the multiplicative factor we can send 3 packets not 2 packets. 377 SendAndExpectPacket(PacedSender::kLowPriority, ssrc, sequence_number++, 378 capture_time_ms, 250, false); 379 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, 380 capture_time_ms, 250, false); 381 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, 382 capture_time_ms, 250, false); 383 send_bucket_->Process(); 384 385 send_bucket_->Pause(); 386 387 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, 388 ssrc, sequence_number++, capture_time_ms, 250, false)); 389 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, 390 ssrc, sequence_number++, capture_time_ms, 250, false)); 391 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kHighPriority, 392 ssrc, sequence_number++, capture_time_ms, 250, false)); 393 394 clock_.AdvanceTimeMilliseconds(10000); 395 int64_t second_capture_time_ms = clock_.TimeInMilliseconds(); 396 397 // Expect everything to be queued. 398 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kLowPriority, 399 ssrc_low_priority, sequence_number++, second_capture_time_ms, 250, 400 false)); 401 402 EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms, 403 send_bucket_->QueueInMs()); 404 405 // Expect no packet to come out while paused. 406 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); 407 EXPECT_CALL(callback_, TimeToSendPacket(_, _, _, _)).Times(0); 408 409 for (int i = 0; i < 10; ++i) { 410 clock_.AdvanceTimeMilliseconds(5); 411 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 412 EXPECT_EQ(0, send_bucket_->Process()); 413 } 414 // Expect high prio packets to come out first followed by all packets in the 415 // way they were added. 416 EXPECT_CALL(callback_, TimeToSendPacket(_, _, capture_time_ms, false)) 417 .Times(3) 418 .WillRepeatedly(Return(true)); 419 send_bucket_->Resume(); 420 421 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); 422 clock_.AdvanceTimeMilliseconds(5); 423 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 424 EXPECT_EQ(0, send_bucket_->Process()); 425 426 EXPECT_CALL( 427 callback_, TimeToSendPacket(_, _, second_capture_time_ms, false)) 428 .Times(1) 429 .WillRepeatedly(Return(true)); 430 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); 431 clock_.AdvanceTimeMilliseconds(5); 432 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 433 EXPECT_EQ(0, send_bucket_->Process()); 434 EXPECT_EQ(0, send_bucket_->QueueInMs()); 435 } 436 437 TEST_F(PacedSenderTest, ResendPacket) { 438 uint32_t ssrc = 12346; 439 uint16_t sequence_number = 1234; 440 int64_t capture_time_ms = clock_.TimeInMilliseconds(); 441 EXPECT_EQ(0, send_bucket_->QueueInMs()); 442 443 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, 444 ssrc, 445 sequence_number, 446 capture_time_ms, 447 250, 448 false)); 449 clock_.AdvanceTimeMilliseconds(1); 450 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, 451 ssrc, 452 sequence_number + 1, 453 capture_time_ms + 1, 454 250, 455 false)); 456 clock_.AdvanceTimeMilliseconds(9999); 457 EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms, 458 send_bucket_->QueueInMs()); 459 // Fails to send first packet so only one call. 460 EXPECT_CALL(callback_, TimeToSendPacket( 461 ssrc, sequence_number, capture_time_ms, false)) 462 .Times(1) 463 .WillOnce(Return(false)); 464 clock_.AdvanceTimeMilliseconds(10000); 465 send_bucket_->Process(); 466 467 // Queue remains unchanged. 468 EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms, 469 send_bucket_->QueueInMs()); 470 471 // Fails to send second packet. 472 EXPECT_CALL(callback_, TimeToSendPacket( 473 ssrc, sequence_number, capture_time_ms, false)) 474 .Times(1) 475 .WillOnce(Return(true)); 476 EXPECT_CALL(callback_, TimeToSendPacket( 477 ssrc, sequence_number + 1, capture_time_ms + 1, false)) 478 .Times(1) 479 .WillOnce(Return(false)); 480 clock_.AdvanceTimeMilliseconds(10000); 481 send_bucket_->Process(); 482 483 // Queue is reduced by 1 packet. 484 EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms - 1, 485 send_bucket_->QueueInMs()); 486 487 // Send second packet and queue becomes empty. 488 EXPECT_CALL(callback_, TimeToSendPacket( 489 ssrc, sequence_number + 1, capture_time_ms + 1, false)) 490 .Times(1) 491 .WillOnce(Return(true)); 492 clock_.AdvanceTimeMilliseconds(10000); 493 send_bucket_->Process(); 494 EXPECT_EQ(0, send_bucket_->QueueInMs()); 495 } 496 497 TEST_F(PacedSenderTest, MaxQueueLength) { 498 uint32_t ssrc = 12346; 499 uint16_t sequence_number = 1234; 500 EXPECT_EQ(0, send_bucket_->QueueInMs()); 501 502 send_bucket_->UpdateBitrate(kPaceMultiplier * 30, 0); 503 for (int i = 0; i < 30; ++i) { 504 SendAndExpectPacket(PacedSender::kNormalPriority, 505 ssrc, 506 sequence_number++, 507 clock_.TimeInMilliseconds(), 508 1200, 509 false); 510 } 511 512 clock_.AdvanceTimeMilliseconds(2001); 513 SendAndExpectPacket(PacedSender::kNormalPriority, 514 ssrc, 515 sequence_number++, 516 clock_.TimeInMilliseconds(), 517 1200, 518 false); 519 EXPECT_EQ(2001, send_bucket_->QueueInMs()); 520 send_bucket_->Process(); 521 EXPECT_EQ(0, send_bucket_->QueueInMs()); 522 clock_.AdvanceTimeMilliseconds(31); 523 524 send_bucket_->Process(); 525 } 526 527 TEST_F(PacedSenderTest, QueueTimeGrowsOverTime) { 528 uint32_t ssrc = 12346; 529 uint16_t sequence_number = 1234; 530 EXPECT_EQ(0, send_bucket_->QueueInMs()); 531 532 send_bucket_->UpdateBitrate(kPaceMultiplier * 30, 0); 533 SendAndExpectPacket(PacedSender::kNormalPriority, 534 ssrc, 535 sequence_number, 536 clock_.TimeInMilliseconds(), 537 1200, 538 false); 539 540 clock_.AdvanceTimeMilliseconds(500); 541 EXPECT_EQ(500, send_bucket_->QueueInMs()); 542 send_bucket_->Process(); 543 EXPECT_EQ(0, send_bucket_->QueueInMs()); 544 } 545 } // namespace test 546 } // namespace webrtc 547
