Remove DISABLED_ON_ macros.

webrtc/modules/audio_coding/acm2/acm_receiver_unittest_oldapi.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 "webrtc/modules/audio_coding/acm2/acm_receiver.h"
 
 #include <algorithm>  // std::min
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/modules/audio_coding/include/audio_coding_module.h"
 #include "webrtc/modules/audio_coding/acm2/audio_coding_module_impl.h"
 #include "webrtc/modules/audio_coding/neteq/tools/rtp_generator.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/test/test_suite.h"
 #include "webrtc/test/testsupport/fileutils.h"
-#include "webrtc/test/testsupport/gtest_disable.h"
 
 namespace webrtc {
 
 namespace acm2 {
 namespace {
 
 bool CodecsEqual(const CodecInst& codec_a, const CodecInst& codec_b) {
     if (strcmp(codec_a.plname, codec_b.plname) != 0 ||
         codec_a.plfreq != codec_b.plfreq ||
         codec_a.pltype != codec_b.pltype ||
@@ skipping 123 matching lines @@
   rtc::scoped_ptr<AcmReceiver> receiver_;
   rtc::ArrayView<const CodecInst> codecs_;
   rtc::scoped_ptr<AudioCodingModule> acm_;
   WebRtcRTPHeader rtp_header_;
   uint32_t timestamp_;
   bool packet_sent_;  // Set when SendData is called reset when inserting audio.
   uint32_t last_packet_send_timestamp_;
   FrameType last_frame_type_;
 };
 
-TEST_F(AcmReceiverTestOldApi, DISABLED_ON_ANDROID(AddCodecGetCodec)) {
+#if defined(WEBRTC_ANDROID)
+#define MAYBE_AddCodecGetCodec DISABLED_AddCodecGetCodec
+#else
+#define MAYBE_AddCodecGetCodec AddCodecGetCodec
+#endif
+TEST_F(AcmReceiverTestOldApi, MAYBE_AddCodecGetCodec) {
   // Add codec.
   for (size_t n = 0; n < codecs_.size(); ++n) {
     if (n & 0x1)  // Just add codecs with odd index.
       EXPECT_EQ(0,
                 receiver_->AddCodec(n, codecs_[n].pltype, codecs_[n].channels,
                                     codecs_[n].plfreq, NULL, ""));
   }
   // Get codec and compare.
   for (size_t n = 0; n < codecs_.size(); ++n) {
     CodecInst my_codec;
     if (n & 0x1) {
       // Codecs with odd index should match the reference.
       EXPECT_EQ(0, receiver_->DecoderByPayloadType(codecs_[n].pltype,
                                                    &my_codec));
       EXPECT_TRUE(CodecsEqual(codecs_[n], my_codec));
     } else {
       // Codecs with even index are not registered.
       EXPECT_EQ(-1, receiver_->DecoderByPayloadType(codecs_[n].pltype,
                                                     &my_codec));
     }
   }
 }
 
-TEST_F(AcmReceiverTestOldApi, DISABLED_ON_ANDROID(AddCodecChangePayloadType)) {
+#if defined(WEBRTC_ANDROID)
+#define MAYBE_AddCodecChangePayloadType DISABLED_AddCodecChangePayloadType
+#else
+#define MAYBE_AddCodecChangePayloadType AddCodecChangePayloadType
+#endif
+TEST_F(AcmReceiverTestOldApi, MAYBE_AddCodecChangePayloadType) {
   const CodecIdInst codec1(RentACodec::CodecId::kPCMA);
   CodecInst codec2 = codec1.inst;
   ++codec2.pltype;
   CodecInst test_codec;
 
   // Register the same codec with different payloads.
   EXPECT_EQ(0, receiver_->AddCodec(codec1.id, codec1.inst.pltype,
                                    codec1.inst.channels, codec1.inst.plfreq,
                                    nullptr, ""));
   EXPECT_EQ(0, receiver_->AddCodec(codec1.id, codec2.pltype, codec2.channels,
                                    codec2.plfreq, NULL, ""));
 
   // Both payload types should exist.
   EXPECT_EQ(0,
             receiver_->DecoderByPayloadType(codec1.inst.pltype, &test_codec));
   EXPECT_EQ(true, CodecsEqual(codec1.inst, test_codec));
   EXPECT_EQ(0, receiver_->DecoderByPayloadType(codec2.pltype, &test_codec));
   EXPECT_EQ(true, CodecsEqual(codec2, test_codec));
 }
 
-TEST_F(AcmReceiverTestOldApi, DISABLED_ON_ANDROID(AddCodecChangeCodecId)) {
+#if defined(WEBRTC_ANDROID)
+#define MAYBE_AddCodecChangeCodecId DISABLED_AddCodecChangeCodecId
+#else
+#define MAYBE_AddCodecChangeCodecId AddCodecChangeCodecId
+#endif
+TEST_F(AcmReceiverTestOldApi, AddCodecChangeCodecId) {
   const CodecIdInst codec1(RentACodec::CodecId::kPCMU);
   CodecIdInst codec2(RentACodec::CodecId::kPCMA);
   codec2.inst.pltype = codec1.inst.pltype;
   CodecInst test_codec;
 
   // Register the same payload type with different codec ID.
   EXPECT_EQ(0, receiver_->AddCodec(codec1.id, codec1.inst.pltype,
                                    codec1.inst.channels, codec1.inst.plfreq,
                                    nullptr, ""));
   EXPECT_EQ(0, receiver_->AddCodec(codec2.id, codec2.inst.pltype,
                                    codec2.inst.channels, codec2.inst.plfreq,
                                    nullptr, ""));
 
   // Make sure that the last codec is used.
   EXPECT_EQ(0,
             receiver_->DecoderByPayloadType(codec2.inst.pltype, &test_codec));
   EXPECT_EQ(true, CodecsEqual(codec2.inst, test_codec));
 }
 
-TEST_F(AcmReceiverTestOldApi, DISABLED_ON_ANDROID(AddCodecRemoveCodec)) {
+#if defined(WEBRTC_ANDROID)
+#define MAYBE_AddCodecRemoveCodec DISABLED_AddCodecRemoveCodec
+#else
+#define MAYBE_AddCodecRemoveCodec AddCodecRemoveCodec
+#endif
+TEST_F(AcmReceiverTestOldApi, MAYBE_AddCodecRemoveCodec) {
   const CodecIdInst codec(RentACodec::CodecId::kPCMA);
   const int payload_type = codec.inst.pltype;
   EXPECT_EQ(
       0, receiver_->AddCodec(codec.id, codec.inst.pltype, codec.inst.channels,
                              codec.inst.plfreq, nullptr, ""));
 
   // Remove non-existing codec should not fail. ACM1 legacy.
   EXPECT_EQ(0, receiver_->RemoveCodec(payload_type + 1));
 
   // Remove an existing codec.
   EXPECT_EQ(0, receiver_->RemoveCodec(payload_type));
 
   // Ask for the removed codec, must fail.
   CodecInst ci;
   EXPECT_EQ(-1, receiver_->DecoderByPayloadType(payload_type, &ci));
 }
 
-TEST_F(AcmReceiverTestOldApi, DISABLED_ON_ANDROID(SampleRate)) {
+#if defined(WEBRTC_ANDROID)
+#define MAYBE_SampleRate DISABLED_SampleRate
+#else
+#define MAYBE_SampleRate SampleRate
+#endif
+TEST_F(AcmReceiverTestOldApi, MAYBE_SampleRate) {
   const RentACodec::CodecId kCodecId[] = {RentACodec::CodecId::kISAC,
                                           RentACodec::CodecId::kISACSWB};
   AddSetOfCodecs(kCodecId);
 
   AudioFrame frame;
   const int kOutSampleRateHz = 8000;  // Different than codec sample rate.
   for (const auto codec_id : kCodecId) {
     const CodecIdInst codec(codec_id);
     const int num_10ms_frames = codec.inst.pacsize / (codec.inst.plfreq / 100);
     InsertOnePacketOfSilence(codec.id);
     for (int k = 0; k < num_10ms_frames; ++k) {
       EXPECT_EQ(0, receiver_->GetAudio(kOutSampleRateHz, &frame));
     }
     EXPECT_EQ(codec.inst.plfreq, receiver_->last_output_sample_rate_hz());
   }
 }
 
-TEST_F(AcmReceiverTestOldApi, DISABLED_ON_ANDROID(PostdecodingVad)) {
+#if defined(WEBRTC_ANDROID)
+#define MAYBE_PostdecodingVad DISABLED_PostdecodingVad
+#else
+#define MAYBE_PostdecodingVad PostdecodingVad
+#endif
+TEST_F(AcmReceiverTestOldApi, MAYBE_PostdecodingVad) {
   receiver_->EnableVad();
   EXPECT_TRUE(receiver_->vad_enabled());
   const CodecIdInst codec(RentACodec::CodecId::kPCM16Bwb);
   ASSERT_EQ(
       0, receiver_->AddCodec(codec.id, codec.inst.pltype, codec.inst.channels,
                              codec.inst.plfreq, nullptr, ""));
   const int kNumPackets = 5;
   const int num_10ms_frames = codec.inst.pacsize / (codec.inst.plfreq / 100);
   AudioFrame frame;
   for (int n = 0; n < kNumPackets; ++n) {
     InsertOnePacketOfSilence(codec.id);
     for (int k = 0; k < num_10ms_frames; ++k)
       ASSERT_EQ(0, receiver_->GetAudio(codec.inst.plfreq, &frame));
   }
   EXPECT_EQ(AudioFrame::kVadPassive, frame.vad_activity_);
 
   receiver_->DisableVad();
   EXPECT_FALSE(receiver_->vad_enabled());
 
   for (int n = 0; n < kNumPackets; ++n) {
     InsertOnePacketOfSilence(codec.id);
     for (int k = 0; k < num_10ms_frames; ++k)
       ASSERT_EQ(0, receiver_->GetAudio(codec.inst.plfreq, &frame));
   }
   EXPECT_EQ(AudioFrame::kVadUnknown, frame.vad_activity_);
 }
 
-#ifdef WEBRTC_CODEC_ISAC
-#define IF_ISAC_FLOAT(x) x
+#if defined(WEBRTC_ANDROID)
+#define MAYBE_LastAudioCodec DISABLED_LastAudioCodec
 #else
-#define IF_ISAC_FLOAT(x) DISABLED_##x
+#define MAYBE_LastAudioCodec LastAudioCodec
 #endif
-
-TEST_F(AcmReceiverTestOldApi,
-       DISABLED_ON_ANDROID(IF_ISAC_FLOAT(LastAudioCodec))) {
+#if defined(WEBRTC_CODEC_ISAC)
+TEST_F(AcmReceiverTestOldApi, MAYBE_LastAudioCodec) {
   const RentACodec::CodecId kCodecId[] = {
       RentACodec::CodecId::kISAC, RentACodec::CodecId::kPCMA,
       RentACodec::CodecId::kISACSWB, RentACodec::CodecId::kPCM16Bswb32kHz};
   AddSetOfCodecs(kCodecId);
 
   const RentACodec::CodecId kCngId[] = {
       // Not including full-band.
       RentACodec::CodecId::kCNNB, RentACodec::CodecId::kCNWB,
       RentACodec::CodecId::kCNSWB};
   AddSetOfCodecs(kCngId);
@@ skipping 42 matching lines @@
       packet_sent_ = false;
       InsertOnePacketOfSilence(c.id);
       ASSERT_TRUE(packet_sent_);
     }
     EXPECT_EQ(rtc::Optional<int>(c.inst.plfreq),
               receiver_->last_packet_sample_rate_hz());
     EXPECT_EQ(0, receiver_->LastAudioCodec(&codec));
     EXPECT_TRUE(CodecsEqual(c.inst, codec));
   }
 }
+#endif
 
 }  // namespace acm2
 
 }  // namespace webrtc