Adds support for webrtc::test::ResourcePath on iOS

webrtc/modules/audio_coding/codecs/opus/opus_unittest.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 <string>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/modules/audio_coding/codecs/opus/interface/opus_interface.h"
 #include "webrtc/modules/audio_coding/codecs/opus/opus_inst.h"
 #include "webrtc/modules/audio_coding/neteq/tools/audio_loop.h"
 #include "webrtc/test/testsupport/fileutils.h"
-#include "webrtc/test/testsupport/gtest_disable.h"
 
 namespace webrtc {
 
 using test::AudioLoop;
 using ::testing::TestWithParam;
 using ::testing::Values;
 using ::testing::Combine;
 
 // Maximum number of bytes in output bitstream.
 const size_t kMaxBytes = 1000;
@@ skipping 212 matching lines @@
   }
 
   // Free memory.
   delete[] output_data_decode;
   delete[] silence;
   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_encoder_));
   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_decoder_));
 }
 
 // Test failing Create.
-TEST(OpusTest, DISABLED_ON_IOS(OpusCreateFail)) {
+TEST(OpusTest, OpusCreateFail) {
   WebRtcOpusEncInst* opus_encoder;
   WebRtcOpusDecInst* opus_decoder;
 
   // Test to see that an invalid pointer is caught.
   EXPECT_EQ(-1, WebRtcOpus_EncoderCreate(NULL, 1, 0));
   // Invalid channel number.
   EXPECT_EQ(-1, WebRtcOpus_EncoderCreate(&opus_encoder, 3, 0));
   // Invalid applciation mode.
   EXPECT_EQ(-1, WebRtcOpus_EncoderCreate(&opus_encoder, 1, 2));
 
   EXPECT_EQ(-1, WebRtcOpus_DecoderCreate(NULL, 1));
   // Invalid channel number.
   EXPECT_EQ(-1, WebRtcOpus_DecoderCreate(&opus_decoder, 3));
 }
 
 // Test failing Free.
-TEST(OpusTest, DISABLED_ON_IOS(OpusFreeFail)) {
+TEST(OpusTest, OpusFreeFail) {
   // Test to see that an invalid pointer is caught.
   EXPECT_EQ(-1, WebRtcOpus_EncoderFree(NULL));
   EXPECT_EQ(-1, WebRtcOpus_DecoderFree(NULL));
 }
 
 // Test normal Create and Free.
-TEST_P(OpusTest, DISABLED_ON_IOS(OpusCreateFree)) {
+TEST_P(OpusTest, OpusCreateFree) {
   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
                                         channels_,
                                         application_));
   EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_decoder_, channels_));
   EXPECT_TRUE(opus_encoder_ != NULL);
   EXPECT_TRUE(opus_decoder_ != NULL);
   // Free encoder and decoder memory.
   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_encoder_));
   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_decoder_));
 }
 
-TEST_P(OpusTest, DISABLED_ON_IOS(OpusEncodeDecode)) {
+TEST_P(OpusTest, OpusEncodeDecode) {
   PrepareSpeechData(channels_, 20, 20);
 
   // Create encoder memory.
   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
                                         channels_,
                                         application_));
   EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_decoder_,
                                         channels_));
 
   // Set bitrate.
@@ skipping 17 matching lines @@
             EncodeDecode(opus_encoder_, speech_data_.GetNextBlock(),
                          kOpus20msFrameSamples, opus_decoder_,
                          output_data_decode, &audio_type));
 
   // Free memory.
   delete[] output_data_decode;
   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_encoder_));
   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_decoder_));
 }
 
-TEST_P(OpusTest, DISABLED_ON_IOS(OpusSetBitRate)) {
+TEST_P(OpusTest, OpusSetBitRate) {
   // Test without creating encoder memory.
   EXPECT_EQ(-1, WebRtcOpus_SetBitRate(opus_encoder_, 60000));
 
   // Create encoder memory, try with different bitrates.
   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
                                         channels_,
                                         application_));
   EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_encoder_, 30000));
   EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_encoder_, 60000));
   EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_encoder_, 300000));
