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/base/constructormagic.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 922