probe_controller_unittest.cc (64729B)
1 /* 2 * Copyright (c) 2016 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 #include "modules/congestion_controller/goog_cc/probe_controller.h" 11 12 #include <memory> 13 #include <optional> 14 #include <vector> 15 16 #include "absl/strings/string_view.h" 17 #include "api/field_trials.h" 18 #include "api/transport/network_types.h" 19 #include "api/units/data_rate.h" 20 #include "api/units/time_delta.h" 21 #include "api/units/timestamp.h" 22 #include "logging/rtc_event_log/mock/mock_rtc_event_log.h" 23 #include "system_wrappers/include/clock.h" 24 #include "test/create_test_field_trials.h" 25 #include "test/gmock.h" 26 #include "test/gtest.h" 27 28 using ::testing::Gt; 29 using ::testing::IsEmpty; 30 using ::testing::NiceMock; 31 using ::testing::SizeIs; 32 33 namespace webrtc { 34 namespace test { 35 36 namespace { 37 38 constexpr DataRate kMinBitrate = DataRate::BitsPerSec(100); 39 constexpr DataRate kStartBitrate = DataRate::BitsPerSec(300); 40 constexpr DataRate kMaxBitrate = DataRate::BitsPerSec(10000); 41 constexpr DataRate kMbpsMultiplier = DataRate::KilobitsPerSec(1000); 42 43 constexpr TimeDelta kExponentialProbingTimeout = TimeDelta::Seconds(5); 44 45 constexpr TimeDelta kAlrProbeInterval = TimeDelta::Seconds(5); 46 constexpr TimeDelta kAlrEndedTimeout = TimeDelta::Seconds(3); 47 constexpr TimeDelta kBitrateDropTimeout = TimeDelta::Seconds(5); 48 } // namespace 49 50 class ProbeControllerFixture { 51 public: 52 explicit ProbeControllerFixture(absl::string_view field_trials = "") 53 : field_trial_config_(CreateTestFieldTrials(field_trials)), 54 clock_(100000000L) {} 55 56 std::unique_ptr<ProbeController> CreateController() { 57 return std::make_unique<ProbeController>(&field_trial_config_, 58 &mock_rtc_event_log); 59 } 60 61 Timestamp CurrentTime() { return clock_.CurrentTime(); } 62 void AdvanceTime(TimeDelta delta) { clock_.AdvanceTime(delta); } 63 64 FieldTrials field_trial_config_; 65 SimulatedClock clock_; 66 NiceMock<MockRtcEventLog> mock_rtc_event_log; 67 }; 68 69 TEST(ProbeControllerTest, InitiatesProbingAfterSetBitrates) { 70 ProbeControllerFixture fixture; 71 std::unique_ptr<ProbeController> probe_controller = 72 fixture.CreateController(); 73 ASSERT_THAT( 74 probe_controller->OnNetworkAvailability({.network_available = true}), 75 IsEmpty()); 76 77 auto probes = probe_controller->SetBitrates( 78 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 79 EXPECT_GE(probes.size(), 2u); 80 } 81 82 TEST(ProbeControllerTest, InitiatesProbingWhenNetworkAvailable) { 83 ProbeControllerFixture fixture; 84 std::unique_ptr<ProbeController> probe_controller = 85 fixture.CreateController(); 86 87 std::vector<ProbeClusterConfig> probes = probe_controller->SetBitrates( 88 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 89 EXPECT_THAT(probes, IsEmpty()); 90 probes = probe_controller->OnNetworkAvailability({.network_available = true}); 91 EXPECT_GE(probes.size(), 2u); 92 } 93 94 TEST(ProbeControllerTest, SetsDefaultTargetDurationAndTargetProbeCount) { 95 ProbeControllerFixture fixture; 96 std::unique_ptr<ProbeController> probe_controller = 97 fixture.CreateController(); 98 ASSERT_THAT( 99 probe_controller->OnNetworkAvailability({.network_available = true}), 100 IsEmpty()); 101 std::vector<ProbeClusterConfig> probes = probe_controller->SetBitrates( 102 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 103 ASSERT_GE(probes.size(), 2u); 104 105 EXPECT_EQ(probes[0].target_duration, TimeDelta::Millis(15)); 106 EXPECT_EQ(probes[0].target_probe_count, 5); 107 } 108 109 TEST(ProbeControllerTest, 110 FieldTrialsOverrideDefaultTargetDurationAndTargetProbeCount) { 111 ProbeControllerFixture fixture( 112 "WebRTC-Bwe-ProbingBehavior/" 113 "min_probe_packets_sent:2,min_probe_duration:123ms/"); 114 std::unique_ptr<ProbeController> probe_controller = 115 fixture.CreateController(); 116 ASSERT_THAT( 117 probe_controller->OnNetworkAvailability({.network_available = true}), 118 IsEmpty()); 119 std::vector<ProbeClusterConfig> probes = probe_controller->SetBitrates( 120 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 121 ASSERT_GE(probes.size(), 2u); 122 123 EXPECT_EQ(probes[0].target_duration, TimeDelta::Millis(123)); 124 EXPECT_EQ(probes[0].target_probe_count, 2); 125 } 126 127 TEST(ProbeControllerTest, ProbeOnlyWhenNetworkIsUp) { 128 ProbeControllerFixture fixture; 129 std::unique_ptr<ProbeController> probe_controller = 130 fixture.CreateController(); 131 auto probes = probe_controller->OnNetworkAvailability( 132 {.at_time = fixture.CurrentTime(), .network_available = false}); 133 probes = probe_controller->SetBitrates(kMinBitrate, kStartBitrate, 134 kMaxBitrate, fixture.CurrentTime()); 135 EXPECT_TRUE(probes.empty()); 136 probes = probe_controller->OnNetworkAvailability( 137 {.at_time = fixture.CurrentTime(), .network_available = true}); 138 EXPECT_GE(probes.size(), 2u); 139 } 140 141 TEST(ProbeControllerTest, CanConfigureInitialProbeRateFactor) { 142 ProbeControllerFixture fixture("WebRTC-Bwe-ProbingConfiguration/p1:2,p2:3/"); 143 std::unique_ptr<ProbeController> probe_controller = 144 fixture.CreateController(); 145 ASSERT_THAT( 146 probe_controller->OnNetworkAvailability({.network_available = true}), 147 IsEmpty()); 148 auto probes = probe_controller->SetBitrates( 149 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 150 EXPECT_EQ(probes.size(), 2u); 151 EXPECT_EQ(probes[0].target_data_rate, kStartBitrate * 2); 152 EXPECT_EQ(probes[1].target_data_rate, kStartBitrate * 3); 153 } 154 155 TEST(ProbeControllerTest, DisableSecondInitialProbeIfRateFactorZero) { 156 ProbeControllerFixture fixture("WebRTC-Bwe-ProbingConfiguration/p1:2,p2:0/"); 157 std::unique_ptr<ProbeController> probe_controller = 158 fixture.CreateController(); 159 ASSERT_THAT( 160 probe_controller->OnNetworkAvailability({.network_available = true}), 161 IsEmpty()); 162 auto probes = probe_controller->SetBitrates( 163 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 164 EXPECT_EQ(probes.size(), 1u); 165 EXPECT_EQ(probes[0].target_data_rate, kStartBitrate * 2); 166 } 167 168 TEST(ProbeControllerTest, InitiatesProbingOnMaxBitrateIncrease) { 169 ProbeControllerFixture fixture; 170 std::unique_ptr<ProbeController> probe_controller = 171 fixture.CreateController(); 172 ASSERT_THAT( 173 probe_controller->OnNetworkAvailability({.network_available = true}), 174 IsEmpty()); 175 auto probes = probe_controller->SetBitrates( 176 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 177 // Long enough to time out exponential probing. 178 fixture.AdvanceTime(kExponentialProbingTimeout); 179 probes = probe_controller->SetEstimatedBitrate( 180 kStartBitrate, BandwidthLimitedCause::kDelayBasedLimited, 181 fixture.CurrentTime()); 182 probes = probe_controller->Process(fixture.CurrentTime()); 183 probes = probe_controller->SetBitrates( 184 kMinBitrate, kStartBitrate, kMaxBitrate + DataRate::BitsPerSec(100), 185 fixture.CurrentTime()); 186 EXPECT_EQ(probes.size(), 1u); 187 EXPECT_EQ(probes[0].target_data_rate.bps(), kMaxBitrate.bps() + 100); 188 } 189 190 TEST(ProbeControllerTest, ProbesOnMaxAllocatedBitrateIncreaseOnlyWhenInAlr) { 191 ProbeControllerFixture fixture; 192 std::unique_ptr<ProbeController> probe_controller = 193 fixture.CreateController(); 194 ASSERT_THAT( 195 probe_controller->OnNetworkAvailability({.network_available = true}), 196 IsEmpty()); 197 auto probes = probe_controller->SetBitrates( 198 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 199 probes = probe_controller->SetEstimatedBitrate( 200 kMaxBitrate - DataRate::BitsPerSec(1), 201 BandwidthLimitedCause::kDelayBasedLimited, fixture.CurrentTime()); 202 203 // Wait long enough to time out exponential probing. 204 fixture.AdvanceTime(kExponentialProbingTimeout); 205 probes = probe_controller->Process(fixture.CurrentTime()); 206 EXPECT_TRUE(probes.empty()); 207 208 // Probe when in alr. 209 probe_controller->SetAlrStartTime(fixture.CurrentTime()); 210 probes = probe_controller->OnMaxTotalAllocatedBitrate( 211 kMaxBitrate + DataRate::BitsPerSec(1), fixture.CurrentTime()); 212 EXPECT_EQ(probes.size(), 2u); 213 EXPECT_EQ(probes.at(0).target_data_rate, kMaxBitrate); 214 215 // Do not probe when not in alr. 216 probe_controller->SetAlrStartTime(std::nullopt); 217 probes = probe_controller->OnMaxTotalAllocatedBitrate( 218 kMaxBitrate + DataRate::BitsPerSec(2), fixture.CurrentTime()); 219 EXPECT_TRUE(probes.empty()); 220 } 221 222 TEST(ProbeControllerTest, ProbesOnMaxAllocatedBitrateLimitedByCurrentBwe) { 223 ProbeControllerFixture fixture(""); 224 225 ASSERT_TRUE(kMaxBitrate > 1.5 * kStartBitrate); 226 std::unique_ptr<ProbeController> probe_controller = 227 fixture.CreateController(); 228 ASSERT_THAT( 229 probe_controller->OnNetworkAvailability({.network_available = true}), 230 IsEmpty()); 231 auto probes = probe_controller->SetBitrates( 232 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 233 probes = probe_controller->SetEstimatedBitrate( 234 kStartBitrate, BandwidthLimitedCause::kDelayBasedLimited, 235 fixture.CurrentTime()); 236 237 // Wait long enough to time out exponential probing. 238 fixture.AdvanceTime(kExponentialProbingTimeout); 239 probes = probe_controller->Process(fixture.CurrentTime()); 240 EXPECT_TRUE(probes.empty()); 241 242 // Probe when in alr. 243 probe_controller->SetAlrStartTime(fixture.CurrentTime()); 244 probes = probe_controller->OnMaxTotalAllocatedBitrate(kMaxBitrate, 245 fixture.CurrentTime()); 246 EXPECT_EQ(probes.size(), 1u); 247 EXPECT_EQ(probes.at(0).target_data_rate, 2.0 * kStartBitrate); 248 249 // Continue probing if probe succeeds. 250 probes = probe_controller->SetEstimatedBitrate( 251 1.5 * kStartBitrate, BandwidthLimitedCause::kDelayBasedLimited, 252 fixture.CurrentTime()); 253 EXPECT_EQ(probes.size(), 1u); 254 EXPECT_GT(probes.at(0).target_data_rate, 1.5 * kStartBitrate); 255 } 256 257 TEST(ProbeControllerTest, CanDisableProbingOnMaxTotalAllocatedBitrateIncrease) { 258 ProbeControllerFixture fixture( 259 "WebRTC-Bwe-ProbingConfiguration/" 260 "probe_max_allocation:false/"); 261 std::unique_ptr<ProbeController> probe_controller = 262 fixture.CreateController(); 263 ASSERT_THAT( 264 probe_controller->OnNetworkAvailability({.network_available = true}), 265 IsEmpty()); 266 auto probes = probe_controller->SetBitrates( 267 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 268 probes = probe_controller->SetEstimatedBitrate( 269 kMaxBitrate - DataRate::BitsPerSec(1), 270 BandwidthLimitedCause::kDelayBasedLimited, fixture.CurrentTime()); 271 fixture.AdvanceTime(kExponentialProbingTimeout); 272 probes = probe_controller->Process(fixture.CurrentTime()); 273 ASSERT_TRUE(probes.empty()); 274 probe_controller->SetAlrStartTime(fixture.CurrentTime()); 275 276 // Do no probe, since probe_max_allocation:false. 277 probe_controller->SetAlrStartTime(fixture.CurrentTime()); 278 probes = probe_controller->OnMaxTotalAllocatedBitrate( 279 kMaxBitrate + DataRate::BitsPerSec(1), fixture.CurrentTime()); 280 EXPECT_TRUE(probes.empty()); 281 } 282 283 TEST(ProbeControllerTest, InitiatesProbingOnMaxBitrateIncreaseAtMaxBitrate) { 284 ProbeControllerFixture fixture; 285 std::unique_ptr<ProbeController> probe_controller = 286 fixture.CreateController(); 287 ASSERT_THAT( 288 probe_controller->OnNetworkAvailability({.network_available = true}), 289 IsEmpty()); 290 auto probes = probe_controller->SetBitrates( 291 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 292 // Long enough to time out exponential probing. 293 fixture.AdvanceTime(kExponentialProbingTimeout); 294 probes = probe_controller->SetEstimatedBitrate( 295 kStartBitrate, BandwidthLimitedCause::kDelayBasedLimited, 296 fixture.CurrentTime()); 297 probes = probe_controller->Process(fixture.CurrentTime()); 298 probes = probe_controller->SetEstimatedBitrate( 299 kMaxBitrate, BandwidthLimitedCause::kDelayBasedLimited, 300 fixture.CurrentTime()); 301 probes = probe_controller->SetBitrates( 302 kMinBitrate, kStartBitrate, kMaxBitrate + DataRate::BitsPerSec(100), 303 fixture.CurrentTime()); 304 EXPECT_EQ(probes.size(), 1u); 305 EXPECT_EQ(probes[0].target_data_rate, 306 kMaxBitrate + DataRate::BitsPerSec(100)); 307 } 308 309 TEST(ProbeControllerTest, TestExponentialProbing) { 310 ProbeControllerFixture fixture; 311 std::unique_ptr<ProbeController> probe_controller = 312 fixture.CreateController(); 313 ASSERT_THAT( 314 probe_controller->OnNetworkAvailability({.network_available = true}), 315 IsEmpty()); 316 auto probes = probe_controller->SetBitrates( 317 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 318 319 // Repeated probe should only be sent when estimated bitrate climbs above 320 // 0.7 * 6 * kStartBitrate = 1260. 321 probes = probe_controller->SetEstimatedBitrate( 322 DataRate::BitsPerSec(1000), BandwidthLimitedCause::kDelayBasedLimited, 323 fixture.CurrentTime()); 324 EXPECT_TRUE(probes.empty()); 325 326 probes = probe_controller->SetEstimatedBitrate( 327 DataRate::BitsPerSec(1800), BandwidthLimitedCause::kDelayBasedLimited, 328 fixture.CurrentTime()); 329 EXPECT_EQ(probes.size(), 1u); 330 EXPECT_EQ(probes[0].target_data_rate.bps(), 2 * 1800); 331 } 332 333 TEST(ProbeControllerTest, ExponentialProbingStopIfMaxBitrateLow) { 334 ProbeControllerFixture fixture( 335 "WebRTC-Bwe-ProbingConfiguration/abort_further:true/"); 336 std::unique_ptr<ProbeController> probe_controller = 337 fixture.CreateController(); 338 ASSERT_THAT( 339 probe_controller->OnNetworkAvailability({.network_available = true}), 340 IsEmpty()); 341 auto probes = probe_controller->SetBitrates( 342 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 343 ASSERT_THAT(probes, SizeIs(Gt(0))); 344 345 // Repeated probe normally is sent when estimated bitrate climbs above 346 // 0.7 * 6 * kStartBitrate = 1260. But since max bitrate is low, expect 347 // exponential probing to stop. 348 probes = probe_controller->SetBitrates(kMinBitrate, kStartBitrate, 349 /*max_bitrate=*/kStartBitrate, 350 fixture.CurrentTime()); 351 EXPECT_THAT(probes, IsEmpty()); 352 353 probes = probe_controller->SetEstimatedBitrate( 354 DataRate::BitsPerSec(1800), BandwidthLimitedCause::kDelayBasedLimited, 355 fixture.CurrentTime()); 356 EXPECT_THAT(probes, IsEmpty()); 357 } 358 359 TEST(ProbeControllerTest, ExponentialProbingStopIfMaxAllocatedBitrateLow) { 360 ProbeControllerFixture fixture( 361 "WebRTC-Bwe-ProbingConfiguration/abort_further:true/"); 362 std::unique_ptr<ProbeController> probe_controller = 363 fixture.CreateController(); 364 ASSERT_THAT( 365 probe_controller->OnNetworkAvailability({.network_available = true}), 366 IsEmpty()); 367 auto probes = probe_controller->SetBitrates( 368 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 369 ASSERT_THAT(probes, SizeIs(Gt(0))); 370 371 // Repeated probe normally is sent when estimated bitrate climbs above 372 // 0.7 * 6 * kStartBitrate = 1260. But since allocated bitrate i slow, expect 373 // exponential probing to stop. 374 probes = probe_controller->OnMaxTotalAllocatedBitrate(kStartBitrate, 375 fixture.CurrentTime()); 376 EXPECT_THAT(probes, IsEmpty()); 377 378 probes = probe_controller->SetEstimatedBitrate( 379 DataRate::BitsPerSec(1800), BandwidthLimitedCause::kDelayBasedLimited, 380 fixture.CurrentTime()); 381 EXPECT_THAT(probes, IsEmpty()); 382 } 383 384 TEST(ProbeControllerTest, InitialProbingToLowMaxAllocatedbitrate) { 385 ProbeControllerFixture fixture; 386 std::unique_ptr<ProbeController> probe_controller = 387 fixture.CreateController(); 388 ASSERT_THAT( 389 probe_controller->OnNetworkAvailability({.network_available = true}), 390 IsEmpty()); 391 auto probes = probe_controller->SetBitrates( 392 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 393 ASSERT_THAT(probes, SizeIs(Gt(0))); 394 395 // Repeated probe is sent when estimated bitrate climbs above 396 // 0.7 * 6 * kStartBitrate = 1260. 397 probes = probe_controller->OnMaxTotalAllocatedBitrate(kStartBitrate, 398 fixture.CurrentTime()); 399 EXPECT_THAT(probes, IsEmpty()); 400 401 // If the inital probe result is received, a new probe is sent at 2x the 402 // needed max bitrate. 403 probes = probe_controller->SetEstimatedBitrate( 404 DataRate::BitsPerSec(1800), BandwidthLimitedCause::kDelayBasedLimited, 405 fixture.CurrentTime()); 406 ASSERT_EQ(probes.size(), 1u); 407 EXPECT_EQ(probes[0].target_data_rate.bps(), 2 * kStartBitrate.bps()); 408 } 409 410 TEST(ProbeControllerTest, InitialProbingTimeout) { 411 ProbeControllerFixture fixture; 412 std::unique_ptr<ProbeController> probe_controller = 413 fixture.CreateController(); 414 ASSERT_THAT( 415 probe_controller->OnNetworkAvailability({.network_available = true}), 416 IsEmpty()); 417 auto probes = probe_controller->SetBitrates( 418 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 419 EXPECT_THAT(probes, SizeIs(Gt(0))); 420 // Advance far enough to cause a time out in waiting for probing result. 421 fixture.AdvanceTime(kExponentialProbingTimeout); 422 probes = probe_controller->Process(fixture.CurrentTime()); 423 EXPECT_THAT(probes, IsEmpty()); 424 probes = probe_controller->SetEstimatedBitrate( 425 DataRate::BitsPerSec(1800), BandwidthLimitedCause::kDelayBasedLimited, 426 fixture.CurrentTime()); 427 EXPECT_THAT(probes, IsEmpty()); 428 } 429 430 TEST(ProbeControllerTest, RepeatedInitialProbingSendsNewProbeAfterTimeout) { 431 ProbeControllerFixture fixture; 432 std::unique_ptr<ProbeController> probe_controller = 433 fixture.CreateController(); 434 probe_controller->EnableRepeatedInitialProbing(true); 435 ASSERT_THAT( 436 probe_controller->OnNetworkAvailability({.network_available = true}), 437 IsEmpty()); 438 auto probes = probe_controller->SetBitrates( 439 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 440 EXPECT_THAT(probes, SizeIs(Gt(0))); 441 Timestamp start_time = fixture.CurrentTime(); 442 Timestamp last_probe_time = fixture.CurrentTime(); 443 while (fixture.CurrentTime() < start_time + TimeDelta::Seconds(5)) { 444 fixture.AdvanceTime(TimeDelta::Millis(100)); 445 probes = probe_controller->Process(fixture.CurrentTime()); 446 if (!probes.empty()) { 447 // Expect a probe every second. 448 EXPECT_EQ(fixture.CurrentTime() - last_probe_time, 449 TimeDelta::Seconds(1.1)); 450 EXPECT_EQ(probes[0].min_probe_delta, TimeDelta::Millis(20)); 451 EXPECT_EQ(probes[0].target_duration, TimeDelta::Millis(100)); 452 last_probe_time = fixture.CurrentTime(); 453 } else { 454 EXPECT_LT(fixture.CurrentTime() - last_probe_time, 455 TimeDelta::Seconds(1.1)); 456 } 457 } 458 fixture.AdvanceTime(TimeDelta::Seconds(1)); 459 // After 5s, repeated initial probing stops. 460 EXPECT_THAT(probe_controller->Process(fixture.CurrentTime()), IsEmpty()); 461 } 462 463 TEST(ProbeControllerTest, RepeatedInitialProbingStopIfMaxAllocatedBitrateSet) { 464 ProbeControllerFixture fixture; 465 std::unique_ptr<ProbeController> probe_controller = 466 fixture.CreateController(); 467 probe_controller->EnableRepeatedInitialProbing(true); 468 ASSERT_THAT( 469 probe_controller->OnNetworkAvailability({.network_available = true}), 470 IsEmpty()); 471 auto probes = probe_controller->SetBitrates( 472 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 473 EXPECT_THAT(probes, SizeIs(Gt(0))); 474 475 fixture.AdvanceTime(TimeDelta::Millis(1100)); 476 probes = probe_controller->Process(fixture.CurrentTime()); 477 EXPECT_THAT(probes, SizeIs(1)); 478 probes = probe_controller->OnMaxTotalAllocatedBitrate(kMinBitrate, 479 fixture.CurrentTime()); 480 fixture.AdvanceTime(TimeDelta::Millis(1100)); 481 probes = probe_controller->Process(fixture.CurrentTime()); 482 EXPECT_THAT(probes, IsEmpty()); 483 } 484 485 TEST(ProbeControllerTest, RequestProbeInAlr) { 486 ProbeControllerFixture fixture; 487 std::unique_ptr<ProbeController> probe_controller = 488 fixture.CreateController(); 489 ASSERT_THAT( 490 probe_controller->OnNetworkAvailability({.network_available = true}), 491 IsEmpty()); 492 auto probes = probe_controller->SetBitrates( 493 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 494 EXPECT_GE(probes.size(), 2u); 495 probes = probe_controller->SetEstimatedBitrate( 496 DataRate::BitsPerSec(500), BandwidthLimitedCause::kDelayBasedLimited, 497 fixture.CurrentTime()); 498 499 probe_controller->SetAlrStartTime(fixture.CurrentTime()); 500 fixture.AdvanceTime(kAlrProbeInterval + TimeDelta::Millis(1)); 501 probes = probe_controller->Process(fixture.CurrentTime()); 502 probes = probe_controller->SetEstimatedBitrate( 503 DataRate::BitsPerSec(250), BandwidthLimitedCause::kDelayBasedLimited, 504 fixture.CurrentTime()); 505 probes = probe_controller->RequestProbe(fixture.CurrentTime()); 506 507 EXPECT_EQ(probes.size(), 1u); 508 EXPECT_EQ(probes[0].target_data_rate.bps(), 0.85 * 500); 509 } 510 511 TEST(ProbeControllerTest, RequestProbeWhenAlrEndedRecently) { 512 ProbeControllerFixture fixture; 513 std::unique_ptr<ProbeController> probe_controller = 514 fixture.CreateController(); 515 ASSERT_THAT( 516 probe_controller->OnNetworkAvailability({.network_available = true}), 517 IsEmpty()); 518 auto probes = probe_controller->SetBitrates( 519 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 520 EXPECT_EQ(probes.size(), 2u); 521 probes = probe_controller->SetEstimatedBitrate( 522 DataRate::BitsPerSec(500), BandwidthLimitedCause::kDelayBasedLimited, 523 fixture.CurrentTime()); 524 525 probe_controller->SetAlrStartTime(std::nullopt); 526 fixture.AdvanceTime(kAlrProbeInterval + TimeDelta::Millis(1)); 527 probes = probe_controller->Process(fixture.CurrentTime()); 528 probes = probe_controller->SetEstimatedBitrate( 529 DataRate::BitsPerSec(250), BandwidthLimitedCause::kDelayBasedLimited, 530 fixture.CurrentTime()); 531 probe_controller->SetAlrEndedTime(fixture.CurrentTime()); 532 fixture.AdvanceTime(kAlrEndedTimeout - TimeDelta::Millis(1)); 533 probes = probe_controller->RequestProbe(fixture.CurrentTime()); 534 535 EXPECT_EQ(probes.size(), 1u); 536 EXPECT_EQ(probes[0].target_data_rate.bps(), 0.85 * 500); 537 } 538 539 TEST(ProbeControllerTest, RequestProbeWhenAlrNotEndedRecently) { 540 ProbeControllerFixture fixture; 541 std::unique_ptr<ProbeController> probe_controller = 542 fixture.CreateController(); 543 ASSERT_THAT( 544 probe_controller->OnNetworkAvailability({.network_available = true}), 545 IsEmpty()); 546 auto probes = probe_controller->SetBitrates( 547 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 548 EXPECT_EQ(probes.size(), 2u); 549 probes = probe_controller->SetEstimatedBitrate( 550 DataRate::BitsPerSec(500), BandwidthLimitedCause::kDelayBasedLimited, 551 fixture.CurrentTime()); 552 553 probe_controller->SetAlrStartTime(std::nullopt); 554 fixture.AdvanceTime(kAlrProbeInterval + TimeDelta::Millis(1)); 555 probes = probe_controller->Process(fixture.CurrentTime()); 556 probes = probe_controller->SetEstimatedBitrate( 557 DataRate::BitsPerSec(250), BandwidthLimitedCause::kDelayBasedLimited, 558 fixture.CurrentTime()); 559 probe_controller->SetAlrEndedTime(fixture.CurrentTime()); 560 fixture.AdvanceTime(kAlrEndedTimeout + TimeDelta::Millis(1)); 561 probes = probe_controller->RequestProbe(fixture.CurrentTime()); 562 EXPECT_TRUE(probes.empty()); 563 } 564 565 TEST(ProbeControllerTest, RequestProbeWhenBweDropNotRecent) { 566 ProbeControllerFixture fixture; 567 std::unique_ptr<ProbeController> probe_controller = 568 fixture.CreateController(); 569 ASSERT_THAT( 570 probe_controller->OnNetworkAvailability({.network_available = true}), 571 IsEmpty()); 572 auto probes = probe_controller->SetBitrates( 573 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 574 EXPECT_EQ(probes.size(), 2u); 575 probes = probe_controller->SetEstimatedBitrate( 576 DataRate::BitsPerSec(500), BandwidthLimitedCause::kDelayBasedLimited, 577 fixture.CurrentTime()); 578 579 probe_controller->SetAlrStartTime(fixture.CurrentTime()); 580 fixture.AdvanceTime(kAlrProbeInterval + TimeDelta::Millis(1)); 581 probes = probe_controller->Process(fixture.CurrentTime()); 582 probes = probe_controller->SetEstimatedBitrate( 583 DataRate::BitsPerSec(250), BandwidthLimitedCause::kDelayBasedLimited, 584 fixture.CurrentTime()); 585 fixture.AdvanceTime(kBitrateDropTimeout + TimeDelta::Millis(1)); 586 probes = probe_controller->RequestProbe(fixture.CurrentTime()); 587 EXPECT_TRUE(probes.empty()); 588 } 589 590 TEST(ProbeControllerTest, PeriodicProbing) { 591 ProbeControllerFixture fixture; 592 std::unique_ptr<ProbeController> probe_controller = 593 fixture.CreateController(); 594 ASSERT_THAT( 595 probe_controller->OnNetworkAvailability({.network_available = true}), 596 IsEmpty()); 597 probe_controller->EnablePeriodicAlrProbing(true); 598 auto probes = probe_controller->SetBitrates( 599 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 600 EXPECT_EQ(probes.size(), 2u); 601 probes = probe_controller->SetEstimatedBitrate( 602 DataRate::BitsPerSec(500), BandwidthLimitedCause::kDelayBasedLimited, 603 fixture.CurrentTime()); 604 605 Timestamp start_time = fixture.CurrentTime(); 606 607 // Expect the controller to send a new probe after 5s has passed. 608 probe_controller->SetAlrStartTime(start_time); 609 fixture.AdvanceTime(TimeDelta::Seconds(5)); 610 probes = probe_controller->Process(fixture.CurrentTime()); 611 EXPECT_EQ(probes.size(), 1u); 612 EXPECT_EQ(probes[0].target_data_rate.bps(), 1000); 613 614 probes = probe_controller->SetEstimatedBitrate( 615 DataRate::BitsPerSec(500), BandwidthLimitedCause::kDelayBasedLimited, 616 fixture.CurrentTime()); 617 618 // The following probe should be sent at 10s into ALR. 619 probe_controller->SetAlrStartTime(start_time); 620 fixture.AdvanceTime(TimeDelta::Seconds(4)); 621 probes = probe_controller->Process(fixture.CurrentTime()); 622 probes = probe_controller->SetEstimatedBitrate( 623 DataRate::BitsPerSec(500), BandwidthLimitedCause::kDelayBasedLimited, 624 fixture.CurrentTime()); 625 EXPECT_TRUE(probes.empty()); 626 627 probe_controller->SetAlrStartTime(start_time); 628 fixture.AdvanceTime(TimeDelta::Seconds(1)); 629 probes = probe_controller->Process(fixture.CurrentTime()); 630 EXPECT_EQ(probes.size(), 1u); 631 probes = probe_controller->SetEstimatedBitrate( 632 DataRate::BitsPerSec(500), BandwidthLimitedCause::kDelayBasedLimited, 633 fixture.CurrentTime()); 634 EXPECT_TRUE(probes.empty()); 635 } 636 637 TEST(ProbeControllerTest, PeriodicProbingAfterReset) { 638 ProbeControllerFixture fixture; 639 std::unique_ptr<ProbeController> probe_controller = 640 fixture.CreateController(); 641 ASSERT_THAT( 642 probe_controller->OnNetworkAvailability({.network_available = true}), 643 IsEmpty()); 644 Timestamp alr_start_time = fixture.CurrentTime(); 645 646 probe_controller->SetAlrStartTime(alr_start_time); 647 probe_controller->EnablePeriodicAlrProbing(true); 648 auto probes = probe_controller->SetBitrates( 649 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 650 probe_controller->Reset(fixture.CurrentTime()); 651 652 fixture.AdvanceTime(TimeDelta::Seconds(10)); 653 probes = probe_controller->Process(fixture.CurrentTime()); 654 // Since bitrates are not yet set, no probe is sent event though we are in ALR 655 // mode. 656 EXPECT_TRUE(probes.empty()); 657 658 probes = probe_controller->SetBitrates(kMinBitrate, kStartBitrate, 659 kMaxBitrate, fixture.CurrentTime()); 660 EXPECT_EQ(probes.size(), 2u); 661 662 // Make sure we use `kStartBitrateBps` as the estimated bitrate 663 // until SetEstimatedBitrate is called with an updated estimate. 664 fixture.AdvanceTime(TimeDelta::Seconds(10)); 665 probes = probe_controller->Process(fixture.CurrentTime()); 666 EXPECT_EQ(probes.size(), 1u); 667 EXPECT_EQ(probes[0].target_data_rate, kStartBitrate * 2); 668 } 669 670 TEST(ProbeControllerTest, NoProbesWhenTransportIsNotWritable) { 671 ProbeControllerFixture fixture; 672 std::unique_ptr<ProbeController> probe_controller = 673 fixture.CreateController(); 674 probe_controller->EnablePeriodicAlrProbing(true); 675 676 std::vector<ProbeClusterConfig> probes = 677 probe_controller->OnNetworkAvailability({.network_available = false}); 678 EXPECT_THAT(probes, IsEmpty()); 679 EXPECT_THAT(probe_controller->SetBitrates(kMinBitrate, kStartBitrate, 680 kMaxBitrate, fixture.CurrentTime()), 681 IsEmpty()); 682 fixture.AdvanceTime(TimeDelta::Seconds(10)); 683 EXPECT_THAT(probe_controller->Process(fixture.CurrentTime()), IsEmpty()); 684 685 // Controller is reset after a network route change. 686 // But, a probe should not be sent since the transport is not writable. 687 // Transport is not writable until after DTLS negotiation completes. 688 // However, the bitrate constraints may change. 689 probe_controller->Reset(fixture.CurrentTime()); 690 EXPECT_THAT( 691 probe_controller->SetBitrates(2 * kMinBitrate, 2 * kStartBitrate, 692 2 * kMaxBitrate, fixture.CurrentTime()), 693 IsEmpty()); 694 fixture.AdvanceTime(TimeDelta::Seconds(10)); 695 EXPECT_THAT(probe_controller->Process(fixture.CurrentTime()), IsEmpty()); 696 } 697 698 TEST(ProbeControllerTest, TestExponentialProbingOverflow) { 699 ProbeControllerFixture fixture; 700 std::unique_ptr<ProbeController> probe_controller = 701 fixture.CreateController(); 702 ASSERT_THAT( 703 probe_controller->OnNetworkAvailability({.network_available = true}), 704 IsEmpty()); 705 auto probes = probe_controller->SetBitrates(kMinBitrate, 10 * kMbpsMultiplier, 706 100 * kMbpsMultiplier, 707 fixture.CurrentTime()); 708 // Verify that probe bitrate is capped at the specified max bitrate. 709 probes = probe_controller->SetEstimatedBitrate( 710 60 * kMbpsMultiplier, BandwidthLimitedCause::kDelayBasedLimited, 711 fixture.CurrentTime()); 712 EXPECT_EQ(probes.size(), 1u); 713 EXPECT_EQ(probes[0].target_data_rate, 100 * kMbpsMultiplier); 714 // Verify that repeated probes aren't sent. 715 probes = probe_controller->SetEstimatedBitrate( 716 100 * kMbpsMultiplier, BandwidthLimitedCause::kDelayBasedLimited, 717 fixture.CurrentTime()); 718 EXPECT_TRUE(probes.empty()); 719 } 720 721 TEST(ProbeControllerTest, TestAllocatedBitrateCap) { 722 ProbeControllerFixture fixture; 723 std::unique_ptr<ProbeController> probe_controller = 724 fixture.CreateController(); 725 ASSERT_THAT( 726 probe_controller->OnNetworkAvailability({.network_available = true}), 727 IsEmpty()); 728 auto probes = probe_controller->SetBitrates(kMinBitrate, 10 * kMbpsMultiplier, 729 100 * kMbpsMultiplier, 730 fixture.CurrentTime()); 731 732 // Configure ALR for periodic probing. 733 probe_controller->EnablePeriodicAlrProbing(true); 734 Timestamp alr_start_time = fixture.CurrentTime(); 735 probe_controller->SetAlrStartTime(alr_start_time); 736 737 DataRate estimated_bitrate = 10 * kMbpsMultiplier; 738 probes = probe_controller->SetEstimatedBitrate( 739 estimated_bitrate, BandwidthLimitedCause::kDelayBasedLimited, 740 fixture.CurrentTime()); 741 742 // Set a max allocated bitrate below the current estimate. 743 DataRate max_allocated = estimated_bitrate - 1 * kMbpsMultiplier; 744 probes = probe_controller->OnMaxTotalAllocatedBitrate(max_allocated, 745 fixture.CurrentTime()); 746 EXPECT_TRUE(probes.empty()); // No probe since lower than current max. 747 748 // Probes such as ALR capped at 2x the max allocation limit. 749 fixture.AdvanceTime(TimeDelta::Seconds(5)); 750 probes = probe_controller->Process(fixture.CurrentTime()); 751 EXPECT_EQ(probes.size(), 1u); 752 EXPECT_EQ(probes[0].target_data_rate, 2 * max_allocated); 753 754 // Remove allocation limit. 755 EXPECT_TRUE( 756 probe_controller 757 ->OnMaxTotalAllocatedBitrate(DataRate::Zero(), fixture.CurrentTime()) 758 .empty()); 759 fixture.AdvanceTime(TimeDelta::Seconds(5)); 760 probes = probe_controller->Process(fixture.CurrentTime()); 761 EXPECT_EQ(probes.size(), 1u); 762 EXPECT_EQ(probes[0].target_data_rate, estimated_bitrate * 2); 763 } 764 765 TEST(ProbeControllerTest, ConfigurableProbingFieldTrial) { 766 ProbeControllerFixture fixture( 767 "WebRTC-Bwe-ProbingConfiguration/" 768 "p1:2,p2:5,step_size:3,further_probe_threshold:0.8," 769 "alloc_p1:2,alloc_current_bwe_limit:1000.0,alloc_p2,min_probe_packets_" 770 "sent:2/"); 771 std::unique_ptr<ProbeController> probe_controller = 772 fixture.CreateController(); 773 ASSERT_THAT( 774 probe_controller->OnNetworkAvailability({.network_available = true}), 775 IsEmpty()); 776 777 auto probes = probe_controller->SetBitrates(kMinBitrate, kStartBitrate, 778 DataRate::KilobitsPerSec(5000), 779 fixture.CurrentTime()); 780 EXPECT_EQ(probes.size(), 2u); 781 EXPECT_EQ(probes[0].target_data_rate.bps(), 600); 782 EXPECT_EQ(probes[0].target_probe_count, 2); 783 EXPECT_EQ(probes[1].target_data_rate.bps(), 1500); 784 EXPECT_EQ(probes[1].target_probe_count, 2); 785 786 // Repeated probe should only be sent when estimated bitrate climbs above 787 // 0.8 * 5 * kStartBitrateBps = 1200. 788 probes = probe_controller->SetEstimatedBitrate( 789 DataRate::BitsPerSec(1100), BandwidthLimitedCause::kDelayBasedLimited, 790 fixture.CurrentTime()); 791 EXPECT_EQ(probes.size(), 0u); 792 793 probes = probe_controller->SetEstimatedBitrate( 794 DataRate::BitsPerSec(1250), BandwidthLimitedCause::kDelayBasedLimited, 795 fixture.CurrentTime()); 796 EXPECT_EQ(probes.size(), 1u); 797 EXPECT_EQ(probes[0].target_data_rate.bps(), 3 * 1250); 798 799 fixture.AdvanceTime(TimeDelta::Seconds(5)); 800 probes = probe_controller->Process(fixture.CurrentTime()); 801 802 probe_controller->SetAlrStartTime(fixture.CurrentTime()); 803 probes = probe_controller->OnMaxTotalAllocatedBitrate( 804 DataRate::KilobitsPerSec(200), fixture.CurrentTime()); 805 EXPECT_EQ(probes.size(), 1u); 806 EXPECT_EQ(probes[0].target_data_rate.bps(), 400'000); 807 } 808 809 TEST(ProbeControllerTest, LimitAlrProbeWhenLossBasedBweLimited) { 810 ProbeControllerFixture fixture; 811 std::unique_ptr<ProbeController> probe_controller = 812 fixture.CreateController(); 813 ASSERT_THAT( 814 probe_controller->OnNetworkAvailability({.network_available = true}), 815 IsEmpty()); 816 probe_controller->EnablePeriodicAlrProbing(true); 817 auto probes = probe_controller->SetBitrates( 818 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 819 probes = probe_controller->SetEstimatedBitrate( 820 DataRate::BitsPerSec(500), BandwidthLimitedCause::kDelayBasedLimited, 821 fixture.CurrentTime()); 822 // Expect the controller to send a new probe after 5s has passed. 823 probe_controller->SetAlrStartTime(fixture.CurrentTime()); 824 fixture.AdvanceTime(TimeDelta::Seconds(5)); 825 probes = probe_controller->Process(fixture.CurrentTime()); 826 ASSERT_EQ(probes.size(), 1u); 827 828 probes = probe_controller->SetEstimatedBitrate( 829 DataRate::BitsPerSec(500), 830 BandwidthLimitedCause::kLossLimitedBweIncreasing, fixture.CurrentTime()); 831 fixture.AdvanceTime(TimeDelta::Seconds(6)); 832 probes = probe_controller->Process(fixture.CurrentTime()); 833 ASSERT_EQ(probes.size(), 1u); 834 EXPECT_EQ(probes[0].target_data_rate, 1.5 * DataRate::BitsPerSec(500)); 835 836 probes = probe_controller->SetEstimatedBitrate( 837 1.5 * DataRate::BitsPerSec(500), 838 BandwidthLimitedCause::kDelayBasedLimited, fixture.CurrentTime()); 839 fixture.AdvanceTime(TimeDelta::Seconds(6)); 840 probes = probe_controller->Process(fixture.CurrentTime()); 841 ASSERT_FALSE(probes.empty()); 842 EXPECT_GT(probes[0].target_data_rate, 1.5 * 1.5 * DataRate::BitsPerSec(500)); 843 } 844 845 TEST(ProbeControllerTest, PeriodicProbeAtUpperNetworkStateEstimate) { 846 ProbeControllerFixture fixture( 847 "WebRTC-Bwe-ProbingConfiguration/network_state_interval:5s/"); 848 std::unique_ptr<ProbeController> probe_controller = 849 fixture.CreateController(); 850 ASSERT_THAT( 851 probe_controller->OnNetworkAvailability({.network_available = true}), 852 IsEmpty()); 853 854 auto probes = probe_controller->SetBitrates( 855 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 856 probes = probe_controller->SetEstimatedBitrate( 857 DataRate::BitsPerSec(5000), BandwidthLimitedCause::kDelayBasedLimited, 858 fixture.CurrentTime()); 859 // Expect the controller to send a new probe after 5s has passed. 860 NetworkStateEstimate state_estimate; 861 state_estimate.link_capacity_upper = DataRate::KilobitsPerSec(6); 862 probe_controller->SetNetworkStateEstimate(state_estimate); 863 864 fixture.AdvanceTime(TimeDelta::Seconds(5)); 865 probes = probe_controller->Process(fixture.CurrentTime()); 866 ASSERT_EQ(probes.size(), 1u); 867 EXPECT_EQ(probes[0].target_data_rate, state_estimate.link_capacity_upper); 868 fixture.AdvanceTime(TimeDelta::Seconds(5)); 869 probes = probe_controller->Process(fixture.CurrentTime()); 870 ASSERT_EQ(probes.size(), 1u); 871 EXPECT_EQ(probes[0].target_data_rate, state_estimate.link_capacity_upper); 872 } 873 874 TEST(ProbeControllerTest, 875 LimitProbeAtUpperNetworkStateEstimateIfLossBasedLimited) { 876 ProbeControllerFixture fixture( 877 "WebRTC-Bwe-ProbingConfiguration/" 878 "network_state_interval:5s/"); 879 std::unique_ptr<ProbeController> probe_controller = 880 fixture.CreateController(); 881 ASSERT_THAT( 882 probe_controller->OnNetworkAvailability({.network_available = true}), 883 IsEmpty()); 884 885 auto probes = probe_controller->SetBitrates( 886 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 887 probes = probe_controller->SetEstimatedBitrate( 888 DataRate::BitsPerSec(500), BandwidthLimitedCause::kDelayBasedLimited, 889 fixture.CurrentTime()); 890 // Expect the controller to send a new probe after 5s has passed. 891 NetworkStateEstimate state_estimate; 892 state_estimate.link_capacity_upper = DataRate::BitsPerSec(700); 893 probe_controller->SetNetworkStateEstimate(state_estimate); 894 fixture.AdvanceTime(TimeDelta::Seconds(5)); 895 probes = probe_controller->Process(fixture.CurrentTime()); 896 ASSERT_EQ(probes.size(), 1u); 897 898 probes = probe_controller->SetEstimatedBitrate( 899 DataRate::BitsPerSec(500), 900 BandwidthLimitedCause::kLossLimitedBweIncreasing, fixture.CurrentTime()); 901 // Expect the controller to send a new probe after 5s has passed. 902 fixture.AdvanceTime(TimeDelta::Seconds(5)); 903 probes = probe_controller->Process(fixture.CurrentTime()); 904 ASSERT_FALSE(probes.empty()); 905 EXPECT_EQ(probes[0].target_data_rate, DataRate::BitsPerSec(700)); 906 } 907 908 TEST(ProbeControllerTest, AlrProbesLimitedByNetworkStateEstimate) { 909 ProbeControllerFixture fixture( 910 "WebRTC-Bwe-ProbingConfiguration/network_state_interval:5s/"); 911 std::unique_ptr<ProbeController> probe_controller = 912 fixture.CreateController(); 913 ASSERT_THAT( 914 probe_controller->OnNetworkAvailability({.network_available = true}), 915 IsEmpty()); 916 probe_controller->EnablePeriodicAlrProbing(true); 917 auto probes = probe_controller->SetBitrates( 918 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 919 probes = probe_controller->SetEstimatedBitrate( 920 DataRate::KilobitsPerSec(6), BandwidthLimitedCause::kDelayBasedLimited, 921 fixture.CurrentTime()); 922 probe_controller->SetAlrStartTime(fixture.CurrentTime()); 923 924 fixture.AdvanceTime(TimeDelta::Seconds(5)); 925 probes = probe_controller->Process(fixture.CurrentTime()); 926 ASSERT_EQ(probes.size(), 1u); 927 EXPECT_EQ(probes[0].target_data_rate, kMaxBitrate); 928 929 NetworkStateEstimate state_estimate; 930 state_estimate.link_capacity_upper = DataRate::BitsPerSec(8000); 931 probe_controller->SetNetworkStateEstimate(state_estimate); 932 fixture.AdvanceTime(TimeDelta::Seconds(5)); 933 probes = probe_controller->Process(fixture.CurrentTime()); 934 ASSERT_EQ(probes.size(), 1u); 935 EXPECT_EQ(probes[0].target_data_rate, state_estimate.link_capacity_upper); 936 } 937 938 TEST(ProbeControllerTest, CanSetLongerProbeDurationAfterNetworkStateEstimate) { 939 ProbeControllerFixture fixture( 940 "WebRTC-Bwe-ProbingConfiguration/" 941 "network_state_interval:5s,network_state_probe_duration:100ms/"); 942 std::unique_ptr<ProbeController> probe_controller = 943 fixture.CreateController(); 944 ASSERT_THAT( 945 probe_controller->OnNetworkAvailability({.network_available = true}), 946 IsEmpty()); 947 948 auto probes = probe_controller->SetBitrates( 949 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 950 probes = probe_controller->SetEstimatedBitrate( 951 DataRate::KilobitsPerSec(5), BandwidthLimitedCause::kDelayBasedLimited, 952 fixture.CurrentTime()); 953 ASSERT_FALSE(probes.empty()); 954 EXPECT_LT(probes[0].target_duration, TimeDelta::Millis(100)); 955 956 NetworkStateEstimate state_estimate; 957 state_estimate.link_capacity_upper = DataRate::KilobitsPerSec(6); 958 probe_controller->SetNetworkStateEstimate(state_estimate); 959 fixture.AdvanceTime(TimeDelta::Seconds(5)); 960 probes = probe_controller->Process(fixture.CurrentTime()); 961 ASSERT_EQ(probes.size(), 1u); 962 EXPECT_EQ(probes[0].target_duration, TimeDelta::Millis(100)); 963 } 964 965 TEST(ProbeControllerTest, ProbeInAlrIfLossBasedIncreasing) { 966 ProbeControllerFixture fixture; 967 std::unique_ptr<ProbeController> probe_controller = 968 fixture.CreateController(); 969 ASSERT_THAT( 970 probe_controller->OnNetworkAvailability({.network_available = true}), 971 IsEmpty()); 972 auto probes = probe_controller->SetBitrates( 973 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 974 probe_controller->EnablePeriodicAlrProbing(true); 975 probes = probe_controller->SetEstimatedBitrate( 976 kStartBitrate, BandwidthLimitedCause::kLossLimitedBweIncreasing, 977 fixture.CurrentTime()); 978 979 // Wait long enough to time out exponential probing. 980 fixture.AdvanceTime(kExponentialProbingTimeout); 981 probes = probe_controller->Process(fixture.CurrentTime()); 982 ASSERT_TRUE(probes.empty()); 983 984 // Probe when in alr. 985 probe_controller->SetAlrStartTime(fixture.CurrentTime()); 986 fixture.AdvanceTime(kAlrProbeInterval + TimeDelta::Millis(1)); 987 probes = probe_controller->Process(fixture.CurrentTime()); 988 ASSERT_EQ(probes.size(), 1u); 989 EXPECT_EQ(probes.at(0).target_data_rate, 1.5 * kStartBitrate); 990 } 991 992 TEST(ProbeControllerTest, NotProbeWhenInAlrIfLossBasedDecreases) { 993 ProbeControllerFixture fixture; 994 std::unique_ptr<ProbeController> probe_controller = 995 fixture.CreateController(); 996 ASSERT_THAT( 997 probe_controller->OnNetworkAvailability({.network_available = true}), 998 IsEmpty()); 999 auto probes = probe_controller->SetBitrates( 1000 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 1001 probe_controller->EnablePeriodicAlrProbing(true); 1002 probes = probe_controller->SetEstimatedBitrate( 1003 kStartBitrate, BandwidthLimitedCause::kLossLimitedBwe, 1004 fixture.CurrentTime()); 1005 1006 // Wait long enough to time out exponential probing. 1007 fixture.AdvanceTime(kExponentialProbingTimeout); 1008 probes = probe_controller->Process(fixture.CurrentTime()); 1009 ASSERT_TRUE(probes.empty()); 1010 1011 // Not probe in alr when loss based estimate decreases. 1012 probe_controller->SetAlrStartTime(fixture.CurrentTime()); 1013 fixture.AdvanceTime(kAlrProbeInterval + TimeDelta::Millis(1)); 1014 probes = probe_controller->Process(fixture.CurrentTime()); 1015 EXPECT_TRUE(probes.empty()); 1016 } 1017 1018 TEST(ProbeControllerTest, NotProbeIfLossBasedIncreasingOutsideAlr) { 1019 ProbeControllerFixture fixture; 1020 std::unique_ptr<ProbeController> probe_controller = 1021 fixture.CreateController(); 1022 ASSERT_THAT( 1023 probe_controller->OnNetworkAvailability({.network_available = true}), 1024 IsEmpty()); 1025 auto probes = probe_controller->SetBitrates( 1026 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 1027 probe_controller->EnablePeriodicAlrProbing(true); 1028 probes = probe_controller->SetEstimatedBitrate( 1029 kStartBitrate, BandwidthLimitedCause::kLossLimitedBweIncreasing, 1030 fixture.CurrentTime()); 1031 1032 // Wait long enough to time out exponential probing. 1033 fixture.AdvanceTime(kExponentialProbingTimeout); 1034 probes = probe_controller->Process(fixture.CurrentTime()); 1035 ASSERT_TRUE(probes.empty()); 1036 1037 probe_controller->SetAlrStartTime(std::nullopt); 1038 fixture.AdvanceTime(kAlrProbeInterval + TimeDelta::Millis(1)); 1039 probes = probe_controller->Process(fixture.CurrentTime()); 1040 EXPECT_TRUE(probes.empty()); 1041 } 1042 1043 TEST(ProbeControllerTest, ProbeFurtherWhenLossBasedIsSameAsDelayBasedEstimate) { 1044 ProbeControllerFixture fixture( 1045 "WebRTC-Bwe-ProbingConfiguration/" 1046 "network_state_interval:5s/"); 1047 std::unique_ptr<ProbeController> probe_controller = 1048 fixture.CreateController(); 1049 ASSERT_THAT( 1050 probe_controller->OnNetworkAvailability({.network_available = true}), 1051 IsEmpty()); 1052 1053 auto probes = probe_controller->SetBitrates( 1054 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 1055 ASSERT_FALSE(probes.empty()); 1056 1057 // Need to wait at least one second before process can trigger a new probe. 1058 fixture.AdvanceTime(TimeDelta::Millis(1100)); 1059 probes = probe_controller->Process(fixture.CurrentTime()); 1060 ASSERT_TRUE(probes.empty()); 1061 1062 NetworkStateEstimate state_estimate; 1063 state_estimate.link_capacity_upper = 5 * kStartBitrate; 1064 probe_controller->SetNetworkStateEstimate(state_estimate); 1065 fixture.AdvanceTime(TimeDelta::Seconds(5)); 1066 probes = probe_controller->Process(fixture.CurrentTime()); 1067 ASSERT_FALSE(probes.empty()); 1068 1069 DataRate probe_target_rate = probes[0].target_data_rate; 1070 EXPECT_LT(probe_target_rate, state_estimate.link_capacity_upper); 1071 // Expect that more probes are sent if BWE is the same as delay based 1072 // estimate. 1073 probes = probe_controller->SetEstimatedBitrate( 1074 probe_target_rate, BandwidthLimitedCause::kDelayBasedLimited, 1075 fixture.CurrentTime()); 1076 ASSERT_FALSE(probes.empty()); 1077 EXPECT_EQ(probes[0].target_data_rate, 2 * probe_target_rate); 1078 } 1079 1080 TEST(ProbeControllerTest, ProbeIfEstimateLowerThanNetworkStateEstimate) { 1081 // Periodic probe every 1 second if estimate is lower than 50% of the 1082 // NetworkStateEstimate. 1083 ProbeControllerFixture fixture( 1084 "WebRTC-Bwe-ProbingConfiguration/est_lower_than_network_interval:1s," 1085 "est_lower_than_network_ratio:0.5,limit_probe_" 1086 "target_rate_to_loss_bwe:true/"); 1087 std::unique_ptr<ProbeController> probe_controller = 1088 fixture.CreateController(); 1089 ASSERT_THAT( 1090 probe_controller->OnNetworkAvailability({.network_available = true}), 1091 IsEmpty()); 1092 1093 auto probes = probe_controller->SetBitrates( 1094 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 1095 probes = probe_controller->SetEstimatedBitrate( 1096 kStartBitrate, BandwidthLimitedCause::kDelayBasedLimited, 1097 fixture.CurrentTime()); 1098 // Need to wait at least one second before process can trigger a new probe. 1099 fixture.AdvanceTime(TimeDelta::Millis(1100)); 1100 probes = probe_controller->Process(fixture.CurrentTime()); 1101 EXPECT_TRUE(probes.empty()); 1102 1103 NetworkStateEstimate state_estimate; 1104 state_estimate.link_capacity_upper = kStartBitrate; 1105 probe_controller->SetNetworkStateEstimate(state_estimate); 1106 probes = probe_controller->Process(fixture.CurrentTime()); 1107 EXPECT_TRUE(probes.empty()); 1108 1109 state_estimate.link_capacity_upper = kStartBitrate * 3; 1110 probe_controller->SetNetworkStateEstimate(state_estimate); 1111 probes = probe_controller->Process(fixture.CurrentTime()); 1112 ASSERT_EQ(probes.size(), 1u); 1113 EXPECT_GT(probes[0].target_data_rate, kStartBitrate); 1114 1115 // If network state not increased, send another probe. 1116 fixture.AdvanceTime(TimeDelta::Millis(1100)); 1117 probes = probe_controller->Process(fixture.CurrentTime()); 1118 EXPECT_FALSE(probes.empty()); 1119 1120 // Stop probing if estimate increase. We might probe further here though. 1121 probes = probe_controller->SetEstimatedBitrate( 1122 2 * kStartBitrate, BandwidthLimitedCause::kDelayBasedLimited, 1123 fixture.CurrentTime()); 1124 // No more periodic probes. 1125 fixture.AdvanceTime(TimeDelta::Millis(1100)); 1126 probes = probe_controller->Process(fixture.CurrentTime()); 1127 EXPECT_TRUE(probes.empty()); 1128 } 1129 1130 TEST(ProbeControllerTest, DontProbeFurtherWhenLossLimited) { 1131 ProbeControllerFixture fixture( 1132 "WebRTC-Bwe-ProbingConfiguration/" 1133 "network_state_interval:5s/"); 1134 std::unique_ptr<ProbeController> probe_controller = 1135 fixture.CreateController(); 1136 ASSERT_THAT( 1137 probe_controller->OnNetworkAvailability({.network_available = true}), 1138 IsEmpty()); 1139 1140 auto probes = probe_controller->SetBitrates( 1141 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 1142 ASSERT_FALSE(probes.empty()); 1143 1144 // Need to wait at least one second before process can trigger a new probe. 1145 fixture.AdvanceTime(TimeDelta::Millis(1100)); 1146 probes = probe_controller->Process(fixture.CurrentTime()); 1147 EXPECT_TRUE(probes.empty()); 1148 1149 NetworkStateEstimate state_estimate; 1150 state_estimate.link_capacity_upper = 3 * kStartBitrate; 1151 probe_controller->SetNetworkStateEstimate(state_estimate); 1152 fixture.AdvanceTime(TimeDelta::Seconds(5)); 1153 probes = probe_controller->Process(fixture.CurrentTime()); 1154 EXPECT_FALSE(probes.empty()); 1155 EXPECT_LT(probes[0].target_data_rate, state_estimate.link_capacity_upper); 1156 // Expect that no more probes are sent immediately if BWE is loss limited. 1157 probes = probe_controller->SetEstimatedBitrate( 1158 probes[0].target_data_rate, BandwidthLimitedCause::kLossLimitedBwe, 1159 fixture.CurrentTime()); 1160 EXPECT_TRUE(probes.empty()); 1161 } 1162 1163 TEST(ProbeControllerTest, ProbeFurtherWhenDelayBasedLimited) { 1164 ProbeControllerFixture fixture( 1165 "WebRTC-Bwe-ProbingConfiguration/" 1166 "network_state_interval:5s/"); 1167 std::unique_ptr<ProbeController> probe_controller = 1168 fixture.CreateController(); 1169 ASSERT_THAT( 1170 probe_controller->OnNetworkAvailability({.network_available = true}), 1171 IsEmpty()); 1172 1173 auto probes = probe_controller->SetBitrates( 1174 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 1175 ASSERT_FALSE(probes.empty()); 1176 1177 // Need to wait at least one second before process can trigger a new probe. 1178 fixture.AdvanceTime(TimeDelta::Millis(1100)); 1179 probes = probe_controller->Process(fixture.CurrentTime()); 1180 EXPECT_TRUE(probes.empty()); 1181 1182 NetworkStateEstimate state_estimate; 1183 state_estimate.link_capacity_upper = 3 * kStartBitrate; 1184 probe_controller->SetNetworkStateEstimate(state_estimate); 1185 fixture.AdvanceTime(TimeDelta::Seconds(5)); 1186 probes = probe_controller->Process(fixture.CurrentTime()); 1187 EXPECT_FALSE(probes.empty()); 1188 EXPECT_LT(probes[0].target_data_rate, state_estimate.link_capacity_upper); 1189 // Since the probe was successfull, expect to continue probing. 1190 probes = probe_controller->SetEstimatedBitrate( 1191 probes[0].target_data_rate, BandwidthLimitedCause::kDelayBasedLimited, 1192 fixture.CurrentTime()); 1193 EXPECT_FALSE(probes.empty()); 1194 EXPECT_EQ(probes[0].target_data_rate, state_estimate.link_capacity_upper); 1195 } 1196 1197 TEST(ProbeControllerTest, 1198 ProbeAfterTimeoutIfNetworkStateEstimateIncreaseAfterProbeSent) { 1199 ProbeControllerFixture fixture( 1200 "WebRTC-Bwe-ProbingConfiguration/" 1201 "network_state_interval:5s,est_lower_than_network_interval:3s,est_lower_" 1202 "than_network_ratio:0.7/"); 1203 std::unique_ptr<ProbeController> probe_controller = 1204 fixture.CreateController(); 1205 ASSERT_THAT( 1206 probe_controller->OnNetworkAvailability({.network_available = true}), 1207 IsEmpty()); 1208 auto probes = probe_controller->SetBitrates( 1209 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 1210 ASSERT_FALSE(probes.empty()); 1211 NetworkStateEstimate state_estimate; 1212 state_estimate.link_capacity_upper = 1.2 * probes[0].target_data_rate / 2; 1213 probe_controller->SetNetworkStateEstimate(state_estimate); 1214 // No immediate further probing since probe result is low. 1215 probes = probe_controller->SetEstimatedBitrate( 1216 probes[0].target_data_rate / 2, BandwidthLimitedCause::kDelayBasedLimited, 1217 fixture.CurrentTime()); 1218 ASSERT_TRUE(probes.empty()); 1219 1220 fixture.AdvanceTime(TimeDelta::Seconds(5)); 1221 probes = probe_controller->Process(fixture.CurrentTime()); 1222 ASSERT_FALSE(probes.empty()); 1223 EXPECT_LE(probes[0].target_data_rate, state_estimate.link_capacity_upper); 1224 // If the network state estimate increase, even before the probe result, 1225 // expect a new probe after `est_lower_than_network_interval` timeout. 1226 state_estimate.link_capacity_upper = 3 * kStartBitrate; 1227 probe_controller->SetNetworkStateEstimate(state_estimate); 1228 probes = probe_controller->SetEstimatedBitrate( 1229 probes[0].target_data_rate, BandwidthLimitedCause::kDelayBasedLimited, 1230 fixture.CurrentTime()); 1231 EXPECT_THAT(probes, IsEmpty()); 1232 1233 fixture.AdvanceTime(TimeDelta::Seconds(3)); 1234 probes = probe_controller->Process(fixture.CurrentTime()); 1235 EXPECT_THAT(probes, Not(IsEmpty())); 1236 1237 // But no more probes if estimate is close to the link capacity. 1238 probes = probe_controller->SetEstimatedBitrate( 1239 state_estimate.link_capacity_upper * 0.9, 1240 BandwidthLimitedCause::kDelayBasedLimited, fixture.CurrentTime()); 1241 EXPECT_TRUE(probes.empty()); 1242 } 1243 1244 TEST(ProbeControllerTest, SkipProbeFurtherIfAlreadyProbedToMaxRate) { 1245 ProbeControllerFixture fixture( 1246 "WebRTC-Bwe-ProbingConfiguration/" 1247 "network_state_interval:2s,skip_if_est_larger_than_fraction_of_max:0.9/"); 1248 std::unique_ptr<ProbeController> probe_controller = 1249 fixture.CreateController(); 1250 ASSERT_THAT( 1251 probe_controller->OnNetworkAvailability({.network_available = true}), 1252 IsEmpty()); 1253 auto probes = probe_controller->SetBitrates( 1254 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 1255 ASSERT_FALSE(probes.empty()); 1256 1257 probe_controller->SetNetworkStateEstimate( 1258 {.link_capacity_upper = 2 * kMaxBitrate}); 1259 1260 // Attempt to probe up to max rate. 1261 probes = probe_controller->SetEstimatedBitrate( 1262 kMaxBitrate * 0.8, BandwidthLimitedCause::kDelayBasedLimited, 1263 fixture.CurrentTime()); 1264 ASSERT_FALSE(probes.empty()); 1265 EXPECT_EQ(probes[0].target_data_rate, kMaxBitrate); 1266 1267 // If the probe result arrives, dont expect a new probe immediately since we 1268 // already tried to probe at the max rate. 1269 probes = probe_controller->SetEstimatedBitrate( 1270 kMaxBitrate * 0.8, BandwidthLimitedCause::kDelayBasedLimited, 1271 fixture.CurrentTime()); 1272 EXPECT_TRUE(probes.empty()); 1273 1274 fixture.AdvanceTime(TimeDelta::Millis(1000)); 1275 probes = probe_controller->Process(fixture.CurrentTime()); 1276 EXPECT_THAT(probes, IsEmpty()); 1277 // But when enough time has passed, expect a new probe. 1278 fixture.AdvanceTime(TimeDelta::Millis(1000)); 1279 probes = probe_controller->Process(fixture.CurrentTime()); 1280 EXPECT_THAT(probes, Not(IsEmpty())); 1281 } 1282 1283 TEST(ProbeControllerTest, MaxAllocatedBitrateNotReset) { 1284 ProbeControllerFixture fixture; 1285 std::unique_ptr<ProbeController> probe_controller = 1286 fixture.CreateController(); 1287 ASSERT_THAT( 1288 probe_controller->OnNetworkAvailability({.network_available = true}), 1289 IsEmpty()); 1290 auto probes = probe_controller->SetBitrates( 1291 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 1292 ASSERT_FALSE(probes.empty()); 1293 1294 probes = probe_controller->OnMaxTotalAllocatedBitrate(kStartBitrate / 4, 1295 fixture.CurrentTime()); 1296 probe_controller->Reset(fixture.CurrentTime()); 1297 1298 probes = probe_controller->SetBitrates(kMinBitrate, kStartBitrate, 1299 kMaxBitrate, fixture.CurrentTime()); 1300 ASSERT_FALSE(probes.empty()); 1301 EXPECT_EQ(probes[0].target_data_rate, kStartBitrate / 4 * 2); 1302 } 1303 1304 TEST(ProbeControllerTest, SkipAlrProbeIfEstimateLargerThanMaxProbe) { 1305 ProbeControllerFixture fixture( 1306 "WebRTC-Bwe-ProbingConfiguration/" 1307 "skip_if_est_larger_than_fraction_of_max:0.9/"); 1308 std::unique_ptr<ProbeController> probe_controller = 1309 fixture.CreateController(); 1310 ASSERT_THAT( 1311 probe_controller->OnNetworkAvailability({.network_available = true}), 1312 IsEmpty()); 1313 probe_controller->EnablePeriodicAlrProbing(true); 1314 auto probes = probe_controller->SetBitrates( 1315 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 1316 ASSERT_FALSE(probes.empty()); 1317 1318 probes = probe_controller->SetEstimatedBitrate( 1319 kMaxBitrate, BandwidthLimitedCause::kDelayBasedLimited, 1320 fixture.CurrentTime()); 1321 EXPECT_TRUE(probes.empty()); 1322 1323 probe_controller->SetAlrStartTime(fixture.CurrentTime()); 1324 fixture.AdvanceTime(TimeDelta::Seconds(10)); 1325 probes = probe_controller->Process(fixture.CurrentTime()); 1326 EXPECT_TRUE(probes.empty()); 1327 1328 // But if the max rate increase, A new probe is sent. 1329 probes = probe_controller->SetBitrates( 1330 kMinBitrate, kStartBitrate, 2 * kMaxBitrate, fixture.CurrentTime()); 1331 EXPECT_FALSE(probes.empty()); 1332 } 1333 1334 TEST(ProbeControllerTest, 1335 SkipAlrProbeIfEstimateLargerThanFractionOfMaxAllocated) { 1336 ProbeControllerFixture fixture( 1337 "WebRTC-Bwe-ProbingConfiguration/" 1338 "skip_if_est_larger_than_fraction_of_max:1.0/"); 1339 std::unique_ptr<ProbeController> probe_controller = 1340 fixture.CreateController(); 1341 ASSERT_THAT( 1342 probe_controller->OnNetworkAvailability({.network_available = true}), 1343 IsEmpty()); 1344 probe_controller->EnablePeriodicAlrProbing(true); 1345 auto probes = probe_controller->SetBitrates( 1346 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 1347 ASSERT_FALSE(probes.empty()); 1348 probes = probe_controller->SetEstimatedBitrate( 1349 kMaxBitrate / 2, BandwidthLimitedCause::kDelayBasedLimited, 1350 fixture.CurrentTime()); 1351 1352 fixture.AdvanceTime(TimeDelta::Seconds(10)); 1353 probe_controller->SetAlrStartTime(fixture.CurrentTime()); 1354 probes = probe_controller->OnMaxTotalAllocatedBitrate(kMaxBitrate / 2, 1355 fixture.CurrentTime()); 1356 // No probes since total allocated is not higher than the current estimate. 1357 EXPECT_TRUE(probes.empty()); 1358 fixture.AdvanceTime(TimeDelta::Seconds(2)); 1359 probes = probe_controller->Process(fixture.CurrentTime()); 1360 EXPECT_TRUE(probes.empty()); 1361 1362 // But if the max allocated increase, A new probe is sent. 1363 probes = probe_controller->OnMaxTotalAllocatedBitrate( 1364 kMaxBitrate / 2 + DataRate::BitsPerSec(1), fixture.CurrentTime()); 1365 EXPECT_FALSE(probes.empty()); 1366 } 1367 1368 TEST(ProbeControllerTest, SkipNetworkStateProbeIfEstimateLargerThanMaxProbe) { 1369 ProbeControllerFixture fixture( 1370 "WebRTC-Bwe-ProbingConfiguration/" 1371 "network_state_interval:2s,skip_if_est_larger_than_fraction_of_max:0.9/"); 1372 std::unique_ptr<ProbeController> probe_controller = 1373 fixture.CreateController(); 1374 ASSERT_THAT( 1375 probe_controller->OnNetworkAvailability({.network_available = true}), 1376 IsEmpty()); 1377 auto probes = probe_controller->SetBitrates( 1378 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 1379 ASSERT_FALSE(probes.empty()); 1380 1381 probe_controller->SetNetworkStateEstimate( 1382 {.link_capacity_upper = 2 * kMaxBitrate}); 1383 probes = probe_controller->SetEstimatedBitrate( 1384 kMaxBitrate, BandwidthLimitedCause::kDelayBasedLimited, 1385 fixture.CurrentTime()); 1386 EXPECT_TRUE(probes.empty()); 1387 1388 fixture.AdvanceTime(TimeDelta::Seconds(10)); 1389 probes = probe_controller->Process(fixture.CurrentTime()); 1390 EXPECT_TRUE(probes.empty()); 1391 } 1392 1393 TEST(ProbeControllerTest, SendsProbeIfNetworkStateEstimateLowerThanMaxProbe) { 1394 ProbeControllerFixture fixture( 1395 "WebRTC-Bwe-ProbingConfiguration/" 1396 "network_state_interval:2s,skip_if_est_larger_than_fraction_of_max:0.9," 1397 "network_state_probe_duration:100ms,network_" 1398 "state_min_probe_delta:20/"); 1399 std::unique_ptr<ProbeController> probe_controller = 1400 fixture.CreateController(); 1401 ASSERT_THAT( 1402 probe_controller->OnNetworkAvailability({.network_available = true}), 1403 IsEmpty()); 1404 auto probes = probe_controller->SetBitrates( 1405 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 1406 ASSERT_FALSE(probes.empty()); 1407 probe_controller->SetNetworkStateEstimate( 1408 {.link_capacity_upper = 2 * kMaxBitrate}); 1409 probes = probe_controller->SetEstimatedBitrate( 1410 kMaxBitrate, BandwidthLimitedCause::kDelayBasedLimited, 1411 fixture.CurrentTime()); 1412 EXPECT_TRUE(probes.empty()); 1413 1414 // Need to wait at least two seconds before process can trigger a new probe. 1415 fixture.AdvanceTime(TimeDelta::Millis(2100)); 1416 1417 probes = probe_controller->SetEstimatedBitrate( 1418 kStartBitrate, BandwidthLimitedCause::kDelayBasedLimited, 1419 fixture.CurrentTime()); 1420 EXPECT_TRUE(probes.empty()); 1421 probe_controller->SetNetworkStateEstimate( 1422 {.link_capacity_upper = 2 * kStartBitrate}); 1423 probes = probe_controller->Process(fixture.CurrentTime()); 1424 EXPECT_FALSE(probes.empty()); 1425 EXPECT_LE(probes[0].target_data_rate, 2 * kStartBitrate); 1426 // Expect probe durations to be picked from field trial probe target is lower 1427 // or equal to the network state estimate. 1428 EXPECT_EQ(probes[0].min_probe_delta, TimeDelta::Millis(20)); 1429 EXPECT_EQ(probes[0].target_duration, TimeDelta::Millis(100)); 1430 } 1431 1432 TEST(ProbeControllerTest, 1433 ProbeNotLimitedByNetworkStateEsimateIfLowerThantCurrent) { 1434 ProbeControllerFixture fixture( 1435 "WebRTC-Bwe-ProbingConfiguration/" 1436 "network_state_interval:5s,network_state_probe_duration:100ms,network_" 1437 "state_min_probe_delta:20/"); 1438 std::unique_ptr<ProbeController> probe_controller = 1439 fixture.CreateController(); 1440 ASSERT_THAT( 1441 probe_controller->OnNetworkAvailability({.network_available = true}), 1442 IsEmpty()); 1443 probe_controller->EnablePeriodicAlrProbing(true); 1444 auto probes = probe_controller->SetBitrates( 1445 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 1446 probes = probe_controller->SetEstimatedBitrate( 1447 kStartBitrate, BandwidthLimitedCause::kDelayBasedLimited, 1448 fixture.CurrentTime()); 1449 probe_controller->SetNetworkStateEstimate( 1450 {.link_capacity_upper = kStartBitrate}); 1451 // Need to wait at least one second before process can trigger a new probe. 1452 fixture.AdvanceTime(TimeDelta::Millis(1100)); 1453 probes = probe_controller->Process(fixture.CurrentTime()); 1454 ASSERT_TRUE(probes.empty()); 1455 1456 probe_controller->SetAlrStartTime(fixture.CurrentTime()); 1457 probe_controller->SetNetworkStateEstimate( 1458 {.link_capacity_upper = kStartBitrate / 2}); 1459 fixture.AdvanceTime(TimeDelta::Seconds(6)); 1460 probes = probe_controller->Process(fixture.CurrentTime()); 1461 ASSERT_FALSE(probes.empty()); 1462 EXPECT_EQ(probes[0].target_data_rate, kStartBitrate); 1463 // Expect probe durations to be default since network state estimate is lower 1464 // than the probe rate. 1465 EXPECT_EQ(probes[0].min_probe_delta, TimeDelta::Millis(2)); 1466 EXPECT_EQ(probes[0].target_duration, TimeDelta::Millis(15)); 1467 } 1468 1469 TEST(ProbeControllerTest, DontProbeIfDelayIncreased) { 1470 ProbeControllerFixture fixture; 1471 std::unique_ptr<ProbeController> probe_controller = 1472 fixture.CreateController(); 1473 ASSERT_THAT( 1474 probe_controller->OnNetworkAvailability({.network_available = true}), 1475 IsEmpty()); 1476 1477 auto probes = probe_controller->SetBitrates( 1478 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 1479 ASSERT_FALSE(probes.empty()); 1480 1481 // Need to wait at least one second before process can trigger a new probe. 1482 fixture.AdvanceTime(TimeDelta::Millis(1100)); 1483 probes = probe_controller->Process(fixture.CurrentTime()); 1484 ASSERT_TRUE(probes.empty()); 1485 1486 NetworkStateEstimate state_estimate; 1487 state_estimate.link_capacity_upper = 3 * kStartBitrate; 1488 probe_controller->SetNetworkStateEstimate(state_estimate); 1489 probes = probe_controller->SetEstimatedBitrate( 1490 kStartBitrate, BandwidthLimitedCause::kDelayBasedLimitedDelayIncreased, 1491 fixture.CurrentTime()); 1492 ASSERT_TRUE(probes.empty()); 1493 1494 fixture.AdvanceTime(TimeDelta::Seconds(5)); 1495 probes = probe_controller->Process(fixture.CurrentTime()); 1496 EXPECT_TRUE(probes.empty()); 1497 } 1498 1499 TEST(ProbeControllerTest, DontProbeIfHighRtt) { 1500 ProbeControllerFixture fixture; 1501 std::unique_ptr<ProbeController> probe_controller = 1502 fixture.CreateController(); 1503 ASSERT_THAT( 1504 probe_controller->OnNetworkAvailability({.network_available = true}), 1505 IsEmpty()); 1506 1507 auto probes = probe_controller->SetBitrates( 1508 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime()); 1509 ASSERT_FALSE(probes.empty()); 1510 1511 // Need to wait at least one second before process can trigger a new probe. 1512 fixture.AdvanceTime(TimeDelta::Millis(1100)); 1513 probes = probe_controller->Process(fixture.CurrentTime()); 1514 ASSERT_TRUE(probes.empty()); 1515 1516 NetworkStateEstimate state_estimate; 1517 state_estimate.link_capacity_upper = 3 * kStartBitrate; 1518 probe_controller->SetNetworkStateEstimate(state_estimate); 1519 probes = probe_controller->SetEstimatedBitrate( 1520 kStartBitrate, BandwidthLimitedCause::kRttBasedBackOffHighRtt, 1521 fixture.CurrentTime()); 1522 ASSERT_TRUE(probes.empty()); 1523 1524 fixture.AdvanceTime(TimeDelta::Seconds(5)); 1525 probes = probe_controller->Process(fixture.CurrentTime()); 1526 EXPECT_TRUE(probes.empty()); 1527 } 1528 } // namespace test 1529 } // namespace webrtc