@@ skipping 15 matching lines @@
   EXPECT_EQ(0, WebRtcOpus_SetComplexity(opus_encoder_, 0));
   EXPECT_EQ(0, WebRtcOpus_SetComplexity(opus_encoder_, 10));
   EXPECT_EQ(-1, WebRtcOpus_SetComplexity(opus_encoder_, 11));
 
   // Free memory.
   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_encoder_));
 }
 
 // Encode and decode one frame, initialize the decoder and
 // decode once more.
-TEST_P(OpusTest, DISABLED_ON_IOS(OpusDecodeInit)) {
+TEST_P(OpusTest, OpusDecodeInit) {
   PrepareSpeechData(channels_, 20, 20);
 
   // Create encoder memory.
   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
                                         channels_,
                                         application_));
   EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_decoder_, channels_));
 
   // Encode & decode.
   int16_t audio_type;
   int16_t* output_data_decode = new int16_t[kOpus20msFrameSamples * channels_];
   EXPECT_EQ(kOpus20msFrameSamples,
             EncodeDecode(opus_encoder_, speech_data_.GetNextBlock(),
                          kOpus20msFrameSamples, opus_decoder_,
                          output_data_decode, &audio_type));
 
   EXPECT_EQ(0, WebRtcOpus_DecoderInit(opus_decoder_));
 
   EXPECT_EQ(kOpus20msFrameSamples,
             WebRtcOpus_Decode(opus_decoder_, bitstream_,
                               encoded_bytes_, output_data_decode,
                               &audio_type));
 
   // Free memory.
   delete[] output_data_decode;
   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_encoder_));
   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_decoder_));
 }
 
-TEST_P(OpusTest, DISABLED_ON_IOS(OpusEnableDisableFec)) {
+TEST_P(OpusTest, OpusEnableDisableFec) {
   // Test without creating encoder memory.
   EXPECT_EQ(-1, WebRtcOpus_EnableFec(opus_encoder_));
   EXPECT_EQ(-1, WebRtcOpus_DisableFec(opus_encoder_));
 
   // Create encoder memory.
   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
                                         channels_,
                                         application_));
 
   EXPECT_EQ(0, WebRtcOpus_EnableFec(opus_encoder_));
   EXPECT_EQ(0, WebRtcOpus_DisableFec(opus_encoder_));
 
   // Free memory.
   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_encoder_));
 }
 
-TEST_P(OpusTest, DISABLED_ON_IOS(OpusEnableDisableDtx)) {
+TEST_P(OpusTest, OpusEnableDisableDtx) {
   // Test without creating encoder memory.
   EXPECT_EQ(-1, WebRtcOpus_EnableDtx(opus_encoder_));
   EXPECT_EQ(-1, WebRtcOpus_DisableDtx(opus_encoder_));
 
   // Create encoder memory.
   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
                                         channels_,
                                         application_));
 
   opus_int32 dtx;
@@ skipping 13 matching lines @@
   EXPECT_EQ(0, WebRtcOpus_DisableDtx(opus_encoder_));
   opus_encoder_ctl(opus_encoder_->encoder,
                    OPUS_GET_DTX(&dtx));
   EXPECT_EQ(0, dtx);
 
 
   // Free memory.
   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_encoder_));
 }
 
-TEST_P(OpusTest, DISABLED_ON_IOS(OpusDtxOff)) {
+TEST_P(OpusTest, OpusDtxOff) {
   TestDtxEffect(false);
 }
 
-TEST_P(OpusTest, DISABLED_ON_IOS(OpusDtxOn)) {
+TEST_P(OpusTest, OpusDtxOn) {
   TestDtxEffect(true);
 }
 
-TEST_P(OpusTest, DISABLED_ON_IOS(OpusSetPacketLossRate)) {
+TEST_P(OpusTest, OpusSetPacketLossRate) {
   // Test without creating encoder memory.
   EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_encoder_, 50));
 
   // Create encoder memory.
   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
                                         channels_,
                                         application_));
 
   EXPECT_EQ(0, WebRtcOpus_SetPacketLossRate(opus_encoder_, 50));
   EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_encoder_, -1));
   EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_encoder_, 101));
 
   // Free memory.
   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_encoder_));
 }
 
