Enable adaptive threshold experiment by default.

webrtc/modules/remote_bitrate_estimator/overuse_detector_unittest.cc

 /*
  *  Copyright (c) 2012 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.
  */
 
@@ skipping 177 matching lines @@
   int packets_per_frame = 6;
   int frame_duration_ms = 33;
   int drift_per_frame_ms = 1;
   int sigma_ms = 0;  // No variance.
   int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                         frame_duration_ms, sigma_ms);
 
   EXPECT_EQ(0, unique_overuse);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
-  EXPECT_EQ(8, frames_until_overuse);
+  EXPECT_EQ(5, frames_until_overuse);
 }
 
 TEST_F(OveruseDetectorTest, SimpleOveruse100kbit10fps) {
   size_t packet_size = 1200;
   int packets_per_frame = 1;
   int frame_duration_ms = 100;
   int drift_per_frame_ms = 1;
   int sigma_ms = 0;  // No variance.
   int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                         frame_duration_ms, sigma_ms);
 
   EXPECT_EQ(0, unique_overuse);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
-  EXPECT_EQ(6, frames_until_overuse);
+  EXPECT_EQ(5, frames_until_overuse);
 }
 
 TEST_F(OveruseDetectorTest, DISABLED_OveruseWithHighVariance100Kbit10fps) {
   uint32_t frame_duration_ms = 100;
   uint32_t drift_per_frame_ms = 10;
   uint32_t rtp_timestamp = frame_duration_ms * 90;
   size_t packet_size = 1200;
   int offset = 10;
 
   // Run 1000 samples to reach steady state.
@@ skipping 71 matching lines @@
     if (i % 2) {
       offset = random_.Rand(0, 1);
       now_ms_ += frame_duration_ms - offset;
     } else {
       now_ms_ += frame_duration_ms + offset;
     }
     EXPECT_EQ(kBwNormal, overuse_detector_->State());
   }
   // Simulate a higher send pace, that is too high.
   // Total build up of 30 ms.
-  for (int j = 0; j < 5; ++j) {
+  for (int j = 0; j < 3; ++j) {
     UpdateDetector(rtp_timestamp, now_ms_, packet_size);
     UpdateDetector(rtp_timestamp, now_ms_, packet_size);
     UpdateDetector(rtp_timestamp, now_ms_, packet_size);
     UpdateDetector(rtp_timestamp, now_ms_, packet_size);
     UpdateDetector(rtp_timestamp, now_ms_, packet_size);
     UpdateDetector(rtp_timestamp, now_ms_, packet_size);
     now_ms_ += frame_duration_ms + drift_per_frame_ms * 6;
     rtp_timestamp += frame_duration_ms * 90;
     EXPECT_EQ(kBwNormal, overuse_detector_->State());
   }
   UpdateDetector(rtp_timestamp, now_ms_, packet_size);
   EXPECT_EQ(kBwOverusing, overuse_detector_->State());
 }
 
 #if defined(WEBRTC_ANDROID)
 #define MAYBE_LowGaussianVariance30Kbit3fps \
   DISABLED_LowGaussianVariance30Kbit3fps
 #else
 #define MAYBE_LowGaussianVariance30Kbit3fps LowGaussianVariance30Kbit3fps
 #endif
 TEST_F(OveruseDetectorTest, MAYBE_LowGaussianVariance30Kbit3fps) {
   size_t packet_size = 1200;
   int packets_per_frame = 1;
   int frame_duration_ms = 333;
   int drift_per_frame_ms = 1;
   int sigma_ms = 3;
   int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                         frame_duration_ms, sigma_ms);
-  EXPECT_EQ(1, unique_overuse);
+  EXPECT_EQ(56, unique_overuse);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
-  EXPECT_EQ(13, frames_until_overuse);
+  EXPECT_EQ(430, frames_until_overuse);
 }
 
 TEST_F(OveruseDetectorTest, LowGaussianVarianceFastDrift30Kbit3fps) {
   size_t packet_size = 1200;
   int packets_per_frame = 1;
   int frame_duration_ms = 333;
   int drift_per_frame_ms = 100;
   int sigma_ms = 3;
   int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                         frame_duration_ms, sigma_ms);
