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 "testing/gtest/include/gtest/gtest.h" 16#include "webrtc/base/constructormagic.h" 17#include "webrtc/test/testsupport/fileutils.h" 18 19using std::vector; 20 21namespace webrtc { 22namespace testing { 23namespace bwe { 24 25TEST(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 58static 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 70TEST(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 91TEST(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 112TEST(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 125TEST(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 140TEST(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 154TEST(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 172class 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 202TEST_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 208TEST_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 216TEST_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 232static 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 271TEST(BweTestFramework_LossFilterTest, Loss0) { 272 // With 0% loss, the result should be exact (no loss). 273 TestLossFilter(0.0f, true); 274} 275 276TEST(BweTestFramework_LossFilterTest, Loss10) { 277 TestLossFilter(10.0f, false); 278} 279 280TEST(BweTestFramework_LossFilterTest, Loss50) { 281 TestLossFilter(50.0f, false); 282} 283 284TEST(BweTestFramework_LossFilterTest, Loss100) { 285 // With 100% loss, the result should be exact (no packets out). 286 TestLossFilter(100.0f, true); 287} 288 289class 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 371TEST_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 380TEST_F(BweTestFramework_DelayFilterTest, Delay1) { 381 TestDelayFilter(1); 382} 383 384TEST_F(BweTestFramework_DelayFilterTest, Delay2) { 385 TestDelayFilter(2); 386} 387 388TEST_F(BweTestFramework_DelayFilterTest, Delay20) { 389 TestDelayFilter(20); 390} 391 392TEST_F(BweTestFramework_DelayFilterTest, Delay100) { 393 TestDelayFilter(100); 394} 395 396TEST_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 423TEST_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 441static 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 483TEST(BweTestFramework_JitterFilterTest, Jitter0) { 484 TestJitterFilter(0); 485} 486 487TEST(BweTestFramework_JitterFilterTest, Jitter1) { 488 TestJitterFilter(1); 489} 490 491TEST(BweTestFramework_JitterFilterTest, Jitter5) { 492 TestJitterFilter(5); 493} 494 495TEST(BweTestFramework_JitterFilterTest, Jitter10) { 496 TestJitterFilter(10); 497} 498 499TEST(BweTestFramework_JitterFilterTest, Jitter1031) { 500 TestJitterFilter(1031); 501} 502 503static void TestReorderFilter(uint32_t reorder_percent, uint32_t near_value) { 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( 537 ((kPacketCount - 1) * reorder_percent) / 100, distance, near_value); 538} 539 540TEST(BweTestFramework_ReorderFilterTest, Reorder0) { 541 // For 0% reordering, no packets should have been moved, so result is exact. 542 TestReorderFilter(0, 0); 543} 544 545TEST(BweTestFramework_ReorderFilterTest, Reorder10) { 546 TestReorderFilter(10, 30); 547} 548 549TEST(BweTestFramework_ReorderFilterTest, Reorder20) { 550 TestReorderFilter(20, 20); 551} 552 553TEST(BweTestFramework_ReorderFilterTest, Reorder50) { 554 TestReorderFilter(50, 20); 555} 556 557TEST(BweTestFramework_ReorderFilterTest, Reorder70) { 558 TestReorderFilter(70, 20); 559} 560 561TEST(BweTestFramework_ReorderFilterTest, Reorder100) { 562 // Note that because the implementation works by optionally swapping two 563 // adjacent packets, when the likelihood of a swap is 1.0, a swap will always 564 // occur, so the stream will be in order except for the first packet, which 565 // has been moved to the end. Therefore we expect the result to be exact here. 566 TestReorderFilter(100.0, 0); 567} 568 569class BweTestFramework_ChokeFilterTest : public ::testing::Test { 570 public: 571 BweTestFramework_ChokeFilterTest() 572 : now_ms_(0), 573 sequence_number_(0), 574 output_packets_(), 575 send_times_us_() { 576 } 577 virtual ~BweTestFramework_ChokeFilterTest() {} 578 579 protected: 580 void TestChoke(PacketProcessor* filter, 581 int64_t run_for_ms, 582 uint32_t packets_to_generate, 583 uint32_t expected_kbit_transmitted) { 584 // Generate a bunch of packets, apply choke, verify output is ordered. 585 Packets packets; 586 RTPHeader header; 587 for (uint32_t i = 0; i < packets_to_generate; ++i) { 588 int64_t send_time_ms = now_ms_ + (i * run_for_ms) / packets_to_generate; 589 header.sequenceNumber = sequence_number_++; 590 // Payload is 1000 bits. 591 packets.push_back(Packet(0, send_time_ms * 1000, 125, header)); 592 send_times_us_.push_back(send_time_ms * 1000); 593 } 594 ASSERT_TRUE(IsTimeSorted(packets)); 595 filter->RunFor(run_for_ms, &packets); 596 now_ms_ += run_for_ms; 597 output_packets_.splice(output_packets_.end(), packets); 598 ASSERT_TRUE(IsTimeSorted(output_packets_)); 599 ASSERT_TRUE(IsSequenceNumberSorted(output_packets_)); 600 601 // Sum up the transmitted bytes up until the current time. 602 uint32_t bytes_transmitted = 0; 603 while (!output_packets_.empty()) { 604 const Packet& packet = output_packets_.front(); 605 if (packet.send_time_us() > now_ms_ * 1000) { 606 break; 607 } 608 bytes_transmitted += packet.payload_size(); 609 output_packets_.pop_front(); 610 } 611 EXPECT_EQ(expected_kbit_transmitted, (bytes_transmitted * 8) / 1000); 612 } 613 614 void CheckMaxDelay(int64_t max_delay_ms) { 615 for (PacketsIt it = output_packets_.begin(); it != output_packets_.end(); 616 ++it) { 617 const Packet& packet = *it; 618 int64_t delay_us = packet.send_time_us() - 619 send_times_us_[packet.header().sequenceNumber]; 620 EXPECT_GE(max_delay_ms * 1000, delay_us); 621 } 622 } 623 624 private: 625 int64_t now_ms_; 626 uint32_t sequence_number_; 627 Packets output_packets_; 628 std::vector<int64_t> send_times_us_; 629 630 DISALLOW_COPY_AND_ASSIGN(BweTestFramework_ChokeFilterTest); 631}; 632 633TEST_F(BweTestFramework_ChokeFilterTest, Short) { 634 // 100ms, 100 packets, 10 kbps choke -> 1 kbit of data should have propagated. 635 // That is actually just a single packet, since each packet has 1000 bits of 636 // payload. 637 ChokeFilter filter(NULL); 638 filter.SetCapacity(10); 639 TestChoke(&filter, 100, 100, 1); 640} 641 642TEST_F(BweTestFramework_ChokeFilterTest, Medium) { 643 // 100ms, 10 packets, 10 kbps choke -> 1 packet through, or 1 kbit. 644 ChokeFilter filter(NULL); 645 filter.SetCapacity(10); 646 TestChoke(&filter, 100, 10, 1); 647 // 200ms, no new packets -> another packet through. 648 TestChoke(&filter, 100, 0, 1); 649 // 1000ms, no new packets -> 8 more packets. 650 TestChoke(&filter, 800, 0, 8); 651 // 2000ms, no new packets -> queue is empty so no output. 652 TestChoke(&filter, 1000, 0, 0); 653} 654 655TEST_F(BweTestFramework_ChokeFilterTest, Long) { 656 // 100ms, 100 packets in queue, 10 kbps choke -> 1 packet through, or 1 kbit. 657 ChokeFilter filter(NULL); 658 filter.SetCapacity(10); 659 TestChoke(&filter, 100, 100, 1); 660 // 200ms, no input, another packet through. 661 TestChoke(&filter, 100, 0, 1); 662 // 1000ms, no input, 8 packets through. 663 TestChoke(&filter, 800, 0, 8); 664 // 10000ms, no input, raise choke to 100 kbps. Remaining 90 packets in queue 665 // should be propagated, for a total of 90 kbps. 666 filter.SetCapacity(100); 667 TestChoke(&filter, 9000, 0, 90); 668 // 10100ms, 20 more packets -> 10 packets or 10 kbit through. 669 TestChoke(&filter, 100, 20, 10); 670 // 10300ms, 10 more packets -> 20 packets out. 671 TestChoke(&filter, 200, 10, 20); 672 // 11300ms, no input, queue should be empty. 673 filter.SetCapacity(10); 674 TestChoke(&filter, 1000, 0, 0); 675} 676 677TEST_F(BweTestFramework_ChokeFilterTest, MaxDelay) { 678 // 10 kbps choke, 500 ms delay cap 679 ChokeFilter filter(NULL); 680 filter.SetCapacity(10); 681 filter.SetMaxDelay(500); 682 // 100ms, 100 packets in queue, 10 kbps choke -> 1 packet through, or 1 kbit. 683 TestChoke(&filter, 100, 100, 1); 684 CheckMaxDelay(500); 685 // 500ms, no input, 4 more packets through. 686 TestChoke(&filter, 400, 0, 4); 687 // 10000ms, no input, remaining packets should have been dropped. 688 TestChoke(&filter, 9500, 0, 0); 689 690 // 100 ms delay cap 691 filter.SetMaxDelay(100); 692 // 10100ms, 50 more packets -> 2 packets or 2 kbit through. 693 TestChoke(&filter, 100, 50, 2); 694 CheckMaxDelay(100); 695 // 20000ms, no input, remaining packets in queue should have been dropped. 696 TestChoke(&filter, 9900, 0, 0); 697 698 // Reset delay cap (0 is no cap) and verify no packets are dropped. 699 filter.SetCapacity(10); 700 filter.SetMaxDelay(0); 701 TestChoke(&filter, 100, 100, 2); 702 TestChoke(&filter, 9900, 0, 98); 703} 704 705TEST_F(BweTestFramework_ChokeFilterTest, ShortTrace) { 706 // According to the input file 6 packets should be transmitted within 707 // 100 milliseconds. 708 TraceBasedDeliveryFilter filter(NULL); 709 ASSERT_TRUE(filter.Init(test::ResourcePath("synthetic-trace", "rx"))); 710 TestChoke(&filter, 100, 100, 6); 711} 712 713TEST_F(BweTestFramework_ChokeFilterTest, ShortTraceTwoWraps) { 714 // According to the input file 19 packets should be transmitted within 715 // 280 milliseconds (at the wrapping point two packets are sent back to back). 716 TraceBasedDeliveryFilter filter(NULL); 717 ASSERT_TRUE(filter.Init(test::ResourcePath("synthetic-trace", "rx"))); 718 TestChoke(&filter, 280, 100, 19); 719} 720 721TEST_F(BweTestFramework_ChokeFilterTest, ShortTraceMaxDelay) { 722 TraceBasedDeliveryFilter filter(NULL); 723 filter.SetMaxDelay(25); 724 ASSERT_TRUE(filter.Init(test::ResourcePath("synthetic-trace", "rx"))); 725 // Uses all slots up to 110 ms. Several packets are being dropped. 726 TestChoke(&filter, 110, 20, 9); 727 CheckMaxDelay(25); 728 // Simulate enough time for the next slot (at 135 ms) to be used. This makes 729 // sure that a slot isn't missed between runs. 730 TestChoke(&filter, 25, 1, 1); 731} 732 733void TestVideoSender(VideoSender* sender, int64_t run_for_ms, 734 uint32_t expected_packets, 735 uint32_t expected_payload_size, 736 uint32_t expected_total_payload_size) { 737 assert(sender); 738 Packets packets; 739 sender->RunFor(run_for_ms, &packets); 740 ASSERT_TRUE(IsTimeSorted(packets)); 741 ASSERT_TRUE(IsSequenceNumberSorted(packets)); 742 EXPECT_EQ(expected_packets, packets.size()); 743 int64_t send_time_us = -1; 744 uint32_t total_payload_size = 0; 745 uint32_t absolute_send_time = 0; 746 uint32_t absolute_send_time_wraps = 0; 747 uint32_t rtp_timestamp = 0; 748 uint32_t rtp_timestamp_wraps = 0; 749 for (PacketsIt it = packets.begin(); it != packets.end(); ++it) { 750 EXPECT_LE(send_time_us, it->send_time_us()); 751 send_time_us = it->send_time_us(); 752 if (sender->max_payload_size_bytes() != it->payload_size()) { 753 EXPECT_EQ(expected_payload_size, it->payload_size()); 754 } 755 total_payload_size += it->payload_size(); 756 if (absolute_send_time > it->header().extension.absoluteSendTime) { 757 absolute_send_time_wraps++; 758 } 759 absolute_send_time = it->header().extension.absoluteSendTime; 760 if (rtp_timestamp > it->header().timestamp) { 761 rtp_timestamp_wraps++; 762 } 763 rtp_timestamp = it->header().timestamp; 764 } 765 EXPECT_EQ(expected_total_payload_size, total_payload_size); 766 EXPECT_GE(1u, absolute_send_time_wraps); 767 EXPECT_GE(1u, rtp_timestamp_wraps); 768} 769 770TEST(BweTestFramework_VideoSenderTest, Fps1Kbps80_1s) { 771 // 1 fps, 80 kbps 772 VideoSender sender(0, NULL, 1.0f, 80, 0x1234, 0); 773 EXPECT_EQ(10000u, sender.bytes_per_second()); 774 // We're at 1 fps, so all packets should be generated on first call, giving 10 775 // packets of each 1000 bytes, total 10000 bytes. 776 TestVideoSender(&sender, 1, 9, 400, 10000); 777 // 999ms, should see no output here. 778 TestVideoSender(&sender, 998, 0, 0, 0); 779 // 1999ms, should get data for one more frame. 780 TestVideoSender(&sender, 1000, 9, 400, 10000); 781 // 2000ms, one more frame. 782 TestVideoSender(&sender, 1, 9, 400, 10000); 783 // 2999ms, should see nothing. 784 TestVideoSender(&sender, 999, 0, 0, 0); 785} 786 787TEST(BweTestFramework_VideoSenderTest, Fps1Kbps80_1s_Offset) { 788 // 1 fps, 80 kbps, offset 0.5 of a frame period, ==0.5s in this case. 789 VideoSender sender(0, NULL, 1.0f, 80, 0x1234, 0.5f); 790 EXPECT_EQ(10000u, sender.bytes_per_second()); 791 // 499ms, no output. 792 TestVideoSender(&sender, 499, 0, 0, 0); 793 // 500ms, first frame (this is the offset we set), 10 packets of 1000 bytes. 794 TestVideoSender(&sender, 1, 9, 400, 10000); 795 // 1499ms, nothing. 796 TestVideoSender(&sender, 999, 0, 0, 0); 797 // 1999ms, second frame. 798 TestVideoSender(&sender, 500, 9, 400, 10000); 799 // 2499ms, nothing. 800 TestVideoSender(&sender, 500, 0, 0, 0); 801 // 2500ms, third frame. 802 TestVideoSender(&sender, 1, 9, 400, 10000); 803 // 3499ms, nothing. 804 TestVideoSender(&sender, 999, 0, 0, 0); 805} 806 807TEST(BweTestFramework_VideoSenderTest, Fps50Kpbs80_11s) { 808 // 50 fps, 80 kbps. 809 VideoSender sender(0, NULL, 50.0f, 80, 0x1234, 0); 810 EXPECT_EQ(10000u, sender.bytes_per_second()); 811 // 9998ms, should see 500 frames, 200 byte payloads, total 100000 bytes. 812 TestVideoSender(&sender, 9998, 500, 200, 100000); 813 // 9999ms, nothing. 814 TestVideoSender(&sender, 1, 0, 0, 0); 815 // 10000ms, 501st frame as a single packet. 816 TestVideoSender(&sender, 1, 1, 200, 200); 817 // 10998ms, 49 more frames. 818 TestVideoSender(&sender, 998, 49, 200, 9800); 819 // 10999ms, nothing. 820 TestVideoSender(&sender, 1, 0, 0, 0); 821} 822 823TEST(BweTestFramework_VideoSenderTest, Fps10Kpbs120_1s) { 824 // 20 fps, 120 kbps. 825 VideoSender sender(0, NULL, 20.0f, 120, 0x1234, 0); 826 EXPECT_EQ(15000u, sender.bytes_per_second()); 827 // 498ms, 10 frames with 750 byte payloads, total 7500 bytes. 828 TestVideoSender(&sender, 498, 10, 750, 7500); 829 // 499ms, nothing. 830 TestVideoSender(&sender, 1, 0, 0, 0); 831 // 500ms, one more frame. 832 TestVideoSender(&sender, 1, 1, 750, 750); 833 // 998ms, 9 more frames. 834 TestVideoSender(&sender, 498, 9, 750, 6750); 835 // 999ms, nothing. 836 TestVideoSender(&sender, 1, 0, 0, 0); 837} 838 839TEST(BweTestFramework_VideoSenderTest, Fps30Kbps800_20s) { 840 // 20 fps, 820 kbps. 841 VideoSender sender(0, NULL, 25.0f, 820, 0x1234, 0); 842 EXPECT_EQ(102500u, sender.bytes_per_second()); 843 // 9998ms, 250 frames. 820 kbps = 102500 bytes/s, so total should be 1025000. 844 // Each frame is 102500/25=4100 bytes, or 5 packets (4 @1000 bytes, 1 @100), 845 // so packet count should be 5*250=1250 and last packet of each frame has 846 // 100 bytes of payload. 847 TestVideoSender(&sender, 9998, 1000, 500, 1025000); 848 // 9999ms, nothing. 849 TestVideoSender(&sender, 1, 0, 0, 0); 850 // 19998ms, 250 more frames. 851 TestVideoSender(&sender, 9999, 1000, 500, 1025000); 852 // 19999ms, nothing. 853 TestVideoSender(&sender, 1, 0, 0, 0); 854 // 20038ms, one more frame, as described above (25fps == 40ms/frame). 855 TestVideoSender(&sender, 39, 4, 500, 4100); 856 // 20039ms, nothing. 857 TestVideoSender(&sender, 1, 0, 0, 0); 858} 859 860TEST(BweTestFramework_VideoSenderTest, TestAppendInOrder) { 861 // 1 fps, 80 kbps, 250ms offset. 862 VideoSender sender1(0, NULL, 1.0f, 80, 0x1234, 0.25f); 863 EXPECT_EQ(10000u, sender1.bytes_per_second()); 864 Packets packets; 865 // Generate some packets, verify they are sorted. 866 sender1.RunFor(999, &packets); 867 ASSERT_TRUE(IsTimeSorted(packets)); 868 ASSERT_TRUE(IsSequenceNumberSorted(packets)); 869 EXPECT_EQ(9u, packets.size()); 870 // Generate some more packets and verify they are appended to end of list. 871 sender1.RunFor(1000, &packets); 872 ASSERT_TRUE(IsTimeSorted(packets)); 873 ASSERT_TRUE(IsSequenceNumberSorted(packets)); 874 EXPECT_EQ(18u, packets.size()); 875 876 // Another sender, 2 fps, 160 kpbs, 150ms offset 877 VideoSender sender2(0, NULL, 2.0f, 160, 0x2234, 0.30f); 878 EXPECT_EQ(20000u, sender2.bytes_per_second()); 879 // Generate some packets, verify that they are merged with the packets already 880 // on the list. 881 sender2.RunFor(999, &packets); 882 ASSERT_TRUE(IsTimeSorted(packets)); 883 EXPECT_EQ(36u, packets.size()); 884 // Generate some more. 885 sender2.RunFor(1000, &packets); 886 ASSERT_TRUE(IsTimeSorted(packets)); 887 EXPECT_EQ(54u, packets.size()); 888} 889 890TEST(BweTestFramework_VideoSenderTest, FeedbackIneffective) { 891 VideoSender sender(0, NULL, 25.0f, 820, 0x1234, 0); 892 EXPECT_EQ(102500u, sender.bytes_per_second()); 893 TestVideoSender(&sender, 9998, 1000, 500, 1025000); 894 895 // Make sure feedback has no effect on a regular video sender. 896 PacketSender::Feedback feedback = { 512000 }; 897 sender.GiveFeedback(feedback); 898 EXPECT_EQ(102500u, sender.bytes_per_second()); 899 TestVideoSender(&sender, 9998, 1000, 500, 1025000); 900} 901 902TEST(BweTestFramework_AdaptiveVideoSenderTest, FeedbackChangesBitrate) { 903 AdaptiveVideoSender sender(0, NULL, 25.0f, 820, 0x1234, 0); 904 EXPECT_EQ(102500u, sender.bytes_per_second()); 905 TestVideoSender(&sender, 9998, 1000, 500, 1025000); 906 907 // Make sure we can reduce the bitrate. 908 PacketSender::Feedback feedback = { 512000 }; 909 sender.GiveFeedback(feedback); 910 EXPECT_EQ(64000u, sender.bytes_per_second()); 911 TestVideoSender(&sender, 9998, 750, 160, 640000); 912 913 // Increase the bitrate to the initial bitrate and verify that the output is 914 // the same. 915 feedback.estimated_bps = 820000; 916 sender.GiveFeedback(feedback); 917 EXPECT_EQ(102500u, sender.bytes_per_second()); 918 TestVideoSender(&sender, 9998, 1000, 500, 1025000); 919} 920} // namespace bwe 921} // namespace testing 922} // namespace webrtc 923