Probing EndToEndTests.
Add tests for inital probing and mid-call probing by reconfiguring max bitrate.
BUG=none
Review-Url: https://codereview.webrtc.org/2760623002
Cr-Commit-Position: refs/heads/master@{#17316}
diff --git a/tools-webrtc/valgrind/gtest_exclude/video_engine_tests.gtest-memcheck.txt b/tools-webrtc/valgrind/gtest_exclude/video_engine_tests.gtest-memcheck.txt
index 3094f8b6..87ec10d 100644
--- a/tools-webrtc/valgrind/gtest_exclude/video_engine_tests.gtest-memcheck.txt
+++ b/tools-webrtc/valgrind/gtest_exclude/video_engine_tests.gtest-memcheck.txt
@@ -3,6 +3,8 @@
EndToEndTest.SendsAndReceivesVP9
TestWithNewVideoJitterBuffer/EndToEndTest.SendsAndReceivesH264/*
VideoSendStreamTest.VP9FlexMode
+EndToEndTest.InitialProbing
+EndToEndTest.TriggerMidCallProbing
# Times out due to using a real VP8 encoder.
*EndToEndTest.VerifyHistogramStatsWithRed*
diff --git a/webrtc/test/call_test.cc b/webrtc/test/call_test.cc
index 5bfcb4d..10c6438 100644
--- a/webrtc/test/call_test.cc
+++ b/webrtc/test/call_test.cc
@@ -419,6 +419,8 @@
const uint32_t CallTest::kReceiverLocalAudioSsrc = 0x1234567;
const int CallTest::kNackRtpHistoryMs = 1000;
+BaseTest::BaseTest() {}
+
BaseTest::BaseTest(unsigned int timeout_ms) : RtpRtcpObserver(timeout_ms) {
}
@@ -496,6 +498,8 @@
return false;
}
+EndToEndTest::EndToEndTest() {}
+
EndToEndTest::EndToEndTest(unsigned int timeout_ms) : BaseTest(timeout_ms) {
}
diff --git a/webrtc/test/call_test.h b/webrtc/test/call_test.h
index b2ffe7f..f1540bf 100644
--- a/webrtc/test/call_test.h
+++ b/webrtc/test/call_test.h
@@ -150,6 +150,7 @@
class BaseTest : public RtpRtcpObserver {
public:
+ BaseTest();
explicit BaseTest(unsigned int timeout_ms);
virtual ~BaseTest();
@@ -205,6 +206,7 @@
class EndToEndTest : public BaseTest {
public:
+ EndToEndTest();
explicit EndToEndTest(unsigned int timeout_ms);
bool ShouldCreateReceivers() const override;
diff --git a/webrtc/test/rtp_rtcp_observer.h b/webrtc/test/rtp_rtcp_observer.h
index f3c95a6..8e1375f 100644
--- a/webrtc/test/rtp_rtcp_observer.h
+++ b/webrtc/test/rtp_rtcp_observer.h
@@ -67,6 +67,7 @@
}
protected:
+ RtpRtcpObserver() : RtpRtcpObserver(0) {}
explicit RtpRtcpObserver(int event_timeout_ms)
: observation_complete_(false, false),
parser_(RtpHeaderParser::Create()),
diff --git a/webrtc/video/end_to_end_tests.cc b/webrtc/video/end_to_end_tests.cc
index 184c2fe..baf7161 100644
--- a/webrtc/video/end_to_end_tests.cc
+++ b/webrtc/video/end_to_end_tests.cc
@@ -2198,6 +2198,111 @@
RunBaseTest(&test);
}
+class ProbingTest : public test::EndToEndTest {
+ public:
+ explicit ProbingTest(int start_bitrate_bps)
+ : clock_(Clock::GetRealTimeClock()),
+ start_bitrate_bps_(start_bitrate_bps),
+ state_(0),
+ sender_call_(nullptr) {}
+
+ ~ProbingTest() {}
+
+ Call::Config GetSenderCallConfig() override {
+ Call::Config config(&event_log_);
+ config.bitrate_config.start_bitrate_bps = start_bitrate_bps_;
+ return config;
+ }
+
+ void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
+ sender_call_ = sender_call;
+ }
+
+ protected:
+ Clock* const clock_;
+ const int start_bitrate_bps_;
+ int state_;
+ Call* sender_call_;
+};
+
+TEST_F(EndToEndTest, InitialProbing) {
+ class InitialProbingTest : public ProbingTest {
+ public:
+ InitialProbingTest() : ProbingTest(300000) {}
+
+ void PerformTest() override {
+ int64_t start_time_ms = clock_->TimeInMilliseconds();
+ do {
+ if (clock_->TimeInMilliseconds() - start_time_ms > kTimeoutMs) {
+ ADD_FAILURE() << "Timed out while waiting for initial probing.";
+ break;
+ }
+
+ Call::Stats stats = sender_call_->GetStats();
+ // Initial probing is done with a x3 and x6 multiplier of the start
+ // bitrate, so a x4 multiplier is a high enough threshold.
+ if (stats.send_bandwidth_bps > 4 * 300000)
+ break;
+ } while (!observation_complete_.Wait(20));
+ }
+
+ private:
+ const int kTimeoutMs = 1000;
+ } test;
+
+ RunBaseTest(&test);
+}
+
+TEST_F(EndToEndTest, TriggerMidCallProbing) {
+ class TriggerMidCallProbingTest : public ProbingTest {
+ public:
+ TriggerMidCallProbingTest() : ProbingTest(300000) {}
+
+ void PerformTest() override {
+ int64_t start_time_ms = clock_->TimeInMilliseconds();
+ do {
+ if (clock_->TimeInMilliseconds() - start_time_ms > kTimeoutMs) {
+ ADD_FAILURE() << "Timed out while waiting for mid-call probing.";
+ break;
+ }
+
+ Call::Stats stats = sender_call_->GetStats();
+
+ switch (state_) {
+ case 0:
+ if (stats.send_bandwidth_bps > 5 * 300000) {
+ Call::Config::BitrateConfig bitrate_config;
+ bitrate_config.max_bitrate_bps = 100000;
+ sender_call_->SetBitrateConfig(bitrate_config);
+ ++state_;
+ }
+ break;
+ case 1:
+ if (stats.send_bandwidth_bps < 110000) {
+ Call::Config::BitrateConfig bitrate_config;
+ bitrate_config.max_bitrate_bps = 2500000;
+ sender_call_->SetBitrateConfig(bitrate_config);
+ ++state_;
+ }
+ break;
+ case 2:
+ // During high cpu load the pacer will not be able to pace packets
+ // at the correct speed, but if we go from 110 to 1250 kbps
+ // in 5 seconds then it is due to probing.
+ if (stats.send_bandwidth_bps > 1250000)
+ observation_complete_.Set();
+ break;
+ }
+ } while (!observation_complete_.Wait(20));
+ }
+
+ private:
+ const int kTimeoutMs = 5000;
+ } test;
+
+ RunBaseTest(&test);
+}
+
TEST_F(EndToEndTest, VerifyNackStats) {
static const int kPacketNumberToDrop = 200;
class NackObserver : public test::EndToEndTest {
