Add flag --require-audio-hardware-for-testing.

media/audio/win/audio_low_latency_input_win_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <windows.h>
 #include <mmsystem.h>
 
 #include "base/basictypes.h"
 #include "base/environment.h"
 #include "base/files/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/test/test_timeouts.h"
 #include "base/win/scoped_com_initializer.h"
 #include "media/audio/audio_io.h"
 #include "media/audio/audio_manager_base.h"
+#include "media/audio/audio_unittest_util.h"
 #include "media/audio/win/audio_low_latency_input_win.h"
 #include "media/audio/win/core_audio_util_win.h"
 #include "media/base/seekable_buffer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::win::ScopedCOMInitializer;
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::AtLeast;
@@ skipping 115 matching lines @@
 
   virtual void OnError(AudioInputStream* stream) {}
 
  private:
   int bits_per_sample_;
   media::SeekableBuffer buffer_;
   FILE* binary_file_;
   size_t bytes_to_write_;
 };
 
-// Convenience method which ensures that we are not running on the build
-// bots and that at least one valid input device can be found. We also
-// verify that we are not running on XP since the low-latency (WASAPI-
-// based) version requires Windows Vista or higher.
-static bool CanRunAudioTests(AudioManager* audio_man) {
-  if (!CoreAudioUtil::IsSupported()) {
-    LOG(WARNING) << "This tests requires Windows Vista or higher.";
-    return false;
-  }
+static bool HasCoreAudioAndInputDevices(AudioManager* audio_man) {
+  // The low-latency (WASAPI-based) version requires Windows Vista or higher.
   // TODO(henrika): note that we use Wave today to query the number of
   // existing input devices.
-  bool input = audio_man->HasAudioInputDevices();
-  LOG_IF(WARNING, !input) << "No input device detected.";
-  return input;
+  return CoreAudioUtil::IsSupported() && audio_man->HasAudioInputDevices();
 }
 
 // Convenience method which creates a default AudioInputStream object but
 // also allows the user to modify the default settings.
 class AudioInputStreamWrapper {
  public:
   explicit AudioInputStreamWrapper(AudioManager* audio_manager)
       : com_init_(ScopedCOMInitializer::kMTA),
         audio_man_(audio_manager),
         default_params_(
@@ skipping 82 matching lines @@
  private:
   AudioInputStream* stream_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedAudioInputStream);
 };
 
 // Verify that we can retrieve the current hardware/mixing sample rate
 // for all available input devices.
 TEST(WinAudioInputTest, WASAPIAudioInputStreamHardwareSampleRate) {
   scoped_ptr<AudioManager> audio_manager(AudioManager::CreateForTesting());
-  if (!CanRunAudioTests(audio_manager.get()))
-    return;
+  ABORT_AUDIO_TEST_IF_NOT(HasCoreAudioAndInputDevices(audio_manager.get()));
 
   ScopedCOMInitializer com_init(ScopedCOMInitializer::kMTA);
 
   // Retrieve a list of all available input devices.
   media::AudioDeviceNames device_names;
   audio_manager->GetAudioInputDeviceNames(&device_names);
 
   // Scan all available input devices and repeat the same test for all of them.
   for (media::AudioDeviceNames::const_iterator it = device_names.begin();
        it != device_names.end(); ++it) {
     // Retrieve the hardware sample rate given a specified audio input device.
     AudioParameters params = WASAPIAudioInputStream::GetInputStreamParameters(
         it->unique_id);
     EXPECT_GE(params.sample_rate(), 0);
   }
 }
 
 // Test Create(), Close() calling sequence.
 TEST(WinAudioInputTest, WASAPIAudioInputStreamCreateAndClose) {
   scoped_ptr<AudioManager> audio_manager(AudioManager::CreateForTesting());
-  if (!CanRunAudioTests(audio_manager.get()))
-    return;
+  ABORT_AUDIO_TEST_IF_NOT(HasCoreAudioAndInputDevices(audio_manager.get()));
   ScopedAudioInputStream ais(
       CreateDefaultAudioInputStream(audio_manager.get()));
   ais.Close();
 }
 
 // Test Open(), Close() calling sequence.
 TEST(WinAudioInputTest, WASAPIAudioInputStreamOpenAndClose) {
   scoped_ptr<AudioManager> audio_manager(AudioManager::CreateForTesting());
-  if (!CanRunAudioTests(audio_manager.get()))
-    return;
+  ABORT_AUDIO_TEST_IF_NOT(HasCoreAudioAndInputDevices(audio_manager.get()));
   ScopedAudioInputStream ais(
       CreateDefaultAudioInputStream(audio_manager.get()));
   EXPECT_TRUE(ais->Open());
   ais.Close();
 }
 
 // Test Open(), Start(), Close() calling sequence.
 TEST(WinAudioInputTest, WASAPIAudioInputStreamOpenStartAndClose) {
   scoped_ptr<AudioManager> audio_manager(AudioManager::CreateForTesting());
-  if (!CanRunAudioTests(audio_manager.get()))
-    return;
+  ABORT_AUDIO_TEST_IF_NOT(HasCoreAudioAndInputDevices(audio_manager.get()));
   ScopedAudioInputStream ais(
       CreateDefaultAudioInputStream(audio_manager.get()));
   EXPECT_TRUE(ais->Open());
   MockAudioInputCallback sink;
   ais->Start(&sink);
   ais.Close();
 }
 
 // Test Open(), Start(), Stop(), Close() calling sequence.
 TEST(WinAudioInputTest, WASAPIAudioInputStreamOpenStartStopAndClose) {
   scoped_ptr<AudioManager> audio_manager(AudioManager::CreateForTesting());
-  if (!CanRunAudioTests(audio_manager.get()))
-    return;
+  ABORT_AUDIO_TEST_IF_NOT(HasCoreAudioAndInputDevices(audio_manager.get()));
   ScopedAudioInputStream ais(
       CreateDefaultAudioInputStream(audio_manager.get()));
   EXPECT_TRUE(ais->Open());
   MockAudioInputCallback sink;
   ais->Start(&sink);
   ais->Stop();
   ais.Close();
 }
 
 // Test some additional calling sequences.
 TEST(WinAudioInputTest, WASAPIAudioInputStreamMiscCallingSequences) {
   scoped_ptr<AudioManager> audio_manager(AudioManager::CreateForTesting());
-  if (!CanRunAudioTests(audio_manager.get()))
-    return;
+  ABORT_AUDIO_TEST_IF_NOT(HasCoreAudioAndInputDevices(audio_manager.get()));
   ScopedAudioInputStream ais(
       CreateDefaultAudioInputStream(audio_manager.get()));
   WASAPIAudioInputStream* wais =
       static_cast<WASAPIAudioInputStream*>(ais.get());
 
   // Open(), Open() should fail the second time.
   EXPECT_TRUE(ais->Open());
   EXPECT_FALSE(ais->Open());
 
   MockAudioInputCallback sink;
 
   // Start(), Start() is a valid calling sequence (second call does nothing).
   ais->Start(&sink);
   EXPECT_TRUE(wais->started());
   ais->Start(&sink);
   EXPECT_TRUE(wais->started());
 
   // Stop(), Stop() is a valid calling sequence (second call does nothing).
   ais->Stop();
   EXPECT_FALSE(wais->started());
   ais->Stop();
   EXPECT_FALSE(wais->started());
   ais.Close();
 }
 
 TEST(WinAudioInputTest, WASAPIAudioInputStreamTestPacketSizes) {
   scoped_ptr<AudioManager> audio_manager(AudioManager::CreateForTesting());
-  if (!CanRunAudioTests(audio_manager.get()))
-    return;
+  ABORT_AUDIO_TEST_IF_NOT(HasCoreAudioAndInputDevices(audio_manager.get()));
 
   int count = 0;
   base::MessageLoopForUI loop;
 
   // 10 ms packet size.
 
   // Create default WASAPI input stream which records in stereo using
   // the shared mixing rate. The default buffer size is 10ms.
   AudioInputStreamWrapper aisw(audio_manager.get());
   ScopedAudioInputStream ais(aisw.Create());
@@ skipping 49 matching lines @@
       .WillRepeatedly(CheckCountAndPostQuitTask(&count, 10, &loop));
   ais->Start(&sink);
   loop.Run();
   ais->Stop();
   ais.Close();
 }
 
 // Test that we can capture a stream in loopback.
 TEST(WinAudioInputTest, WASAPIAudioInputStreamLoopback) {
   scoped_ptr<AudioManager> audio_manager(AudioManager::CreateForTesting());
-  if (!audio_manager->HasAudioOutputDevices() || !CoreAudioUtil::IsSupported())
-    return;
+  ABORT_AUDIO_TEST_IF_NOT(audio_manager->HasAudioOutputDevices() &&
+                          CoreAudioUtil::IsSupported());
 
   AudioParameters params = audio_manager->GetInputStreamParameters(
       AudioManagerBase::kLoopbackInputDeviceId);
   EXPECT_EQ(params.effects(), 0);
 
   AudioParameters output_params =
       audio_manager->GetOutputStreamParameters(std::string());
   EXPECT_EQ(params.sample_rate(), output_params.sample_rate());
   EXPECT_EQ(params.channel_layout(), output_params.channel_layout());
 
@@ skipping 12 matching lines @@
 }
 
 // This test is intended for manual tests and should only be enabled
 // when it is required to store the captured data on a local file.
 // By default, GTest will print out YOU HAVE 1 DISABLED TEST.
 // To include disabled tests in test execution, just invoke the test program
 // with --gtest_also_run_disabled_tests or set the GTEST_ALSO_RUN_DISABLED_TESTS
 // environment variable to a value greater than 0.
 TEST(WinAudioInputTest, DISABLED_WASAPIAudioInputStreamRecordToFile) {
   scoped_ptr<AudioManager> audio_manager(AudioManager::CreateForTesting());
-  if (!CanRunAudioTests(audio_manager.get()))
-    return;
+  ABORT_AUDIO_TEST_IF_NOT(HasCoreAudioAndInputDevices(audio_manager.get()));
 
   // Name of the output PCM file containing captured data. The output file
   // will be stored in the directory containing 'media_unittests.exe'.
   // Example of full name: \src\build\Debug\out_stereo_10sec.pcm.
   const char* file_name = "out_stereo_10sec.pcm";
 
   AudioInputStreamWrapper aisw(audio_manager.get());
   ScopedAudioInputStream ais(aisw.Create());
   EXPECT_TRUE(ais->Open());
 
   VLOG(0) << ">> Sample rate: " << aisw.sample_rate() << " [Hz]";
   WriteToFileAudioSink file_sink(file_name, aisw.bits_per_sample());
   VLOG(0) << ">> Speak into the default microphone while recording.";
   ais->Start(&file_sink);
   base::PlatformThread::Sleep(TestTimeouts::action_timeout());
   ais->Stop();
   VLOG(0) << ">> Recording has stopped.";
   ais.Close();
 }
 
 }  // namespace media