Ensures that modules_unittests runs on iOS

webrtc/modules/audio_coding/codecs/cng/cng_unittest.cc

 /*
  *  Copyright (c) 2011 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/test/testsupport/fileutils.h"
+#include "webrtc/test/testsupport/gtest_disable.h"
 #include "webrtc_cng.h"
 
 namespace webrtc {
 
 enum {
   kSidShortIntervalUpdate = 1,
   kSidNormalIntervalUpdate = 100,
   kSidLongIntervalUpdate = 10000
 };
 
@@ skipping 30 matching lines @@
         webrtc::test::ResourcePath("audio_coding/testfile32kHz", "pcm");
   input_file = fopen(file_name.c_str(), "rb");
   ASSERT_TRUE(input_file != NULL);
   ASSERT_EQ(640, static_cast<int32_t>(fread(speech_data_, sizeof(int16_t),
                                              640, input_file)));
   fclose(input_file);
   input_file = NULL;
 }
 
 // Test failing Create.
-TEST_F(CngTest, CngCreateFail) {
+TEST_F(CngTest, DISABLED_ON_IOS(CngCreateFail)) {
   // Test to see that an invalid pointer is caught.
   EXPECT_EQ(-1, WebRtcCng_CreateEnc(NULL));
   EXPECT_EQ(-1, WebRtcCng_CreateDec(NULL));
 }
 
 // Test normal Create.
-TEST_F(CngTest, CngCreate) {
+TEST_F(CngTest, DISABLED_ON_IOS(CngCreate)) {
   EXPECT_EQ(0, WebRtcCng_CreateEnc(&cng_enc_inst_));
   EXPECT_EQ(0, WebRtcCng_CreateDec(&cng_dec_inst_));
   EXPECT_TRUE(cng_enc_inst_ != NULL);
   EXPECT_TRUE(cng_dec_inst_ != NULL);
   // Free encoder and decoder memory.
   EXPECT_EQ(0, WebRtcCng_FreeEnc(cng_enc_inst_));
   EXPECT_EQ(0, WebRtcCng_FreeDec(cng_dec_inst_));
 }
 
 // Create CNG encoder, init with faulty values, free CNG encoder.
-TEST_F(CngTest, CngInitFail) {
+TEST_F(CngTest, DISABLED_ON_IOS(CngInitFail)) {
   // Create encoder memory.
   EXPECT_EQ(0, WebRtcCng_CreateEnc(&cng_enc_inst_));
 
   // Call with too few parameters.
   EXPECT_EQ(-1, WebRtcCng_InitEnc(cng_enc_inst_, 8000, kSidNormalIntervalUpdate,
                                   kCNGNumParamsLow));
   EXPECT_EQ(6130, WebRtcCng_GetErrorCodeEnc(cng_enc_inst_));
 
   // Call with too many parameters.
   EXPECT_EQ(-1, WebRtcCng_InitEnc(cng_enc_inst_, 8000, kSidNormalIntervalUpdate,
                                   kCNGNumParamsTooHigh));
   EXPECT_EQ(6130, WebRtcCng_GetErrorCodeEnc(cng_enc_inst_));
 
   // Free encoder memory.
   EXPECT_EQ(0, WebRtcCng_FreeEnc(cng_enc_inst_));
 }
 
-TEST_F(CngTest, CngEncode) {
+TEST_F(CngTest, DISABLED_ON_IOS(CngEncode)) {
   uint8_t sid_data[WEBRTC_CNG_MAX_LPC_ORDER + 1];
   int16_t number_bytes;
 
   // Create encoder memory.
   EXPECT_EQ(0, WebRtcCng_CreateEnc(&cng_enc_inst_));
 
   // 8 kHz, Normal number of parameters
   EXPECT_EQ(0, WebRtcCng_InitEnc(cng_enc_inst_, 8000, kSidNormalIntervalUpdate,
                                  kCNGNumParamsNormal));
   EXPECT_EQ(0, WebRtcCng_Encode(cng_enc_inst_, speech_data_, 80, sid_data,
@@ skipping 31 matching lines @@
   EXPECT_EQ(0, WebRtcCng_Encode(cng_enc_inst_, speech_data_, 640, sid_data,
                                 &number_bytes, kNoSid));
   EXPECT_EQ(kCNGNumParamsNormal + 1, WebRtcCng_Encode(
       cng_enc_inst_, speech_data_, 640, sid_data, &number_bytes, kForceSid));
 
   // Free encoder memory.
   EXPECT_EQ(0, WebRtcCng_FreeEnc(cng_enc_inst_));
 }
 
 // Encode Cng with too long input vector.
-TEST_F(CngTest, CngEncodeTooLong) {
+TEST_F(CngTest, DISABLED_ON_IOS(CngEncodeTooLong)) {
   uint8_t sid_data[WEBRTC_CNG_MAX_LPC_ORDER + 1];
   int16_t number_bytes;
 
   // Create and init encoder memory.
   EXPECT_EQ(0, WebRtcCng_CreateEnc(&cng_enc_inst_));
   EXPECT_EQ(0, WebRtcCng_InitEnc(cng_enc_inst_, 8000, kSidNormalIntervalUpdate,
                                  kCNGNumParamsNormal));
 
   // Run encoder with too much data.
   EXPECT_EQ(-1, WebRtcCng_Encode(cng_enc_inst_, speech_data_, 641, sid_data,
                                  &number_bytes, kNoSid));
   EXPECT_EQ(6140, WebRtcCng_GetErrorCodeEnc(cng_enc_inst_));
 
   // Free encoder memory.
   EXPECT_EQ(0, WebRtcCng_FreeEnc(cng_enc_inst_));
 }
 
 // Call encode without calling init.
-TEST_F(CngTest, CngEncodeNoInit) {
+TEST_F(CngTest, DISABLED_ON_IOS(CngEncodeNoInit)) {
   uint8_t sid_data[WEBRTC_CNG_MAX_LPC_ORDER + 1];
   int16_t number_bytes;
 
   // Create encoder memory.
   EXPECT_EQ(0, WebRtcCng_CreateEnc(&cng_enc_inst_));
 
   // Run encoder without calling init.
   EXPECT_EQ(-1, WebRtcCng_Encode(cng_enc_inst_, speech_data_, 640, sid_data,
                                  &number_bytes, kNoSid));
   EXPECT_EQ(6120, WebRtcCng_GetErrorCodeEnc(cng_enc_inst_));
 
   // Free encoder memory.
   EXPECT_EQ(0, WebRtcCng_FreeEnc(cng_enc_inst_));
 }
 
 // Update SID parameters, for both 9 and 16 parameters.
-TEST_F(CngTest, CngUpdateSid) {
+TEST_F(CngTest, DISABLED_ON_IOS(CngUpdateSid)) {
   uint8_t sid_data[WEBRTC_CNG_MAX_LPC_ORDER + 1];
   int16_t number_bytes;
 
   // Create and initialize encoder and decoder memory.
   EXPECT_EQ(0, WebRtcCng_CreateEnc(&cng_enc_inst_));
   EXPECT_EQ(0, WebRtcCng_CreateDec(&cng_dec_inst_));
   EXPECT_EQ(0, WebRtcCng_InitEnc(cng_enc_inst_, 16000, kSidNormalIntervalUpdate,
                                  kCNGNumParamsNormal));
   EXPECT_EQ(0, WebRtcCng_InitDec(cng_dec_inst_));
 
@@ skipping 16 matching lines @@
       kForceSid));
   EXPECT_EQ(0, WebRtcCng_UpdateSid(cng_dec_inst_, sid_data,
                                    kCNGNumParamsNormal + 1));
 
   // Free encoder and decoder memory.
   EXPECT_EQ(0, WebRtcCng_FreeEnc(cng_enc_inst_));
   EXPECT_EQ(0, WebRtcCng_FreeDec(cng_dec_inst_));
 }
 
 // Update SID parameters, with wrong parameters or without calling decode.
-TEST_F(CngTest, CngUpdateSidErroneous) {
+TEST_F(CngTest, DISABLED_ON_IOS(CngUpdateSidErroneous)) {
   uint8_t sid_data[WEBRTC_CNG_MAX_LPC_ORDER + 1];
   int16_t number_bytes;
 
   // Create encoder and decoder memory.
   EXPECT_EQ(0, WebRtcCng_CreateEnc(&cng_enc_inst_));
   EXPECT_EQ(0, WebRtcCng_CreateDec(&cng_dec_inst_));
 
   // Encode.
   EXPECT_EQ(0, WebRtcCng_InitEnc(cng_enc_inst_, 16000, kSidNormalIntervalUpdate,
                                  kCNGNumParamsNormal));
@@ skipping 15 matching lines @@
                                    kCNGNumParamsNormal + 1));
   EXPECT_EQ(0, WebRtcCng_UpdateSid(cng_dec_inst_, sid_data,
                                    kCNGNumParamsTooHigh + 1));
 
   // Free encoder and decoder memory.
   EXPECT_EQ(0, WebRtcCng_FreeEnc(cng_enc_inst_));
   EXPECT_EQ(0, WebRtcCng_FreeDec(cng_dec_inst_));
 }
 
 // Test to generate cng data, by forcing SID. Both normal and faulty condition.
-TEST_F(CngTest, CngGenerate) {
+TEST_F(CngTest, DISABLED_ON_IOS(CngGenerate)) {
   uint8_t sid_data[WEBRTC_CNG_MAX_LPC_ORDER + 1];
   int16_t out_data[640];
   int16_t number_bytes;
 
   // Create and initialize encoder and decoder memory.
   EXPECT_EQ(0, WebRtcCng_CreateEnc(&cng_enc_inst_));
   EXPECT_EQ(0, WebRtcCng_CreateDec(&cng_dec_inst_));
   EXPECT_EQ(0, WebRtcCng_InitEnc(cng_enc_inst_, 16000, kSidNormalIntervalUpdate,
                                  kCNGNumParamsNormal));
   EXPECT_EQ(0, WebRtcCng_InitDec(cng_dec_inst_));
@@ skipping 13 matching lines @@
   // Call Genereate with too much data.
   EXPECT_EQ(-1, WebRtcCng_Generate(cng_dec_inst_, out_data, 641, 0));
   EXPECT_EQ(6140, WebRtcCng_GetErrorCodeDec(cng_dec_inst_));
 
   // Free encoder and decoder memory.
   EXPECT_EQ(0, WebRtcCng_FreeEnc(cng_enc_inst_));
   EXPECT_EQ(0, WebRtcCng_FreeDec(cng_dec_inst_));
 }
 
 // Test automatic SID.
-TEST_F(CngTest, CngAutoSid) {
+TEST_F(CngTest, DISABLED_ON_IOS(CngAutoSid)) {
   uint8_t sid_data[WEBRTC_CNG_MAX_LPC_ORDER + 1];
   int16_t number_bytes;
 
   // Create and initialize encoder and decoder memory.
   EXPECT_EQ(0, WebRtcCng_CreateEnc(&cng_enc_inst_));
   EXPECT_EQ(0, WebRtcCng_CreateDec(&cng_dec_inst_));
   EXPECT_EQ(0, WebRtcCng_InitEnc(cng_enc_inst_, 16000, kSidNormalIntervalUpdate,
                                  kCNGNumParamsNormal));
   EXPECT_EQ(0, WebRtcCng_InitDec(cng_dec_inst_));
 
   // Normal Encode, 100 msec, where no SID data should be generated.
   for (int i = 0; i < 10; i++) {
     EXPECT_EQ(0, WebRtcCng_Encode(cng_enc_inst_, speech_data_, 160, sid_data,
                                   &number_bytes, kNoSid));
   }
 
   // We have reached 100 msec, and SID data should be generated.
   EXPECT_EQ(kCNGNumParamsNormal + 1, WebRtcCng_Encode(
       cng_enc_inst_, speech_data_, 160, sid_data, &number_bytes, kNoSid));
 
   // Free encoder and decoder memory.
   EXPECT_EQ(0, WebRtcCng_FreeEnc(cng_enc_inst_));
   EXPECT_EQ(0, WebRtcCng_FreeDec(cng_dec_inst_));
 }
 
 // Test automatic SID, with very short interval.
-TEST_F(CngTest, CngAutoSidShort) {
+TEST_F(CngTest, DISABLED_ON_IOS(CngAutoSidShort)) {
   uint8_t sid_data[WEBRTC_CNG_MAX_LPC_ORDER + 1];
   int16_t number_bytes;
 
   // Create and initialize encoder and decoder memory.
   EXPECT_EQ(0, WebRtcCng_CreateEnc(&cng_enc_inst_));
   EXPECT_EQ(0, WebRtcCng_CreateDec(&cng_dec_inst_));
   EXPECT_EQ(0, WebRtcCng_InitEnc(cng_enc_inst_, 16000, kSidShortIntervalUpdate,
                                  kCNGNumParamsNormal));
   EXPECT_EQ(0, WebRtcCng_InitDec(cng_dec_inst_));
 
   // First call will never generate SID, unless forced to.
   EXPECT_EQ(0, WebRtcCng_Encode(cng_enc_inst_, speech_data_, 160, sid_data,
                                 &number_bytes, kNoSid));
 
   // Normal Encode, 100 msec, SID data should be generated all the time.
   for (int i = 0; i < 10; i++) {
     EXPECT_EQ(kCNGNumParamsNormal + 1, WebRtcCng_Encode(
         cng_enc_inst_, speech_data_, 160, sid_data, &number_bytes, kNoSid));
   }
 
   // Free encoder and decoder memory.
   EXPECT_EQ(0, WebRtcCng_FreeEnc(cng_enc_inst_));
   EXPECT_EQ(0, WebRtcCng_FreeDec(cng_dec_inst_));
 }
 
 }  // namespace webrtc