-  EXPECT_EQ(1, unique_overuse);
+  EXPECT_EQ(56, unique_overuse);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
   EXPECT_EQ(4, frames_until_overuse);
 }
 
 TEST_F(OveruseDetectorTest, HighGaussianVariance30Kbit3fps) {
   size_t packet_size = 1200;
   int packets_per_frame = 1;
   int frame_duration_ms = 333;
   int drift_per_frame_ms = 1;
   int sigma_ms = 10;
   int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                         frame_duration_ms, sigma_ms);
-  EXPECT_EQ(1, unique_overuse);
+  EXPECT_EQ(77, unique_overuse);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
-  EXPECT_EQ(32, frames_until_overuse);
+  EXPECT_EQ(430, frames_until_overuse);
 }
 
 TEST_F(OveruseDetectorTest, HighGaussianVarianceFastDrift30Kbit3fps) {
   size_t packet_size = 1200;
   int packets_per_frame = 1;
   int frame_duration_ms = 333;
   int drift_per_frame_ms = 100;
   int sigma_ms = 10;
   int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                         frame_duration_ms, sigma_ms);
-  EXPECT_EQ(1, unique_overuse);
+  EXPECT_EQ(77, unique_overuse);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
   EXPECT_EQ(4, frames_until_overuse);
 }
 
 #if defined(WEBRTC_ANDROID)
 #define MAYBE_LowGaussianVariance100Kbit5fps \
   DISABLED_LowGaussianVariance100Kbit5fps
 #else
 #define MAYBE_LowGaussianVariance100Kbit5fps LowGaussianVariance100Kbit5fps
 #endif
 TEST_F(OveruseDetectorTest, MAYBE_LowGaussianVariance100Kbit5fps) {
   size_t packet_size = 1200;
   int packets_per_frame = 2;
   int frame_duration_ms = 200;
   int drift_per_frame_ms = 1;
   int sigma_ms = 3;
   int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                         frame_duration_ms, sigma_ms);
-  EXPECT_EQ(0, unique_overuse);
+  EXPECT_EQ(45, unique_overuse);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
-  EXPECT_EQ(13, frames_until_overuse);
+  EXPECT_EQ(32, frames_until_overuse);
 }
 
 #if defined(WEBRTC_ANDROID)
 #define MAYBE_HighGaussianVariance100Kbit5fps \
   DISABLED_HighGaussianVariance100Kbit5fps
 #else
 #define MAYBE_HighGaussianVariance100Kbit5fps HighGaussianVariance100Kbit5fps
 #endif
 TEST_F(OveruseDetectorTest, MAYBE_HighGaussianVariance100Kbit5fps) {
   size_t packet_size = 1200;
   int packets_per_frame = 2;
   int frame_duration_ms = 200;
   int drift_per_frame_ms = 1;
   int sigma_ms = 10;
   int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                         frame_duration_ms, sigma_ms);
-  EXPECT_EQ(1, unique_overuse);
+  EXPECT_EQ(70, unique_overuse);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
   EXPECT_EQ(32, frames_until_overuse);
 }
 
 #if defined(WEBRTC_ANDROID)
 #define MAYBE_LowGaussianVariance100Kbit10fps \
   DISABLED_LowGaussianVariance100Kbit10fps
 #else
 #define MAYBE_LowGaussianVariance100Kbit10fps LowGaussianVariance100Kbit10fps
 #endif
 TEST_F(OveruseDetectorTest, MAYBE_LowGaussianVariance100Kbit10fps) {
   size_t packet_size = 1200;
   int packets_per_frame = 1;
   int frame_duration_ms = 100;
   int drift_per_frame_ms = 1;
   int sigma_ms = 3;
   int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                         frame_duration_ms, sigma_ms);
-  EXPECT_EQ(1, unique_overuse);
+  EXPECT_EQ(33, unique_overuse);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
   EXPECT_EQ(13, frames_until_overuse);
 }
 
 #if defined(WEBRTC_ANDROID)
 #define MAYBE_HighGaussianVariance100Kbit10fps \
   DISABLED_HighGaussianVariance100Kbit10fps
 #else
 #define MAYBE_HighGaussianVariance100Kbit10fps HighGaussianVariance100Kbit10fps
 #endif
 TEST_F(OveruseDetectorTest, MAYBE_HighGaussianVariance100Kbit10fps) {
   size_t packet_size = 1200;
   int packets_per_frame = 1;
   int frame_duration_ms = 100;
   int drift_per_frame_ms = 1;
   int sigma_ms = 10;
   int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                         frame_duration_ms, sigma_ms);
