Remove DISABLED_ON_ macros.

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.
  */
 
 #include <math.h>
 
 #include <algorithm>
 #include <cmath>
 #include <cstdlib>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "webrtc/base/random.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/remote_bitrate_estimator/inter_arrival.h"
 #include "webrtc/modules/remote_bitrate_estimator/overuse_detector.h"
 #include "webrtc/modules/remote_bitrate_estimator/overuse_estimator.h"
 #include "webrtc/modules/remote_bitrate_estimator/rate_statistics.h"
 #include "webrtc/test/field_trial.h"
-#include "webrtc/test/testsupport/gtest_disable.h"
 
 namespace webrtc {
 namespace testing {
 
 const double kRtpTimestampToMs = 1.0 / 90.0;
 
 class OveruseDetectorTest : public ::testing::Test {
  public:
   OveruseDetectorTest()
       : now_ms_(0),
@@ skipping 273 matching lines @@
     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());
 }
 
-TEST_F(OveruseDetectorTest,
-       DISABLED_ON_ANDROID(LowGaussianVariance30Kbit3fps)) {
+#if defined(WEBRTC_ANDROID)
+TEST_F(OveruseDetectorTest, DISABLED_LowGaussianVariance30Kbit3fps) {
+#else
+TEST_F(OveruseDetectorTest, LowGaussianVariance30Kbit3fps) {
+#endif
   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);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
@@ skipping 35 matching lines @@
   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);
   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,
-       DISABLED_ON_ANDROID(LowGaussianVariance100Kbit5fps)) {
+#if defined(WEBRTC_ANDROID)
+TEST_F(OveruseDetectorTest, DISABLED_LowGaussianVariance100Kbit5fps) {
+#else
+TEST_F(OveruseDetectorTest, LowGaussianVariance100Kbit5fps) {
+#endif
   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);
   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);
 }
 
-TEST_F(OveruseDetectorTest,
-       DISABLED_ON_ANDROID(HighGaussianVariance100Kbit5fps)) {
+#if defined(WEBRTC_ANDROID)
+TEST_F(OveruseDetectorTest, DISABLED_HighGaussianVariance100Kbit5fps) {
+#else
+TEST_F(OveruseDetectorTest, HighGaussianVariance100Kbit5fps) {
+#endif
   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);
   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);
 }
 
-TEST_F(OveruseDetectorTest,
-       DISABLED_ON_ANDROID(LowGaussianVariance100Kbit10fps)) {
+#if defined(WEBRTC_ANDROID)
+TEST_F(OveruseDetectorTest, DISABLED_LowGaussianVariance100Kbit10fps) {
+#else
+TEST_F(OveruseDetectorTest, LowGaussianVariance100Kbit10fps) {
+#endif
   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);
   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);
 }
 
-TEST_F(OveruseDetectorTest,
-       DISABLED_ON_ANDROID(HighGaussianVariance100Kbit10fps)) {
+#if defined(WEBRTC_ANDROID)
+TEST_F(OveruseDetectorTest, DISABLED_HighGaussianVariance100Kbit10fps) {
+#else
+TEST_F(OveruseDetectorTest, HighGaussianVariance100Kbit10fps) {
+#endif
   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);
   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);
 }
 
-TEST_F(OveruseDetectorTest,
-       DISABLED_ON_ANDROID(LowGaussianVariance300Kbit30fps)) {
+#if defined(WEBRTC_ANDROID)
+TEST_F(OveruseDetectorTest, DISABLED_LowGaussianVariance300Kbit30fps) {
+#else
+TEST_F(OveruseDetectorTest, LowGaussianVariance300Kbit30fps) {
+#endif
   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);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
@@ skipping 35 matching lines @@
   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);
   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);
 }
 
-TEST_F(OveruseDetectorTest,
-       DISABLED_ON_ANDROID(LowGaussianVariance1000Kbit30fps)) {
+#if defined(WEBRTC_ANDROID)
+TEST_F(OveruseDetectorTest, DISABLED_LowGaussianVariance1000Kbit30fps) {
+#else
+TEST_F(OveruseDetectorTest, LowGaussianVariance1000Kbit30fps) {
+#endif
   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);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
@@ skipping 35 matching lines @@
   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);
   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);
 }
 
-TEST_F(OveruseDetectorTest,
-       DISABLED_ON_ANDROID(LowGaussianVariance2000Kbit30fps)) {
+#if defined(WEBRTC_ANDROID)
+TEST_F(OveruseDetectorTest, DISABLED_LowGaussianVariance2000Kbit30fps) {
+#else
+TEST_F(OveruseDetectorTest, LowGaussianVariance2000Kbit30fps) {
+#endif
   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);
   int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size,
       frame_duration_ms, sigma_ms, drift_per_frame_ms);
@@ skipping 171 matching lines @@
     if (overuse_state == kBwOverusing) {
       overuse_detected = true;
     }
     ++num_deltas;
     now_ms += 5;
   }
   EXPECT_TRUE(overuse_detected);
 }
 }  // namespace testing
 }  // namespace webrtc