-TEST_P(OpusTest, DISABLED_ON_IOS(OpusSetMaxPlaybackRate)) {
+TEST_P(OpusTest, OpusSetMaxPlaybackRate) {
   // Test without creating encoder memory.
   EXPECT_EQ(-1, WebRtcOpus_SetMaxPlaybackRate(opus_encoder_, 20000));
 
   // Create encoder memory.
   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
                                         channels_,
                                         application_));
 
   SetMaxPlaybackRate(opus_encoder_, OPUS_BANDWIDTH_FULLBAND, 48000);
   SetMaxPlaybackRate(opus_encoder_, OPUS_BANDWIDTH_FULLBAND, 24001);
   SetMaxPlaybackRate(opus_encoder_, OPUS_BANDWIDTH_SUPERWIDEBAND, 24000);
   SetMaxPlaybackRate(opus_encoder_, OPUS_BANDWIDTH_SUPERWIDEBAND, 16001);
   SetMaxPlaybackRate(opus_encoder_, OPUS_BANDWIDTH_WIDEBAND, 16000);
   SetMaxPlaybackRate(opus_encoder_, OPUS_BANDWIDTH_WIDEBAND, 12001);
   SetMaxPlaybackRate(opus_encoder_, OPUS_BANDWIDTH_MEDIUMBAND, 12000);
   SetMaxPlaybackRate(opus_encoder_, OPUS_BANDWIDTH_MEDIUMBAND, 8001);
   SetMaxPlaybackRate(opus_encoder_, OPUS_BANDWIDTH_NARROWBAND, 8000);
   SetMaxPlaybackRate(opus_encoder_, OPUS_BANDWIDTH_NARROWBAND, 4000);
 
   // Free memory.
   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_encoder_));
 }
 
 // Test PLC.
-TEST_P(OpusTest, DISABLED_ON_IOS(OpusDecodePlc)) {
+TEST_P(OpusTest, OpusDecodePlc) {
   PrepareSpeechData(channels_, 20, 20);
 
   // Create encoder memory.
   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
                                         channels_,
                                         application_));
   EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_decoder_, channels_));
 
   // Set bitrate.
   EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_encoder_,
@@ skipping 16 matching lines @@
             WebRtcOpus_DecodePlc(opus_decoder_, plc_buffer, 1));
 
   // Free memory.
   delete[] plc_buffer;
   delete[] output_data_decode;
   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_encoder_));
   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_decoder_));
 }
 
 // Duration estimation.
-TEST_P(OpusTest, DISABLED_ON_IOS(OpusDurationEstimation)) {
+TEST_P(OpusTest, OpusDurationEstimation) {
   PrepareSpeechData(channels_, 20, 20);
 
   // Create.
   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
                                         channels_,
                                         application_));
   EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_decoder_, channels_));
 
   // 10 ms. We use only first 10 ms of a 20 ms block.
   encoded_bytes_ = WebRtcOpus_Encode(opus_encoder_,
@@ skipping 11 matching lines @@
                                      bitstream_);
   EXPECT_EQ(kOpus20msFrameSamples,
             WebRtcOpus_DurationEst(opus_decoder_, bitstream_,
                                    encoded_bytes_));
 
   // Free memory.
   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_encoder_));
   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_decoder_));
 }
 
-TEST_P(OpusTest, DISABLED_ON_IOS(OpusDecodeRepacketized)) {
+TEST_P(OpusTest, OpusDecodeRepacketized) {
   const int kPackets = 6;
 
   PrepareSpeechData(channels_, 20, 20 * kPackets);
 
   // Create encoder memory.
   ASSERT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
                                         channels_,
                                         application_));
   ASSERT_EQ(0, WebRtcOpus_DecoderCreate(&opus_decoder_,
                                         channels_));
@@ skipping 33 matching lines @@
   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_encoder_));
   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_decoder_));
 }
 
 INSTANTIATE_TEST_CASE_P(VariousMode,
                         OpusTest,
                         Combine(Values(1, 2), Values(0, 1)));
 
 
 }  // namespace webrtc