-  EXPECT_EQ(0, unique_overuse);
+  EXPECT_EQ(45, unique_overuse);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
-  EXPECT_EQ(32, frames_until_overuse);
+  EXPECT_EQ(31, frames_until_overuse);
 }
 
 #if defined(WEBRTC_ANDROID)
 #define MAYBE_LowGaussianVariance300Kbit30fps \
   DISABLED_LowGaussianVariance300Kbit30fps
 #else
 #define MAYBE_LowGaussianVariance300Kbit30fps LowGaussianVariance300Kbit30fps
 #endif
 TEST_F(OveruseDetectorTest, MAYBE_LowGaussianVariance300Kbit30fps) {
   size_t packet_size = 1200;
   int packets_per_frame = 1;
   int frame_duration_ms = 33;
   int drift_per_frame_ms = 1;
   int sigma_ms = 3;
   int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                         frame_duration_ms, sigma_ms);
-  EXPECT_EQ(0, unique_overuse);
+  EXPECT_EQ(25, unique_overuse);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
-  EXPECT_EQ(15, frames_until_overuse);
+  EXPECT_EQ(13, frames_until_overuse);
 }
 
 TEST_F(OveruseDetectorTest, LowGaussianVarianceFastDrift300Kbit30fps) {
   size_t packet_size = 1200;
   int packets_per_frame = 1;
   int frame_duration_ms = 33;
   int drift_per_frame_ms = 10;
   int sigma_ms = 3;
   int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                         frame_duration_ms, sigma_ms);
-  EXPECT_EQ(0, unique_overuse);
+  EXPECT_EQ(25, unique_overuse);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
-  EXPECT_EQ(6, frames_until_overuse);
+  EXPECT_EQ(4, frames_until_overuse);
 }
 
 TEST_F(OveruseDetectorTest, HighGaussianVariance300Kbit30fps) {
   size_t packet_size = 1200;
   int packets_per_frame = 1;
   int frame_duration_ms = 33;
   int drift_per_frame_ms = 1;
   int sigma_ms = 10;
   int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                         frame_duration_ms, sigma_ms);
-  EXPECT_EQ(0, unique_overuse);
+  EXPECT_EQ(46, unique_overuse);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
-  EXPECT_EQ(41, frames_until_overuse);
+  EXPECT_EQ(31, frames_until_overuse);
 }
 
 TEST_F(OveruseDetectorTest, HighGaussianVarianceFastDrift300Kbit30fps) {
   size_t packet_size = 1200;
   int packets_per_frame = 1;
   int frame_duration_ms = 33;
   int drift_per_frame_ms = 10;
   int sigma_ms = 10;
   int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                         frame_duration_ms, sigma_ms);
-  EXPECT_EQ(0, unique_overuse);
+  EXPECT_EQ(46, unique_overuse);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
-  EXPECT_EQ(10, frames_until_overuse);
+  EXPECT_EQ(6, frames_until_overuse);
 }
 
 #if defined(WEBRTC_ANDROID)
 #define MAYBE_LowGaussianVariance1000Kbit30fps \
   DISABLED_LowGaussianVariance1000Kbit30fps
 #else
 #define MAYBE_LowGaussianVariance1000Kbit30fps LowGaussianVariance1000Kbit30fps
 #endif
 TEST_F(OveruseDetectorTest, MAYBE_LowGaussianVariance1000Kbit30fps) {
   size_t packet_size = 1200;
   int packets_per_frame = 3;
   int frame_duration_ms = 33;
   int drift_per_frame_ms = 1;
   int sigma_ms = 3;
   int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                         frame_duration_ms, sigma_ms);
-  EXPECT_EQ(0, unique_overuse);
+  EXPECT_EQ(25, unique_overuse);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
-  EXPECT_EQ(15, frames_until_overuse);
+  EXPECT_EQ(13, frames_until_overuse);
 }
 
 TEST_F(OveruseDetectorTest, LowGaussianVarianceFastDrift1000Kbit30fps) {
   size_t packet_size = 1200;
   int packets_per_frame = 3;
   int frame_duration_ms = 33;
   int drift_per_frame_ms = 10;
   int sigma_ms = 3;
   int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                         frame_duration_ms, sigma_ms);
-  EXPECT_EQ(0, unique_overuse);
+  EXPECT_EQ(25, unique_overuse);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
-  EXPECT_EQ(6, frames_until_overuse);
+  EXPECT_EQ(4, frames_until_overuse);
 }
 
 TEST_F(OveruseDetectorTest, HighGaussianVariance1000Kbit30fps) {
   size_t packet_size = 1200;
   int packets_per_frame = 3;
   int frame_duration_ms = 33;
   int drift_per_frame_ms = 1;
   int sigma_ms = 10;
   int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                         frame_duration_ms, sigma_ms);
