Ensures that modules_unittests runs on iOS

webrtc/modules/audio_coding/neteq/neteq_external_decoder_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.
  */
 
 // Test to verify correct operation for externally created decoders.
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/modules/audio_coding/neteq/mock/mock_external_decoder_pcm16b.h"
 #include "webrtc/modules/audio_coding/neteq/tools/input_audio_file.h"
 #include "webrtc/modules/audio_coding/neteq/tools/neteq_external_decoder_test.h"
 #include "webrtc/modules/audio_coding/neteq/tools/rtp_generator.h"
 #include "webrtc/test/testsupport/fileutils.h"
+#include "webrtc/test/testsupport/gtest_disable.h"
 
 namespace webrtc {
 
 using ::testing::_;
 using ::testing::Return;
 
 class NetEqExternalDecoderUnitTest : public test::NetEqExternalDecoderTest {
  protected:
   static const int kFrameSizeMs = 10;  // Frame size of Pcm16B.
 
@@ skipping 196 matching lines @@
 
   int NumExpectedDecodeCalls(int num_loops) override { return num_loops; }
 
  private:
   int sample_rate_hz_;
   rtc::scoped_ptr<NetEq> neteq_internal_;
   int16_t output_internal_[kMaxBlockSize];
   int16_t output_[kMaxBlockSize];
 };
 
-TEST_F(NetEqExternalVsInternalDecoderTest, RunTest) {
+TEST_F(NetEqExternalVsInternalDecoderTest, DISABLED_ON_IOS(RunTest)) {
   RunTest(100);  // Run 100 laps @ 10 ms each in the test loop.
 }
 
 class LargeTimestampJumpTest : public NetEqExternalDecoderUnitTest,
                                public ::testing::Test {
  protected:
   static const int kMaxBlockSize = 480;  // 10 ms @ 48 kHz.
 
   enum TestStates {
     kInitialPhase,
@@ skipping 74 matching lines @@
     // last packets not being decoded.
     return num_loops - 2;
   }
 
   TestStates test_state_;
 
  private:
   int16_t output_[kMaxBlockSize];
 };
 
-TEST_F(LargeTimestampJumpTest, JumpLongerThanHalfRange) {
+TEST_F(LargeTimestampJumpTest, DISABLED_ON_IOS(JumpLongerThanHalfRange)) {
   // Set the timestamp series to start at 2880, increase to 7200, then jump to
   // 2869342376. The sequence numbers start at 42076 and increase by 1 for each
   // packet, also when the timestamp jumps.
   static const uint16_t kStartSeqeunceNumber = 42076;
   static const uint32_t kStartTimestamp = 2880;
   static const uint32_t kJumpFromTimestamp = 7200;
   static const uint32_t kJumpToTimestamp = 2869342376;
   static_assert(kJumpFromTimestamp < kJumpToTimestamp,
                 "timestamp jump should not result in wrap");
   static_assert(
       static_cast<uint32_t>(kJumpToTimestamp - kJumpFromTimestamp) > 0x7FFFFFFF,
       "jump should be larger than half range");
   // Replace the default RTP generator with one that jumps in timestamp.
   ResetRtpGenerator(new test::TimestampJumpRtpGenerator(samples_per_ms(),
                                                         kStartSeqeunceNumber,
                                                         kStartTimestamp,
                                                         kJumpFromTimestamp,
                                                         kJumpToTimestamp));
 
   RunTest(130);  // Run 130 laps @ 10 ms each in the test loop.
   EXPECT_EQ(kRecovered, test_state_);
 }
 
-TEST_F(LargeTimestampJumpTest, JumpLongerThanHalfRangeAndWrap) {
+TEST_F(LargeTimestampJumpTest,
+       DISABLED_ON_IOS(JumpLongerThanHalfRangeAndWrap)) {
   // Make a jump larger than half the 32-bit timestamp range. Set the start
   // timestamp such that the jump will result in a wrap around.
   static const uint16_t kStartSeqeunceNumber = 42076;
   // Set the jump length slightly larger than 2^31.
   static const uint32_t kStartTimestamp = 3221223116;
   static const uint32_t kJumpFromTimestamp = 3221223216;
   static const uint32_t kJumpToTimestamp = 1073744278;
   static_assert(kJumpToTimestamp < kJumpFromTimestamp,
                 "timestamp jump should result in wrap");
   static_assert(
@@ skipping 38 matching lines @@
       default: { FAIL(); }
     }
   }
 
   int NumExpectedDecodeCalls(int num_loops) override {
     // Some packets won't be decoded because of the timestamp jump.
     return num_loops - 2;
   }
 };
 
-TEST_F(ShortTimestampJumpTest, JumpShorterThanHalfRange) {
+TEST_F(ShortTimestampJumpTest, DISABLED_ON_IOS(JumpShorterThanHalfRange)) {
   // Make a jump shorter than half the 32-bit timestamp range. Set the start
   // timestamp such that the jump will not result in a wrap around.
   static const uint16_t kStartSeqeunceNumber = 42076;
   // Set the jump length slightly smaller than 2^31.
   static const uint32_t kStartTimestamp = 4711;
   static const uint32_t kJumpFromTimestamp = 4811;
   static const uint32_t kJumpToTimestamp = 2147483747;
   static_assert(kJumpFromTimestamp < kJumpToTimestamp,
                 "timestamp jump should not result in wrap");
   static_assert(
       static_cast<uint32_t>(kJumpToTimestamp - kJumpFromTimestamp) < 0x7FFFFFFF,
       "jump should be smaller than half range");
   // Replace the default RTP generator with one that jumps in timestamp.
   ResetRtpGenerator(new test::TimestampJumpRtpGenerator(samples_per_ms(),
                                                         kStartSeqeunceNumber,
                                                         kStartTimestamp,
                                                         kJumpFromTimestamp,
                                                         kJumpToTimestamp));
 
   RunTest(130);  // Run 130 laps @ 10 ms each in the test loop.
   EXPECT_EQ(kRecovered, test_state_);
 }
 
-TEST_F(ShortTimestampJumpTest, JumpShorterThanHalfRangeAndWrap) {
+TEST_F(ShortTimestampJumpTest,
+       DISABLED_ON_IOS(JumpShorterThanHalfRangeAndWrap)) {
   // Make a jump shorter than half the 32-bit timestamp range. Set the start
   // timestamp such that the jump will result in a wrap around.
   static const uint16_t kStartSeqeunceNumber = 42076;
   // Set the jump length slightly smaller than 2^31.
   static const uint32_t kStartTimestamp = 3221227827;
   static const uint32_t kJumpFromTimestamp = 3221227927;
   static const uint32_t kJumpToTimestamp = 1073739567;
   static_assert(kJumpToTimestamp < kJumpFromTimestamp,
                 "timestamp jump should result in wrap");
   static_assert(
       static_cast<uint32_t>(kJumpToTimestamp - kJumpFromTimestamp) < 0x7FFFFFFF,
       "jump should be smaller than half range");
   // Replace the default RTP generator with one that jumps in timestamp.
   ResetRtpGenerator(new test::TimestampJumpRtpGenerator(samples_per_ms(),
                                                         kStartSeqeunceNumber,
                                                         kStartTimestamp,
                                                         kJumpFromTimestamp,
                                                         kJumpToTimestamp));
 
   RunTest(130);  // Run 130 laps @ 10 ms each in the test loop.
   EXPECT_EQ(kRecovered, test_state_);
 }
 
 }  // namespace webrtc