Probing EndToEndTests.

webrtc/video/end_to_end_tests.cc

 /*
  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 #include <algorithm>
@@ skipping 2178 matching lines @@
     test::PacketTransport* receive_transport_;
     rtc::Event stop_event_;
     rtc::PlatformThread poller_thread_;
     TestState state_;
     RateLimiter retransmission_rate_limiter_;
   } test;
 
   RunBaseTest(&test);
 }
 
+class ProbingTest : public test::EndToEndTest {
+ public:
+  explicit ProbingTest(int start_bitrate_bps)
+      : clock_(Clock::GetRealTimeClock()),
+        start_bitrate_bps_(start_bitrate_bps),
+        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_;
+  int start_bitrate_bps_;

[stefan-webrtc, 2017/03/17 13:14:26]

const

[philipel, 2017/03/17 13:33:23]

Done.

+  Call* sender_call_;
+  int state_ = 0;

[stefan-webrtc, 2017/03/17 13:14:26]

Use an enum for readability. It also seems like this member belongs in
TriggerMidCallProbingTest.

[philipel, 2017/03/17 13:33:23]

I don't really think an enum adds anything in terms of readability when you have
such linear transitions, it just adds a bit more boilerplate. I put |state_| in
the base class in case we wanted to write more ProbingTests.

+};
+
+TEST_F(EndToEndTest, InitialProbing) {
+  class InitialProbingTest : public ProbingTest {
+   public:
+    InitialProbingTest() : ProbingTest(300000) {}
+
+    void PerformTest() override {
+      int64_t test_end_ms = clock_->TimeInMilliseconds() + kTimeoutMs;
+      do {
+        if (test_end_ms - clock_->TimeInMilliseconds() <= 0) {

[stefan-webrtc, 2017/03/17 13:14:26]

I would have written this:
if (clock_->TimeInMilliseconds() - test_start_ms > kTestTimeoutMs) {

easier to read that way IMO

[philipel, 2017/03/17 13:33:23]

Agree, fixed.

+          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 x5 multiplier is a high enough threshold.
+        if (stats.send_bandwidth_bps > 5 * 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 test_end_ms = clock_->TimeInMilliseconds() + kTimeoutMs;
+      do {
+        if (test_end_ms - clock_->TimeInMilliseconds() <= 0) {
+          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:
+            if (stats.send_bandwidth_bps > 2300000)
+              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 {
    public:
     NackObserver()
         : EndToEndTest(kLongTimeoutMs),
           sent_rtp_packets_(0),
           dropped_rtp_packet_(0),
           dropped_rtp_packet_requested_(false),
           send_stream_(nullptr),
@@ skipping 1971 matching lines @@
     std::unique_ptr<VideoEncoder> encoder_;
     std::unique_ptr<VideoDecoder> decoder_;
     rtc::CriticalSection crit_;
     int recorded_frames_ GUARDED_BY(crit_);
   } test(this);
 
   RunBaseTest(&test);
 }
 
 }  // namespace webrtc