-  EXPECT_EQ(0, unique_overuse);
+  EXPECT_EQ(45, unique_overuse);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
-  EXPECT_EQ(41, frames_until_overuse);
+  EXPECT_EQ(31, frames_until_overuse);
 }
 
 TEST_F(OveruseDetectorTest, HighGaussianVarianceFastDrift1000Kbit30fps) {
   size_t packet_size = 1200;
   int packets_per_frame = 3;
   int frame_duration_ms = 33;
   int drift_per_frame_ms = 10;
   int sigma_ms = 10;
   int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                         frame_duration_ms, sigma_ms);
-  EXPECT_EQ(0, unique_overuse);
+  EXPECT_EQ(45, unique_overuse);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
-  EXPECT_EQ(10, frames_until_overuse);
+  EXPECT_EQ(6, frames_until_overuse);
 }
 
 #if defined(WEBRTC_ANDROID)
 #define MAYBE_LowGaussianVariance2000Kbit30fps \
   DISABLED_LowGaussianVariance2000Kbit30fps
 #else
 #define MAYBE_LowGaussianVariance2000Kbit30fps LowGaussianVariance2000Kbit30fps
 #endif
 TEST_F(OveruseDetectorTest, MAYBE_LowGaussianVariance2000Kbit30fps) {
   size_t packet_size = 1200;
   int packets_per_frame = 6;
   int frame_duration_ms = 33;
   int drift_per_frame_ms = 1;
   int sigma_ms = 3;
   int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                         frame_duration_ms, sigma_ms);
-  EXPECT_EQ(0, unique_overuse);
+  EXPECT_EQ(25, unique_overuse);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
-  EXPECT_EQ(15, frames_until_overuse);
+  EXPECT_EQ(13, frames_until_overuse);
 }
 
 TEST_F(OveruseDetectorTest, LowGaussianVarianceFastDrift2000Kbit30fps) {
   size_t packet_size = 1200;
   int packets_per_frame = 6;
   int frame_duration_ms = 33;
   int drift_per_frame_ms = 10;
   int sigma_ms = 3;
   int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                         frame_duration_ms, sigma_ms);
-  EXPECT_EQ(0, unique_overuse);
+  EXPECT_EQ(25, unique_overuse);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
-  EXPECT_EQ(6, frames_until_overuse);
+  EXPECT_EQ(4, frames_until_overuse);
 }
 
 TEST_F(OveruseDetectorTest, HighGaussianVariance2000Kbit30fps) {
   size_t packet_size = 1200;
   int packets_per_frame = 6;
   int frame_duration_ms = 33;
   int drift_per_frame_ms = 1;
   int sigma_ms = 10;
   int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                         frame_duration_ms, sigma_ms);
-  EXPECT_EQ(0, unique_overuse);
+  EXPECT_EQ(45, unique_overuse);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
-  EXPECT_EQ(41, frames_until_overuse);
+  EXPECT_EQ(31, frames_until_overuse);
 }
 
 TEST_F(OveruseDetectorTest, HighGaussianVarianceFastDrift2000Kbit30fps) {
   size_t packet_size = 1200;
   int packets_per_frame = 6;
   int frame_duration_ms = 33;
   int drift_per_frame_ms = 10;
   int sigma_ms = 10;
   int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
                                         frame_duration_ms, sigma_ms);
-  EXPECT_EQ(0, unique_overuse);
+  EXPECT_EQ(45, unique_overuse);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
-  EXPECT_EQ(10, frames_until_overuse);
+  EXPECT_EQ(6, frames_until_overuse);
 }
 
 class OveruseDetectorExperimentTest : public OveruseDetectorTest {
  public:
   OveruseDetectorExperimentTest()
       : override_field_trials_(
             "WebRTC-AdaptiveBweThreshold/Enabled-0.01,0.00018/") {}
 
  protected:
   void SetUp() override {
@@ skipping 118 matching lines @@
     if (overuse_state == kBwOverusing) {
       overuse_detected = true;
     }
     ++num_deltas;
     now_ms += 5;
   }
   EXPECT_TRUE(overuse_detected);
 }
 }  // namespace testing
 }  // namespace webrtc