Created a mock AudioTransport.

webrtc/modules/audio_device/ios/audio_device_unittest_ios.cc

 /*
  *  Copyright (c) 2015 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 <algorithm>
 #include <limits>
 #include <list>
 #include <memory>
 #include <numeric>
 #include <string>
 #include <vector>
 
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/format_macros.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/scoped_ref_ptr.h"
 #include "webrtc/modules/audio_device/audio_device_impl.h"
 #include "webrtc/modules/audio_device/include/audio_device.h"
+#include "webrtc/modules/audio_device/include/mock_audio_transport.h"
 #include "webrtc/modules/audio_device/ios/audio_device_ios.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/event_wrapper.h"
 #include "webrtc/system_wrappers/include/sleep.h"
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/testsupport/fileutils.h"
 
 using std::cout;
 using std::endl;
@@ skipping 315 matching lines @@
   const size_t frames_per_buffer_;
   const size_t bytes_per_buffer_;
   size_t play_count_;
   size_t rec_count_;
   int64_t pulse_time_;
   std::vector<int> latencies_;
 };
 // Mocks the AudioTransport object and proxies actions for the two callbacks
 // (RecordedDataIsAvailable and NeedMorePlayData) to different implementations
 // of AudioStreamInterface.
-class MockAudioTransport : public AudioTransport {
+class MockAudioTransportIOS : public test::MockAudioTransport {
  public:
-  explicit MockAudioTransport(int type)
+  explicit MockAudioTransportIOS(int type)
       : num_callbacks_(0),
         type_(type),
         play_count_(0),
         rec_count_(0),
         audio_stream_(nullptr) {}
 
-  virtual ~MockAudioTransport() {}
-
-  MOCK_METHOD10(RecordedDataIsAvailable,
-                int32_t(const void* audioSamples,
-                        const size_t nSamples,
-                        const size_t nBytesPerSample,
-                        const size_t nChannels,
-                        const uint32_t samplesPerSec,
-                        const uint32_t totalDelayMS,
-                        const int32_t clockDrift,
-                        const uint32_t currentMicLevel,
-                        const bool keyPressed,
-                        uint32_t& newMicLevel));
-
-  MOCK_METHOD8(NeedMorePlayData,
-               int32_t(const size_t nSamples,
-                       const size_t nBytesPerSample,
-                       const size_t nChannels,
-                       const uint32_t samplesPerSec,
-                       void* audioSamples,
-                       size_t& nSamplesOut,
-                       int64_t* elapsed_time_ms,
-                       int64_t* ntp_time_ms));
-
-  MOCK_METHOD6(PushCaptureData,
-               void(int voe_channel,
-                    const void* audio_data,
-                    int bits_per_sample,
-                    int sample_rate,
-                    size_t number_of_channels,
-                    size_t number_of_frames));
-
-  MOCK_METHOD7(PullRenderData,
-               void(int bits_per_sample,
-                    int sample_rate,
-                    size_t number_of_channels,
-                    size_t number_of_frames,
-                    void* audio_data,
-                    int64_t* elapsed_time_ms,
-                    int64_t* ntp_time_ms));
+  virtual ~MockAudioTransportIOS() {}
 
   // Set default actions of the mock object. We are delegating to fake
   // implementations (of AudioStreamInterface) here.
   void HandleCallbacks(EventWrapper* test_is_done,
                        AudioStreamInterface* audio_stream,
                        size_t num_callbacks) {
     test_is_done_ = test_is_done;
     audio_stream_ = audio_stream;
     num_callbacks_ = num_callbacks;
     if (play_mode()) {
       ON_CALL(*this, NeedMorePlayData(_, _, _, _, _, _, _, _))
           .WillByDefault(
-              Invoke(this, &MockAudioTransport::RealNeedMorePlayData));
+              Invoke(this, &MockAudioTransportIOS::RealNeedMorePlayData));
     }
     if (rec_mode()) {
       ON_CALL(*this, RecordedDataIsAvailable(_, _, _, _, _, _, _, _, _, _))
-          .WillByDefault(
-              Invoke(this, &MockAudioTransport::RealRecordedDataIsAvailable));
+          .WillByDefault(Invoke(
+              this, &MockAudioTransportIOS::RealRecordedDataIsAvailable));
     }
   }
 
   int32_t RealRecordedDataIsAvailable(const void* audioSamples,
                                       const size_t nSamples,
                                       const size_t nBytesPerSample,
                                       const size_t nChannels,
                                       const uint32_t samplesPerSec,
                                       const uint32_t totalDelayMS,
                                       const int32_t clockDrift,
@@ skipping 226 matching lines @@
   // Create and initialize a second/extra ADM instance. The default ADM is
   // created by the test harness.
   rtc::scoped_refptr<AudioDeviceModule> second_audio_device =
       CreateAudioDevice(AudioDeviceModule::kPlatformDefaultAudio);
   EXPECT_NE(second_audio_device.get(), nullptr);
   EXPECT_EQ(0, second_audio_device->Init());
 
   // Start playout for the default ADM but don't wait here. Instead use the
   // upcoming second stream for that. We set the same expectation on number
   // of callbacks as for the second stream.
-  NiceMock<MockAudioTransport> mock(kPlayout);
+  NiceMock<MockAudioTransportIOS> mock(kPlayout);
   mock.HandleCallbacks(nullptr, nullptr, 0);
   EXPECT_CALL(
       mock, NeedMorePlayData(playout_frames_per_10ms_buffer(), kBytesPerSample,
                              playout_channels(), playout_sample_rate(),
                              NotNull(), _, _, _))
       .Times(AtLeast(kNumCallbacks));
   EXPECT_EQ(0, audio_device()->RegisterAudioCallback(&mock));
   StartPlayout();
 
   // Initialize playout for the second ADM. If all is OK, the second ADM shall
   // reuse the audio session activated when the first ADM started playing.
   // This call will also ensure that we avoid a problem related to initializing
   // two different audio unit instances back to back (see webrtc:5166 for
   // details).
   EXPECT_EQ(0, second_audio_device->InitPlayout());
   EXPECT_TRUE(second_audio_device->PlayoutIsInitialized());
 
   // Start playout for the second ADM and verify that it starts as intended.
   // Passing this test ensures that initialization of the second audio unit
   // has been done successfully and that there is no conflict with the already
   // playing first ADM.
-  MockAudioTransport mock2(kPlayout);
+  MockAudioTransportIOS mock2(kPlayout);
   mock2.HandleCallbacks(test_is_done_.get(), nullptr, kNumCallbacks);
   EXPECT_CALL(
       mock2, NeedMorePlayData(playout_frames_per_10ms_buffer(), kBytesPerSample,
                               playout_channels(), playout_sample_rate(),
                               NotNull(), _, _, _))
       .Times(AtLeast(kNumCallbacks));
   EXPECT_EQ(0, second_audio_device->RegisterAudioCallback(&mock2));
   EXPECT_EQ(0, second_audio_device->StartPlayout());
   EXPECT_TRUE(second_audio_device->Playing());
   test_is_done_->Wait(kTestTimeOutInMilliseconds);
   EXPECT_EQ(0, second_audio_device->StopPlayout());
   EXPECT_FALSE(second_audio_device->Playing());
   EXPECT_FALSE(second_audio_device->PlayoutIsInitialized());
 
   EXPECT_EQ(0, second_audio_device->Terminate());
 }
 
 // Start playout and verify that the native audio layer starts asking for real
 // audio samples to play out using the NeedMorePlayData callback.
 TEST_F(AudioDeviceTest, StartPlayoutVerifyCallbacks) {
-  MockAudioTransport mock(kPlayout);
+  MockAudioTransportIOS mock(kPlayout);
   mock.HandleCallbacks(test_is_done_.get(), nullptr, kNumCallbacks);
   EXPECT_CALL(mock, NeedMorePlayData(playout_frames_per_10ms_buffer(),
                                      kBytesPerSample, playout_channels(),
                                      playout_sample_rate(), NotNull(), _, _, _))
       .Times(AtLeast(kNumCallbacks));
   EXPECT_EQ(0, audio_device()->RegisterAudioCallback(&mock));
   StartPlayout();
   test_is_done_->Wait(kTestTimeOutInMilliseconds);
   StopPlayout();
 }
 
 // Start recording and verify that the native audio layer starts feeding real
 // audio samples via the RecordedDataIsAvailable callback.
 TEST_F(AudioDeviceTest, StartRecordingVerifyCallbacks) {
-  MockAudioTransport mock(kRecording);
+  MockAudioTransportIOS mock(kRecording);
   mock.HandleCallbacks(test_is_done_.get(), nullptr, kNumCallbacks);
   EXPECT_CALL(mock,
               RecordedDataIsAvailable(
                   NotNull(), record_frames_per_10ms_buffer(), kBytesPerSample,
                   record_channels(), record_sample_rate(),
                   _,  // TODO(henrika): fix delay
                   0, 0, false, _)).Times(AtLeast(kNumCallbacks));
 
   EXPECT_EQ(0, audio_device()->RegisterAudioCallback(&mock));
   StartRecording();
   test_is_done_->Wait(kTestTimeOutInMilliseconds);
   StopRecording();
 }
 
 // Start playout and recording (full-duplex audio) and verify that audio is
 // active in both directions.
 TEST_F(AudioDeviceTest, StartPlayoutAndRecordingVerifyCallbacks) {
-  MockAudioTransport mock(kPlayout | kRecording);
+  MockAudioTransportIOS mock(kPlayout | kRecording);
   mock.HandleCallbacks(test_is_done_.get(), nullptr, kNumCallbacks);
   EXPECT_CALL(mock, NeedMorePlayData(playout_frames_per_10ms_buffer(),
                                      kBytesPerSample, playout_channels(),
                                      playout_sample_rate(), NotNull(), _, _, _))
       .Times(AtLeast(kNumCallbacks));
   EXPECT_CALL(mock,
               RecordedDataIsAvailable(
                   NotNull(), record_frames_per_10ms_buffer(), kBytesPerSample,
                   record_channels(), record_sample_rate(),
                   _,  // TODO(henrika): fix delay
                   0, 0, false, _)).Times(AtLeast(kNumCallbacks));
   EXPECT_EQ(0, audio_device()->RegisterAudioCallback(&mock));
   StartPlayout();
   StartRecording();
   test_is_done_->Wait(kTestTimeOutInMilliseconds);
   StopRecording();
   StopPlayout();
 }
 
 // Start playout and read audio from an external PCM file when the audio layer
 // asks for data to play out. Real audio is played out in this test but it does
 // not contain any explicit verification that the audio quality is perfect.
 TEST_F(AudioDeviceTest, RunPlayoutWithFileAsSource) {
   // TODO(henrika): extend test when mono output is supported.
   EXPECT_EQ(1, playout_channels());
-  NiceMock<MockAudioTransport> mock(kPlayout);
+  NiceMock<MockAudioTransportIOS> mock(kPlayout);
   const int num_callbacks = kFilePlayTimeInSec * kNumCallbacksPerSecond;
   std::string file_name = GetFileName(playout_sample_rate());
   std::unique_ptr<FileAudioStream> file_audio_stream(
       new FileAudioStream(num_callbacks, file_name, playout_sample_rate()));
   mock.HandleCallbacks(test_is_done_.get(), file_audio_stream.get(),
                        num_callbacks);
   // SetMaxPlayoutVolume();
   EXPECT_EQ(0, audio_device()->RegisterAudioCallback(&mock));
   StartPlayout();
   test_is_done_->Wait(kTestTimeOutInMilliseconds);
@@ skipping 15 matching lines @@
 // of the FIFO will vary more due to an unbalance between the two sides.
 // This test tries to verify that the device maintains a balanced callback-
 // sequence by running in loopback for ten seconds while measuring the size
 // (max and average) of the FIFO. The size of the FIFO is increased by the
 // recording side and decreased by the playout side.
 // TODO(henrika): tune the final test parameters after running tests on several
 // different devices.
 TEST_F(AudioDeviceTest, RunPlayoutAndRecordingInFullDuplex) {
   EXPECT_EQ(record_channels(), playout_channels());
   EXPECT_EQ(record_sample_rate(), playout_sample_rate());
-  NiceMock<MockAudioTransport> mock(kPlayout | kRecording);
+  NiceMock<MockAudioTransportIOS> mock(kPlayout | kRecording);
   std::unique_ptr<FifoAudioStream> fifo_audio_stream(
       new FifoAudioStream(playout_frames_per_10ms_buffer()));
   mock.HandleCallbacks(test_is_done_.get(), fifo_audio_stream.get(),
                        kFullDuplexTimeInSec * kNumCallbacksPerSecond);
   // SetMaxPlayoutVolume();
   EXPECT_EQ(0, audio_device()->RegisterAudioCallback(&mock));
   StartRecording();
   StartPlayout();
   test_is_done_->Wait(
       std::max(kTestTimeOutInMilliseconds, 1000 * kFullDuplexTimeInSec));
   StopPlayout();
   StopRecording();
   EXPECT_LE(fifo_audio_stream->average_size(), 10u);
   EXPECT_LE(fifo_audio_stream->largest_size(), 20u);
 }
 
 // Measures loopback latency and reports the min, max and average values for
 // a full duplex audio session.
 // The latency is measured like so:
 // - Insert impulses periodically on the output side.
 // - Detect the impulses on the input side.
 // - Measure the time difference between the transmit time and receive time.
 // - Store time differences in a vector and calculate min, max and average.
 // This test requires a special hardware called Audio Loopback Dongle.
 // See http://source.android.com/devices/audio/loopback.html for details.
 TEST_F(AudioDeviceTest, DISABLED_MeasureLoopbackLatency) {
   EXPECT_EQ(record_channels(), playout_channels());
   EXPECT_EQ(record_sample_rate(), playout_sample_rate());
-  NiceMock<MockAudioTransport> mock(kPlayout | kRecording);
+  NiceMock<MockAudioTransportIOS> mock(kPlayout | kRecording);
   std::unique_ptr<LatencyMeasuringAudioStream> latency_audio_stream(
       new LatencyMeasuringAudioStream(playout_frames_per_10ms_buffer()));
   mock.HandleCallbacks(test_is_done_.get(), latency_audio_stream.get(),
                        kMeasureLatencyTimeInSec * kNumCallbacksPerSecond);
   EXPECT_EQ(0, audio_device()->RegisterAudioCallback(&mock));
   // SetMaxPlayoutVolume();
   // DisableBuiltInAECIfAvailable();
   StartRecording();
   StartPlayout();
   test_is_done_->Wait(
       std::max(kTestTimeOutInMilliseconds, 1000 * kMeasureLatencyTimeInSec));
   StopPlayout();
   StopRecording();
   // Verify that the correct number of transmitted impulses are detected.
   EXPECT_EQ(latency_audio_stream->num_latency_values(),
             static_cast<size_t>(
                 kImpulseFrequencyInHz * kMeasureLatencyTimeInSec - 1));
   latency_audio_stream->PrintResults();
 }
 
 }  // namespace webrtc