Ensures that modules_unittests runs on iOS

webrtc/modules/audio_processing/transient/file_utils_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 "webrtc/modules/audio_processing/transient/file_utils.h"
 
 #include <string.h>
 #include <string>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/system_wrappers/interface/file_wrapper.h"
 #include "webrtc/test/testsupport/fileutils.h"
+#include "webrtc/test/testsupport/gtest_disable.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
 
 static const uint8_t kPiBytesf[4] = {0xDB, 0x0F, 0x49, 0x40};
 static const uint8_t kEBytesf[4] = {0x54, 0xF8, 0x2D, 0x40};
 static const uint8_t kAvogadroBytesf[4] = {0x2F, 0x0C, 0xFF, 0x66};
 
 static const uint8_t kPiBytes[8] =
     {0x18, 0x2D, 0x44, 0x54, 0xFB, 0x21, 0x09, 0x40};
@@ skipping 21 matching lines @@
   // appended in that order.
   const std::string kTestFileName;
 
   // This file (used in some tests) contains binary data. The data correspond to
   // the float representation of the constants: Pi, E, and the Avogadro's
   // Number;
   // appended in that order.
   const std::string kTestFileNamef;
 };
 
-TEST_F(TransientFileUtilsTest, ConvertByteArrayToFloat) {
+TEST_F(TransientFileUtilsTest, DISABLED_ON_IOS(ConvertByteArrayToFloat)) {
   float value = 0.0;
 
   EXPECT_EQ(0, ConvertByteArrayToFloat(kPiBytesf, &value));
   EXPECT_FLOAT_EQ(kPi, value);
 
   EXPECT_EQ(0, ConvertByteArrayToFloat(kEBytesf, &value));
   EXPECT_FLOAT_EQ(kE, value);
 
   EXPECT_EQ(0, ConvertByteArrayToFloat(kAvogadroBytesf, &value));
   EXPECT_FLOAT_EQ(kAvogadro, value);
 }
 
-TEST_F(TransientFileUtilsTest, ConvertByteArrayToDouble) {
+TEST_F(TransientFileUtilsTest, DISABLED_ON_IOS(ConvertByteArrayToDouble)) {
   double value = 0.0;
 
   EXPECT_EQ(0, ConvertByteArrayToDouble(kPiBytes, &value));
   EXPECT_DOUBLE_EQ(kPi, value);
 
   EXPECT_EQ(0, ConvertByteArrayToDouble(kEBytes, &value));
   EXPECT_DOUBLE_EQ(kE, value);
 
   EXPECT_EQ(0, ConvertByteArrayToDouble(kAvogadroBytes, &value));
   EXPECT_DOUBLE_EQ(kAvogadro, value);
 }
 
-TEST_F(TransientFileUtilsTest, ConvertFloatToByteArray) {
+TEST_F(TransientFileUtilsTest, DISABLED_ON_IOS(ConvertFloatToByteArray)) {
   rtc::scoped_ptr<uint8_t[]> bytes(new uint8_t[4]);
 
   EXPECT_EQ(0, ConvertFloatToByteArray(kPi, bytes.get()));
   EXPECT_EQ(0, memcmp(bytes.get(), kPiBytesf, 4));
 
   EXPECT_EQ(0, ConvertFloatToByteArray(kE, bytes.get()));
   EXPECT_EQ(0, memcmp(bytes.get(), kEBytesf, 4));
 
   EXPECT_EQ(0, ConvertFloatToByteArray(kAvogadro, bytes.get()));
   EXPECT_EQ(0, memcmp(bytes.get(), kAvogadroBytesf, 4));
 }
 
-TEST_F(TransientFileUtilsTest, ConvertDoubleToByteArray) {
+TEST_F(TransientFileUtilsTest, DISABLED_ON_IOS(ConvertDoubleToByteArray)) {
   rtc::scoped_ptr<uint8_t[]> bytes(new uint8_t[8]);
 
   EXPECT_EQ(0, ConvertDoubleToByteArray(kPi, bytes.get()));
   EXPECT_EQ(0, memcmp(bytes.get(), kPiBytes, 8));
 
   EXPECT_EQ(0, ConvertDoubleToByteArray(kE, bytes.get()));
   EXPECT_EQ(0, memcmp(bytes.get(), kEBytes, 8));
 
   EXPECT_EQ(0, ConvertDoubleToByteArray(kAvogadro, bytes.get()));
   EXPECT_EQ(0, memcmp(bytes.get(), kAvogadroBytes, 8));
 }
 
-TEST_F(TransientFileUtilsTest, ReadInt16BufferFromFile) {
+TEST_F(TransientFileUtilsTest, DISABLED_ON_IOS(ReadInt16BufferFromFile)) {
   std::string test_filename = kTestFileName;
 
   rtc::scoped_ptr<FileWrapper> file(FileWrapper::Create());
 
   file->OpenFile(test_filename.c_str(),
                  true,    // Read only.
                  true,    // Loop.
                  false);  // No text.
   ASSERT_TRUE(file->Open()) << "File could not be opened:\n"
       << kTestFileName.c_str();
@@ skipping 17 matching lines @@
   buffer.reset(new int16_t[kBufferLenghtLargerThanFile]);
   EXPECT_EQ(kBufferLength, ReadInt16BufferFromFile(file.get(),
                                                    kBufferLenghtLargerThanFile,
                                                    buffer.get()));
   EXPECT_EQ(11544, buffer[0]);
   EXPECT_EQ(22377, buffer[4]);
   EXPECT_EQ(16389, buffer[7]);
   EXPECT_EQ(17631, buffer[kBufferLength - 1]);
 }
 
-TEST_F(TransientFileUtilsTest, ReadInt16FromFileToFloatBuffer) {
+TEST_F(TransientFileUtilsTest,
+       DISABLED_ON_IOS(ReadInt16FromFileToFloatBuffer)) {
   std::string test_filename = kTestFileName;
 
   rtc::scoped_ptr<FileWrapper> file(FileWrapper::Create());
 
   file->OpenFile(test_filename.c_str(),
                  true,    // Read only.
                  true,    // Loop.
                  false);  // No text.
   ASSERT_TRUE(file->Open()) << "File could not be opened:\n"
       << kTestFileName.c_str();
@@ skipping 20 matching lines @@
   EXPECT_EQ(kBufferLength,
             ReadInt16FromFileToFloatBuffer(file.get(),
                                            kBufferLenghtLargerThanFile,
                                            buffer.get()));
   EXPECT_DOUBLE_EQ(11544, buffer[0]);
   EXPECT_DOUBLE_EQ(22377, buffer[4]);
   EXPECT_DOUBLE_EQ(16389, buffer[7]);
   EXPECT_DOUBLE_EQ(17631, buffer[kBufferLength - 1]);
 }
 
-TEST_F(TransientFileUtilsTest, ReadInt16FromFileToDoubleBuffer) {
+TEST_F(TransientFileUtilsTest,
+       DISABLED_ON_IOS(ReadInt16FromFileToDoubleBuffer)) {
   std::string test_filename = kTestFileName;
 
   rtc::scoped_ptr<FileWrapper> file(FileWrapper::Create());
 
   file->OpenFile(test_filename.c_str(),
                  true,    // Read only.
                  true,    // Loop.
                  false);  // No text.
   ASSERT_TRUE(file->Open()) << "File could not be opened:\n"
       << kTestFileName.c_str();
@@ skipping 19 matching lines @@
   EXPECT_EQ(kBufferLength,
             ReadInt16FromFileToDoubleBuffer(file.get(),
                                             kBufferLenghtLargerThanFile,
                                             buffer.get()));
   EXPECT_DOUBLE_EQ(11544, buffer[0]);
   EXPECT_DOUBLE_EQ(22377, buffer[4]);
   EXPECT_DOUBLE_EQ(16389, buffer[7]);
   EXPECT_DOUBLE_EQ(17631, buffer[kBufferLength - 1]);
 }
 
-TEST_F(TransientFileUtilsTest, ReadFloatBufferFromFile) {
+TEST_F(TransientFileUtilsTest, DISABLED_ON_IOS(ReadFloatBufferFromFile)) {
   std::string test_filename = kTestFileNamef;
 
   rtc::scoped_ptr<FileWrapper> file(FileWrapper::Create());
 
   file->OpenFile(test_filename.c_str(),
                  true,    // Read only.
                  true,    // Loop.
                  false);  // No text.
   ASSERT_TRUE(file->Open()) << "File could not be opened:\n"
       << kTestFileNamef.c_str();
@@ skipping 16 matching lines @@
   const size_t kBufferLenghtLargerThanFile = kBufferLength * 2;
   buffer.reset(new float[kBufferLenghtLargerThanFile]);
   EXPECT_EQ(kBufferLength, ReadFloatBufferFromFile(file.get(),
                                                    kBufferLenghtLargerThanFile,
                                                    buffer.get()));
   EXPECT_FLOAT_EQ(kPi, buffer[0]);
   EXPECT_FLOAT_EQ(kE, buffer[1]);
   EXPECT_FLOAT_EQ(kAvogadro, buffer[2]);
 }
 
-TEST_F(TransientFileUtilsTest, ReadDoubleBufferFromFile) {
+TEST_F(TransientFileUtilsTest, DISABLED_ON_IOS(ReadDoubleBufferFromFile)) {
   std::string test_filename = kTestFileName;
 
   rtc::scoped_ptr<FileWrapper> file(FileWrapper::Create());
 
   file->OpenFile(test_filename.c_str(),
                  true,    // Read only.
                  true,    // Loop.
                  false);  // No text.
   ASSERT_TRUE(file->Open()) << "File could not be opened:\n"
       << kTestFileName.c_str();
@@ skipping 16 matching lines @@
   const size_t kBufferLenghtLargerThanFile = kBufferLength * 2;
   buffer.reset(new double[kBufferLenghtLargerThanFile]);
   EXPECT_EQ(kBufferLength, ReadDoubleBufferFromFile(file.get(),
                                                     kBufferLenghtLargerThanFile,
                                                     buffer.get()));
   EXPECT_DOUBLE_EQ(kPi, buffer[0]);
   EXPECT_DOUBLE_EQ(kE, buffer[1]);
   EXPECT_DOUBLE_EQ(kAvogadro, buffer[2]);
 }
 
-TEST_F(TransientFileUtilsTest, WriteInt16BufferToFile) {
+TEST_F(TransientFileUtilsTest, DISABLED_ON_IOS(WriteInt16BufferToFile)) {
   rtc::scoped_ptr<FileWrapper> file(FileWrapper::Create());
 
   std::string kOutFileName = test::TempFilename(test::OutputPath(),
                                                 "utils_test");
 
   file->OpenFile(kOutFileName.c_str(),
                  false,   // Write mode.
                  false,   // No loop.
                  false);  // No text.
   ASSERT_TRUE(file->Open()) << "File could not be opened:\n"
@@ skipping 21 matching lines @@
       << kOutFileName.c_str();
 
   EXPECT_EQ(kBufferLength, ReadInt16BufferFromFile(file.get(),
                                                    kBufferLength,
                                                    read_buffer.get()));
   EXPECT_EQ(0, memcmp(written_buffer.get(),
                       read_buffer.get(),
                       kBufferLength * sizeof(written_buffer[0])));
 }
 
-TEST_F(TransientFileUtilsTest, WriteFloatBufferToFile) {
+TEST_F(TransientFileUtilsTest, DISABLED_ON_IOS(WriteFloatBufferToFile)) {
   rtc::scoped_ptr<FileWrapper> file(FileWrapper::Create());
 
   std::string kOutFileName = test::TempFilename(test::OutputPath(),
                                                 "utils_test");
 
   file->OpenFile(kOutFileName.c_str(),
                  false,   // Write mode.
                  false,   // No loop.
                  false);  // No text.
   ASSERT_TRUE(file->Open()) << "File could not be opened:\n"
@@ skipping 21 matching lines @@
       << kOutFileName.c_str();
 
   EXPECT_EQ(kBufferLength, ReadFloatBufferFromFile(file.get(),
                                                    kBufferLength,
                                                    read_buffer.get()));
   EXPECT_EQ(0, memcmp(written_buffer.get(),
                       read_buffer.get(),
                       kBufferLength * sizeof(written_buffer[0])));
 }
 
-TEST_F(TransientFileUtilsTest, WriteDoubleBufferToFile) {
+TEST_F(TransientFileUtilsTest, DISABLED_ON_IOS(WriteDoubleBufferToFile)) {
   rtc::scoped_ptr<FileWrapper> file(FileWrapper::Create());
 
   std::string kOutFileName = test::TempFilename(test::OutputPath(),
                                                 "utils_test");
 
   file->OpenFile(kOutFileName.c_str(),
                  false,   // Write mode.
                  false,   // No loop.
                  false);  // No text.
   ASSERT_TRUE(file->Open()) << "File could not be opened:\n"
@@ skipping 21 matching lines @@
       << kOutFileName.c_str();
 
   EXPECT_EQ(kBufferLength, ReadDoubleBufferFromFile(file.get(),
                                                     kBufferLength,
                                                     read_buffer.get()));
   EXPECT_EQ(0, memcmp(written_buffer.get(),
                       read_buffer.get(),
                       kBufferLength * sizeof(written_buffer[0])));
 }
 
-TEST_F(TransientFileUtilsTest, ExpectedErrorReturnValues) {
+TEST_F(TransientFileUtilsTest, DISABLED_ON_IOS(ExpectedErrorReturnValues)) {
   std::string test_filename = kTestFileName;
 
   double value;
   rtc::scoped_ptr<int16_t[]> int16_buffer(new int16_t[1]);
   rtc::scoped_ptr<double[]> double_buffer(new double[1]);
   rtc::scoped_ptr<FileWrapper> file(FileWrapper::Create());
 
   EXPECT_EQ(-1, ConvertByteArrayToDouble(NULL, &value));
   EXPECT_EQ(-1, ConvertByteArrayToDouble(kPiBytes, NULL));
 
@@ skipping 33 matching lines @@
   EXPECT_EQ(0u, WriteInt16BufferToFile(file.get(), 1, NULL));
   EXPECT_EQ(0u, WriteInt16BufferToFile(file.get(), 0, int16_buffer.get()));
 
   EXPECT_EQ(0u, WriteDoubleBufferToFile(NULL, 1, double_buffer.get()));
   EXPECT_EQ(0u, WriteDoubleBufferToFile(file.get(), 1, NULL));
   EXPECT_EQ(0u, WriteDoubleBufferToFile(file.get(), 0, double_buffer.get()));
 }
 
 }  // namespace webrtc