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