Remove DISABLED_ON_ macros.

webrtc/modules/audio_coding/acm2/audio_coding_module_unittest_oldapi.cc

 /*
  *  Copyright (c) 2014 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 23 matching lines @@
 #include "webrtc/modules/audio_coding/neteq/tools/input_audio_file.h"
 #include "webrtc/modules/audio_coding/neteq/tools/output_audio_file.h"
 #include "webrtc/modules/audio_coding/neteq/tools/packet.h"
 #include "webrtc/modules/audio_coding/neteq/tools/rtp_file_source.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/event_wrapper.h"
 #include "webrtc/system_wrappers/include/sleep.h"
 #include "webrtc/test/testsupport/fileutils.h"
-#include "webrtc/test/testsupport/gtest_disable.h"
 
 using ::testing::AtLeast;
 using ::testing::Invoke;
 using ::testing::_;
 
 namespace webrtc {
 
 namespace {
 const int kSampleRateHz = 16000;
 const int kNumSamples10ms = kSampleRateHz / 100;
@@ skipping 176 matching lines @@
   rtc::scoped_ptr<AudioCodingModule> acm_;
   PacketizationCallbackStubOldApi packet_cb_;
   WebRtcRTPHeader rtp_header_;
   AudioFrame input_frame_;
   CodecInst codec_;
   Clock* clock_;
 };
 
 // Check if the statistics are initialized correctly. Before any call to ACM
 // all fields have to be zero.
-TEST_F(AudioCodingModuleTestOldApi, DISABLED_ON_ANDROID(InitializedToZero)) {
+#if defined(WEBRTC_ANDROID)
+TEST_F(AudioCodingModuleTestOldApi, DISABLED_InitializedToZero) {
+#else
+TEST_F(AudioCodingModuleTestOldApi, InitializedToZero) {
+#endif
   RegisterCodec();
   AudioDecodingCallStats stats;
   acm_->GetDecodingCallStatistics(&stats);
   EXPECT_EQ(0, stats.calls_to_neteq);
   EXPECT_EQ(0, stats.calls_to_silence_generator);
   EXPECT_EQ(0, stats.decoded_normal);
   EXPECT_EQ(0, stats.decoded_cng);
   EXPECT_EQ(0, stats.decoded_plc);
   EXPECT_EQ(0, stats.decoded_plc_cng);
 }
 
 // Insert some packets and pull audio. Check statistics are valid. Then,
 // simulate packet loss and check if PLC and PLC-to-CNG statistics are
 // correctly updated.
-TEST_F(AudioCodingModuleTestOldApi, DISABLED_ON_ANDROID(NetEqCalls)) {
+#if defined(WEBRTC_ANDROID)
+TEST_F(AudioCodingModuleTestOldApi, DISABLED_NetEqCalls) {
+#else
+TEST_F(AudioCodingModuleTestOldApi, NetEqCalls) {
+#endif
   RegisterCodec();
   AudioDecodingCallStats stats;
   const int kNumNormalCalls = 10;
 
   for (int num_calls = 0; num_calls < kNumNormalCalls; ++num_calls) {
     InsertPacketAndPullAudio();
   }
   acm_->GetDecodingCallStatistics(&stats);
   EXPECT_EQ(kNumNormalCalls, stats.calls_to_neteq);
   EXPECT_EQ(0, stats.calls_to_silence_generator);
@@ skipping 46 matching lines @@
     EXPECT_EQ(i / k10MsBlocksPerPacket, packet_cb_.num_calls());
     if (packet_cb_.num_calls() > 0)
       EXPECT_EQ(kAudioFrameSpeech, packet_cb_.last_frame_type());
     InsertAudioAndVerifyEncoding();
   }
   EXPECT_EQ(kLoops / k10MsBlocksPerPacket, packet_cb_.num_calls());
   EXPECT_EQ(kAudioFrameSpeech, packet_cb_.last_frame_type());
 }
 
 #if defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX)
-#define IF_ISAC(x) x
-#else
-#define IF_ISAC(x) DISABLED_##x
-#endif
-
 // Verifies that the RTP timestamp series is not reset when the codec is
 // changed.
-TEST_F(AudioCodingModuleTestOldApi,
-       IF_ISAC(TimestampSeriesContinuesWhenCodecChanges)) {
+TEST_F(AudioCodingModuleTestOldApi, TimestampSeriesContinuesWhenCodecChanges) {
   RegisterCodec();  // This registers the default codec.
   uint32_t expected_ts = input_frame_.timestamp_;
   int blocks_per_packet = codec_.pacsize / (kSampleRateHz / 100);
   // Encode 5 packets of the first codec type.
   const int kNumPackets1 = 5;
   for (int j = 0; j < kNumPackets1; ++j) {
     for (int i = 0; i < blocks_per_packet; ++i) {
       EXPECT_EQ(j, packet_cb_.num_calls());
       InsertAudio();
     }
@@ skipping 11 matching lines @@
   for (int j = 0; j < kNumPackets2; ++j) {
     for (int i = 0; i < blocks_per_packet; ++i) {
       EXPECT_EQ(kNumPackets1 + j, packet_cb_.num_calls());
       InsertAudio();
     }
     EXPECT_EQ(kNumPackets1 + j + 1, packet_cb_.num_calls());
     EXPECT_EQ(expected_ts, packet_cb_.last_timestamp());
     expected_ts += codec_.pacsize;
   }
 }
+#endif
 
 // Introduce this class to set different expectations on the number of encoded
 // bytes. This class expects all encoded packets to be 9 bytes (matching one
 // CNG SID frame) or 0 bytes. This test depends on |input_frame_| containing
 // (near-)zero values. It also introduces a way to register comfort noise with
 // a custom payload type.
 class AudioCodingModuleTestWithComfortNoiseOldApi
     : public AudioCodingModuleTestOldApi {
  protected:
   void RegisterCngCodec(int rtp_payload_type) {
@@ skipping 202 matching lines @@
   rtc::PlatformThread pull_audio_thread_;
   const rtc::scoped_ptr<EventWrapper> test_complete_;
   int send_count_;
   int insert_packet_count_;
   int pull_audio_count_ GUARDED_BY(crit_sect_);
   const rtc::scoped_ptr<CriticalSectionWrapper> crit_sect_;
   int64_t next_insert_packet_time_ms_ GUARDED_BY(crit_sect_);
   rtc::scoped_ptr<SimulatedClock> fake_clock_;
 };
 
-TEST_F(AudioCodingModuleMtTestOldApi, DISABLED_ON_IOS(DoTest)) {
+#if defined(WEBRTC_IOS)
+TEST_F(AudioCodingModuleMtTestOldApi, DISABLED_DoTest) {
+#else
+TEST_F(AudioCodingModuleMtTestOldApi, DoTest) {
+#endif
   EXPECT_EQ(kEventSignaled, RunTest());
 }
 
 // This is a multi-threaded ACM test using iSAC. The test encodes audio
 // from a PCM file. The most recent encoded frame is used as input to the
 // receiving part. Depending on timing, it may happen that the same RTP packet
 // is inserted into the receiver multiple times, but this is a valid use-case,
 // and simplifies the test code a lot.
 class AcmIsacMtTestOldApi : public AudioCodingModuleMtTestOldApi {
  protected:
@@ skipping 83 matching lines @@
       }
     }
     return false;
   }
 
   int last_packet_number_;
   std::vector<uint8_t> last_payload_vec_;
   test::AudioLoop audio_loop_;
 };
 
-TEST_F(AcmIsacMtTestOldApi, DISABLED_ON_IOS(IF_ISAC(DoTest))) {
+#if defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX)
+#if defined(WEBRTC_IOS)
+TEST_F(AcmIsacMtTestOldApi, DISABLED_DoTest) {
+#else
+TEST_F(AcmIsacMtTestOldApi, DoTest) {
+#endif
   EXPECT_EQ(kEventSignaled, RunTest());
 }
+#endif
 
 class AcmReRegisterIsacMtTestOldApi : public AudioCodingModuleTestOldApi {
  protected:
   static const int kRegisterAfterNumPackets = 5;
   static const int kNumPackets = 10;
   static const int kPacketSizeMs = 30;
   static const int kPacketSizeSamples = kPacketSizeMs * 16;
 
   AcmReRegisterIsacMtTestOldApi()
       : AudioCodingModuleTestOldApi(),
@@ skipping 129 matching lines @@
   const rtc::scoped_ptr<EventWrapper> test_complete_;
   const rtc::scoped_ptr<CriticalSectionWrapper> crit_sect_;
   bool codec_registered_ GUARDED_BY(crit_sect_);
   int receive_packet_count_ GUARDED_BY(crit_sect_);
   int64_t next_insert_packet_time_ms_ GUARDED_BY(crit_sect_);
   rtc::scoped_ptr<AudioEncoderIsac> isac_encoder_;
   rtc::scoped_ptr<SimulatedClock> fake_clock_;
   test::AudioLoop audio_loop_;
 };
 
-TEST_F(AcmReRegisterIsacMtTestOldApi, DISABLED_ON_IOS(IF_ISAC(DoTest))) {
+#if defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX)
+#if defined(WEBRTC_IOS)
+TEST_F(AcmReRegisterIsacMtTestOldApi, DISABLED_DoTest) {
+#else
+TEST_F(AcmReRegisterIsacMtTestOldApi, DoTest) {
+#endif
   EXPECT_EQ(kEventSignaled, RunTest());
 }
+#endif
 
 // Disabling all of these tests on iOS until file support has been added.
 // See https://code.google.com/p/webrtc/issues/detail?id=4752 for details.
 #if !defined(WEBRTC_IOS)
 
 class AcmReceiverBitExactnessOldApi : public ::testing::Test {
  public:
   static std::string PlatformChecksum(std::string others,
                                       std::string win64,
                                       std::string android_arm32,
@@ skipping 333 matching lines @@
   rtc::scoped_ptr<test::AcmSendTestOldApi> send_test_;
   rtc::scoped_ptr<test::InputAudioFile> audio_source_;
   uint32_t frame_size_rtp_timestamps_;
   int packet_count_;
   uint8_t payload_type_;
   uint16_t last_sequence_number_;
   uint32_t last_timestamp_;
   rtc::Md5Digest payload_checksum_;
 };
 
-TEST_F(AcmSenderBitExactnessOldApi, IF_ISAC(IsacWb30ms)) {
+#if defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX)
+TEST_F(AcmSenderBitExactnessOldApi, IsacWb30ms) {
   ASSERT_NO_FATAL_FAILURE(SetUpTest("ISAC", 16000, 1, 103, 480, 480));
   Run(AcmReceiverBitExactnessOldApi::PlatformChecksum(
           "0b58f9eeee43d5891f5f6c75e77984a3",
           "c7e5bdadfa2871df95639fcc297cf23d",
           "0499ca260390769b3172136faad925b9",
           "866abf524acd2807efbe65e133c23f95"),
       AcmReceiverBitExactnessOldApi::PlatformChecksum(
           "3c79f16f34218271f3dca4e2b1dfe1bb",
           "d42cb5195463da26c8129bbfe73a22e6",
           "83de248aea9c3c2bd680b6952401b4ca",
           "3c79f16f34218271f3dca4e2b1dfe1bb"),
       33, test::AcmReceiveTestOldApi::kMonoOutput);
 }
 
-TEST_F(AcmSenderBitExactnessOldApi, IF_ISAC(IsacWb60ms)) {
+TEST_F(AcmSenderBitExactnessOldApi, IsacWb60ms) {
   ASSERT_NO_FATAL_FAILURE(SetUpTest("ISAC", 16000, 1, 103, 960, 960));
   Run(AcmReceiverBitExactnessOldApi::PlatformChecksum(
           "1ad29139a04782a33daad8c2b9b35875",
           "14d63c5f08127d280e722e3191b73bdd",
           "8da003e16c5371af2dc2be79a50f9076",
           "ef75e900e6f375e3061163c53fd09a63"),
       AcmReceiverBitExactnessOldApi::PlatformChecksum(
           "9e0a0ab743ad987b55b8e14802769c56",
           "ebe04a819d3a9d83a83a17f271e1139a",
           "97aeef98553b5a4b5a68f8b716e8eaf0",
           "9e0a0ab743ad987b55b8e14802769c56"),
       16, test::AcmReceiveTestOldApi::kMonoOutput);
 }
-
-#ifdef WEBRTC_CODEC_ISAC
-#define IF_ISAC_FLOAT(x) x
-#else
-#define IF_ISAC_FLOAT(x) DISABLED_##x
 #endif
 
-TEST_F(AcmSenderBitExactnessOldApi,
-       DISABLED_ON_ANDROID(IF_ISAC_FLOAT(IsacSwb30ms))) {
+#if defined(WEBRTC_CODEC_ISAC)
+#if defined(WEBRTC_ANDROID)
+TEST_F(AcmSenderBitExactnessOldApi, DISABLED_IsacSwb30ms) {
+#else
+TEST_F(AcmSenderBitExactnessOldApi, IsacSwb30ms) {
+#endif
   ASSERT_NO_FATAL_FAILURE(SetUpTest("ISAC", 32000, 1, 104, 960, 960));
   Run(AcmReceiverBitExactnessOldApi::PlatformChecksum(
           "5683b58da0fbf2063c7adc2e6bfb3fb8",
           "2b3c387d06f00b7b7aad4c9be56fb83d", "android_arm32_audio",
           "android_arm64_audio"),
       AcmReceiverBitExactnessOldApi::PlatformChecksum(
           "ce86106a93419aefb063097108ec94ab",
           "bcc2041e7744c7ebd9f701866856849c", "android_arm32_payload",
           "android_arm64_payload"),
       33, test::AcmReceiveTestOldApi::kMonoOutput);
 }
+#endif
 
 TEST_F(AcmSenderBitExactnessOldApi, Pcm16_8000khz_10ms) {
   ASSERT_NO_FATAL_FAILURE(SetUpTest("L16", 8000, 1, 107, 80, 80));
   Run("de4a98e1406f8b798d99cd0704e862e2",
       "c1edd36339ce0326cc4550041ad719a0",
       100,
       test::AcmReceiveTestOldApi::kMonoOutput);
 }
 
 TEST_F(AcmSenderBitExactnessOldApi, Pcm16_16000khz_10ms) {
@@ skipping 61 matching lines @@
 }
 
 TEST_F(AcmSenderBitExactnessOldApi, Pcma_stereo_20ms) {
   ASSERT_NO_FATAL_FAILURE(SetUpTest("PCMA", 8000, 2, 118, 160, 160));
   Run("a5c6d83c5b7cedbeff734238220a4b0c",
       "92b282c83efd20e7eeef52ba40842cf7",
       50,
       test::AcmReceiveTestOldApi::kStereoOutput);
 }
 
-#ifdef WEBRTC_CODEC_ILBC
-#define IF_ILBC(x) x
+#if defined(WEBRTC_CODEC_ILBC)
+#if defined(WEBRTC_ANDROID)
+TEST_F(AcmSenderBitExactnessOldApi, DISABLED_Ilbc_30ms) {
 #else
-#define IF_ILBC(x) DISABLED_##x
+TEST_F(AcmSenderBitExactnessOldApi, Ilbc_30ms) {
 #endif
-
-TEST_F(AcmSenderBitExactnessOldApi, DISABLED_ON_ANDROID(IF_ILBC(Ilbc_30ms))) {
   ASSERT_NO_FATAL_FAILURE(SetUpTest("ILBC", 8000, 1, 102, 240, 240));
   Run(AcmReceiverBitExactnessOldApi::PlatformChecksum(
           "7b6ec10910debd9af08011d3ed5249f7",
           "7b6ec10910debd9af08011d3ed5249f7", "android_arm32_audio",
           "android_arm64_audio"),
       AcmReceiverBitExactnessOldApi::PlatformChecksum(
           "cfae2e9f6aba96e145f2bcdd5050ce78",
           "cfae2e9f6aba96e145f2bcdd5050ce78", "android_arm32_payload",
           "android_arm64_payload"),
       33, test::AcmReceiveTestOldApi::kMonoOutput);
 }
-
-#ifdef WEBRTC_CODEC_G722
-#define IF_G722(x) x
-#else
-#define IF_G722(x) DISABLED_##x
 #endif
 
-TEST_F(AcmSenderBitExactnessOldApi, DISABLED_ON_ANDROID(IF_G722(G722_20ms))) {
+#if defined(WEBRTC_CODEC_G722)
+#if defined(WEBRTC_ANDROID)
+TEST_F(AcmSenderBitExactnessOldApi, DISABLED_G722_20ms) {
+#else
+TEST_F(AcmSenderBitExactnessOldApi, G722_20ms) {
+#endif
   ASSERT_NO_FATAL_FAILURE(SetUpTest("G722", 16000, 1, 9, 320, 160));
   Run(AcmReceiverBitExactnessOldApi::PlatformChecksum(
           "7d759436f2533582950d148b5161a36c",
           "7d759436f2533582950d148b5161a36c", "android_arm32_audio",
           "android_arm64_audio"),
       AcmReceiverBitExactnessOldApi::PlatformChecksum(
           "fc68a87e1380614e658087cb35d5ca10",
           "fc68a87e1380614e658087cb35d5ca10", "android_arm32_payload",
           "android_arm64_payload"),
       50, test::AcmReceiveTestOldApi::kMonoOutput);
 }
 
-TEST_F(AcmSenderBitExactnessOldApi,
-       DISABLED_ON_ANDROID(IF_G722(G722_stereo_20ms))) {
+#if defined(WEBRTC_ANDROID)
+TEST_F(AcmSenderBitExactnessOldApi, DISABLED_G722_stereo_20ms) {
+#else
+TEST_F(AcmSenderBitExactnessOldApi, G722_stereo_20ms) {
+#endif
   ASSERT_NO_FATAL_FAILURE(SetUpTest("G722", 16000, 2, 119, 320, 160));
   Run(AcmReceiverBitExactnessOldApi::PlatformChecksum(
           "7190ee718ab3d80eca181e5f7140c210",
           "7190ee718ab3d80eca181e5f7140c210", "android_arm32_audio",
           "android_arm64_audio"),
       AcmReceiverBitExactnessOldApi::PlatformChecksum(
           "66516152eeaa1e650ad94ff85f668dac",
           "66516152eeaa1e650ad94ff85f668dac", "android_arm32_payload",
           "android_arm64_payload"),
       50, test::AcmReceiveTestOldApi::kStereoOutput);
 }
+#endif
 
 TEST_F(AcmSenderBitExactnessOldApi, Opus_stereo_20ms) {
   ASSERT_NO_FATAL_FAILURE(SetUpTest("opus", 48000, 2, 120, 960, 960));
   Run(AcmReceiverBitExactnessOldApi::PlatformChecksum(
           "855041f2490b887302bce9d544731849",
           "855041f2490b887302bce9d544731849",
           "1e1a0fce893fef2d66886a7f09e2ebce",
           "7417a66c28be42d5d9b2d64e0c191585"),
       AcmReceiverBitExactnessOldApi::PlatformChecksum(
           "d781cce1ab986b618d0da87226cdde30",
@@ skipping 95 matching lines @@
   ASSERT_NO_FATAL_FAILURE(SetUpTest("opus", 48000, 1, 107, 960, 960));
 #if defined(WEBRTC_ANDROID)
   Run(50000, 47952);
 #else
   Run(50000, 49600);
 #endif // WEBRTC_ANDROID
 }
 
 // The result on the Android platforms is inconsistent for this test case.
 // On android_rel the result is different from android and android arm64 rel.
-TEST_F(AcmSetBitRateOldApi, DISABLED_ON_ANDROID(Opus_48khz_20ms_100kbps)) {
+#if defined(WEBRTC_ANDROID)
+TEST_F(AcmSetBitRateOldApi, DISABLED_Opus_48khz_20ms_100kbps) {
+#else
+TEST_F(AcmSetBitRateOldApi, Opus_48khz_20ms_100kbps) {
+#endif
   ASSERT_NO_FATAL_FAILURE(SetUpTest("opus", 48000, 1, 107, 960, 960));
   Run(100000, 100888);
 }
 
 // These next 2 tests ensure that the SetBitRate function has no effect on PCM
 TEST_F(AcmSetBitRateOldApi, Pcm16_8khz_10ms_8kbps) {
   ASSERT_NO_FATAL_FAILURE(SetUpTest("L16", 8000, 1, 107, 80, 80));
   Run(8000, 128000);
 }
 
@@ skipping 243 matching lines @@
   Run(16000, 8000, 1000);
 }
 
 TEST_F(AcmSwitchingOutputFrequencyOldApi, Toggle8KhzTo16Khz) {
   Run(8000, 16000, 1000);
 }
 
 #endif
 
 }  // namespace webrtc