Make AudioSystem unit tests reusable for different implementations

Introducing type-parametrized tests verifying that a given AudioSystem implementation is correct.
This will allow to re-use tests for AudioSystem implementation on top of Mojo Audio service.

Bug: 740943
Cq-Include-Trybots: master.tryserver.chromium.android:android_optional_gpu_tests_rel;master.tryserver.chromium.linux:linux_optional_gpu_tests_rel;master.tryserver.chromium.mac:mac_optional_gpu_tests_rel;master.tryserver.chromium.win:win_optional_gpu_tests_rel
Change-Id: If69ee76bce05f0dcfab6abeb31af95959149ca9d
Reviewed-on: https://chromium-review.googlesource.com/707142
Commit-Queue: Olga Sharonova <olka@chromium.org>
Reviewed-by: Max Morin <maxmorin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#517807}

media/audio/BUILD.gn

@@ -333,6 +333,8 @@ static_library("test_support") {
   sources = [
     "audio_device_info_accessor_for_tests.cc",
     "audio_device_info_accessor_for_tests.h",
+    "audio_system_test_util.cc",
+    "audio_system_test_util.h",
     "audio_unittest_util.cc",
     "audio_unittest_util.h",
     "mock_audio_manager.cc",

media/audio/audio_system_impl_unittest.cc

@@ -3,353 +3,50 @@
 // found in the LICENSE file.
 
 #include "media/audio/audio_system_impl.h"
-#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#include "base/single_thread_task_runner.h"
-#include "base/task_runner_util.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_checker.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "media/audio/audio_device_description.h"
+#include "media/audio/audio_system_test_util.h"
 #include "media/audio/audio_thread_impl.h"
 #include "media/audio/mock_audio_manager.h"
 #include "media/audio/test_audio_thread.h"
-#include "media/base/test_helpers.h"
-#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace {
-const char* kNonDefaultDeviceId = "non-default-device-id";
-}
-
 namespace media {
 
-bool operator==(const AudioDeviceDescription& lhs,
-                const AudioDeviceDescription& rhs) {
-  return lhs.device_name == rhs.device_name && lhs.unique_id == rhs.unique_id &&
-         lhs.group_id == rhs.group_id;
-}
-
 // TODO(olka): These are the only tests for AudioSystemHelper. Make sure that
 // AudioSystemHelper is tested if AudioSystemImpl goes away.
-class AudioSystemImplTest : public testing::TestWithParam<bool> {
- public:
-  AudioSystemImplTest()
-      : use_audio_thread_(GetParam()),
-        input_params_(AudioParameters::AUDIO_PCM_LINEAR,
-                      CHANNEL_LAYOUT_MONO,
-                      AudioParameters::kTelephoneSampleRate,
-                      16,
-                      AudioParameters::kTelephoneSampleRate / 10),
-        output_params_(AudioParameters::AUDIO_PCM_LINEAR,
-                       CHANNEL_LAYOUT_MONO,
-                       AudioParameters::kTelephoneSampleRate,
-                       16,
-                       AudioParameters::kTelephoneSampleRate / 20),
-        default_output_params_(AudioParameters::AUDIO_PCM_LINEAR,
-                               CHANNEL_LAYOUT_MONO,
-                               AudioParameters::kTelephoneSampleRate,
-                               16,
-                               AudioParameters::kTelephoneSampleRate / 30) {
-    audio_manager_ = base::MakeUnique<MockAudioManager>(
-        base::MakeUnique<TestAudioThread>(use_audio_thread_));
-    audio_manager_->SetInputStreamParameters(input_params_);
-    audio_manager_->SetOutputStreamParameters(output_params_);
-    audio_manager_->SetDefaultOutputStreamParameters(default_output_params_);
 
-    auto get_device_descriptions = [](const AudioDeviceDescriptions* source,
-                                      AudioDeviceDescriptions* destination) {
-      destination->insert(destination->end(), source->begin(), source->end());
-    };
+// Typed tests cannot be parametrized, so using template parameter instead of
+// inheriting from TestWithParams<>
+template <bool use_audio_thread>
+class AudioSystemImplTestBase : public testing::Test {
+ public:
+  AudioSystemImplTestBase() {}
 
-    audio_manager_->SetInputDeviceDescriptionsCallback(
-        base::Bind(get_device_descriptions,
-                   base::Unretained(&input_device_descriptions_)));
-    audio_manager_->SetOutputDeviceDescriptionsCallback(
-        base::Bind(get_device_descriptions,
-                   base::Unretained(&output_device_descriptions_)));
+  ~AudioSystemImplTestBase() override {}
 
+  void SetUp() override {
+    audio_manager_ = std::make_unique<MockAudioManager>(
+        std::make_unique<TestAudioThread>(use_audio_thread));
     audio_system_ = std::make_unique<AudioSystemImpl>(audio_manager_.get());
   }
-
-  ~AudioSystemImplTest() override { audio_manager_->Shutdown(); }
-
-  void OnAudioParams(const base::Optional<AudioParameters>& expected,
-                     const base::Optional<AudioParameters>& received) {
-    EXPECT_TRUE(thread_checker_.CalledOnValidThread());
-    if (expected) {
-      EXPECT_TRUE(received);
-      EXPECT_EQ(expected->AsHumanReadableString(),
-                received->AsHumanReadableString());
-    } else {
-      EXPECT_FALSE(received);
-    }
-    AudioParametersReceived();
-  }
-
-  void OnHasInputDevices(bool result) {
-    EXPECT_TRUE(thread_checker_.CalledOnValidThread());
-    HasInputDevicesCallback(result);
-  }
-
-  void OnHasOutputDevices(bool result) {
-    EXPECT_TRUE(thread_checker_.CalledOnValidThread());
-    HasOutputDevicesCallback(result);
-  }
-
-  void OnGetDeviceDescriptions(
-      const AudioDeviceDescriptions& expected_descriptions,
-      AudioDeviceDescriptions descriptions) {
-    EXPECT_TRUE(thread_checker_.CalledOnValidThread());
-    EXPECT_EQ(expected_descriptions, descriptions);
-    DeviceDescriptionsReceived();
-  }
-
-  void OnInputDeviceInfo(
-      const base::Optional<AudioParameters>& expected_input,
-      const base::Optional<AudioParameters>& expected_associated_output,
-      const std::string& expected_associated_device_id,
-      const base::Optional<AudioParameters>& input,
-      const base::Optional<AudioParameters>& associated_output,
-      const std::string& associated_device_id) {
-    EXPECT_TRUE(thread_checker_.CalledOnValidThread());
-    if (expected_input) {
-      EXPECT_TRUE(input);
-      EXPECT_EQ(expected_input->AsHumanReadableString(),
-                input->AsHumanReadableString());
-    } else {
-      EXPECT_FALSE(input);
-    }
-    if (expected_associated_output) {
-      EXPECT_TRUE(associated_output);
-      EXPECT_EQ(expected_associated_output->AsHumanReadableString(),
-                associated_output->AsHumanReadableString());
-    } else {
-      EXPECT_FALSE(associated_output);
-    }
-    EXPECT_EQ(expected_associated_device_id, associated_device_id);
-    InputDeviceInfoReceived();
-  }
-
-  void WaitForCallback() {
-    if (!use_audio_thread_) {
-      base::RunLoop().RunUntilIdle();
-      return;
-    }
-    WaitableMessageLoopEvent event;
-    audio_manager_->GetTaskRunner()->PostTaskAndReply(
-        FROM_HERE, base::Bind(&base::DoNothing), event.GetClosure());
-    // Runs the loop and waits for the |audio_thread_| to call event's closure,
-    // which means AudioSystem reply containing device parameters is already
-    // queued on the main thread.
-    event.RunAndWait();
-    base::RunLoop().RunUntilIdle();
-  }
-
-  // Mocks to verify that AudioSystem replied with an expected callback.
-  MOCK_METHOD0(AudioParametersReceived, void(void));
-  MOCK_METHOD1(HasInputDevicesCallback, void(bool));
-  MOCK_METHOD1(HasOutputDevicesCallback, void(bool));
-  MOCK_METHOD0(DeviceDescriptionsReceived, void(void));
-  MOCK_METHOD1(AssociatedOutputDeviceIDReceived, void(const std::string&));
-  MOCK_METHOD0(InputDeviceInfoReceived, void(void));
+  void TearDown() override { audio_manager_->Shutdown(); }
 
  protected:
+  MockAudioManager* audio_manager() { return audio_manager_.get(); }
+  AudioSystem* audio_system() { return audio_system_.get(); }
+
   base::MessageLoop message_loop_;
-  base::ThreadChecker thread_checker_;
-  bool use_audio_thread_;
   std::unique_ptr<MockAudioManager> audio_manager_;
   std::unique_ptr<AudioSystem> audio_system_;
-  AudioParameters input_params_;
-  AudioParameters output_params_;
-  AudioParameters default_output_params_;
-  AudioDeviceDescriptions input_device_descriptions_;
-  AudioDeviceDescriptions output_device_descriptions_;
+  // AudioSystemTester tester_;
 };
 
-TEST_P(AudioSystemImplTest, GetInputStreamParameters) {
-  EXPECT_CALL(*this, AudioParametersReceived());
-  audio_system_->GetInputStreamParameters(
-      AudioDeviceDescription::kDefaultDeviceId,
-      base::Bind(&AudioSystemImplTest::OnAudioParams, base::Unretained(this),
-                 input_params_));
-  WaitForCallback();
-}
-
-TEST_P(AudioSystemImplTest, GetInputStreamParametersNoDevice) {
-  audio_manager_->SetHasInputDevices(false);
-  EXPECT_CALL(*this, AudioParametersReceived());
-  audio_system_->GetInputStreamParameters(
-      AudioDeviceDescription::kDefaultDeviceId,
-      base::Bind(&AudioSystemImplTest::OnAudioParams, base::Unretained(this),
-                 base::Optional<AudioParameters>()));
-  WaitForCallback();
-}
-
-TEST_P(AudioSystemImplTest, GetOutputStreamParameters) {
-  EXPECT_CALL(*this, AudioParametersReceived());
-  audio_system_->GetOutputStreamParameters(
-      kNonDefaultDeviceId, base::Bind(&AudioSystemImplTest::OnAudioParams,
-                                      base::Unretained(this), output_params_));
-  WaitForCallback();
-}
-
-TEST_P(AudioSystemImplTest, GetDefaultOutputStreamParameters) {
-  EXPECT_CALL(*this, AudioParametersReceived());
-  audio_system_->GetOutputStreamParameters(
-      AudioDeviceDescription::kDefaultDeviceId,
-      base::Bind(&AudioSystemImplTest::OnAudioParams, base::Unretained(this),
-                 default_output_params_));
-  WaitForCallback();
-}
-
-TEST_P(AudioSystemImplTest, GetOutputStreamParametersNoDevice) {
-  audio_manager_->SetHasOutputDevices(false);
-  EXPECT_CALL(*this, AudioParametersReceived()).Times(2);
-
-  audio_system_->GetOutputStreamParameters(
-      AudioDeviceDescription::kDefaultDeviceId,
-      base::Bind(&AudioSystemImplTest::OnAudioParams, base::Unretained(this),
-                 base::Optional<AudioParameters>()));
-  WaitForCallback();
-
-  audio_system_->GetOutputStreamParameters(
-      kNonDefaultDeviceId,
-      base::Bind(&AudioSystemImplTest::OnAudioParams, base::Unretained(this),
-                 base::Optional<AudioParameters>()));
-  WaitForCallback();
-}
-
-TEST_P(AudioSystemImplTest, HasInputDevices) {
-  EXPECT_CALL(*this, HasInputDevicesCallback(true));
-  audio_system_->HasInputDevices(base::Bind(
-      &AudioSystemImplTest::OnHasInputDevices, base::Unretained(this)));
-  WaitForCallback();
-}
-
-TEST_P(AudioSystemImplTest, HasNoInputDevices) {
-  audio_manager_->SetHasInputDevices(false);
-  EXPECT_CALL(*this, HasInputDevicesCallback(false));
-  audio_system_->HasInputDevices(base::Bind(
-      &AudioSystemImplTest::OnHasInputDevices, base::Unretained(this)));
-  WaitForCallback();
-}
-
-TEST_P(AudioSystemImplTest, HasOutputDevices) {
-  EXPECT_CALL(*this, HasOutputDevicesCallback(true));
-  audio_system_->HasOutputDevices(base::Bind(
-      &AudioSystemImplTest::OnHasOutputDevices, base::Unretained(this)));
-  WaitForCallback();
-}
-
-TEST_P(AudioSystemImplTest, HasNoOutputDevices) {
-  audio_manager_->SetHasOutputDevices(false);
-  EXPECT_CALL(*this, HasOutputDevicesCallback(false));
-  audio_system_->HasOutputDevices(base::Bind(
-      &AudioSystemImplTest::OnHasOutputDevices, base::Unretained(this)));
-  WaitForCallback();
-}
-
-TEST_P(AudioSystemImplTest, GetInputDeviceDescriptionsNoInputDevices) {
-  output_device_descriptions_.emplace_back("output_device_name",
-                                           "output_device_id", "group_id");
-  EXPECT_EQ(0, static_cast<int>(input_device_descriptions_.size()));
-  EXPECT_EQ(1, static_cast<int>(output_device_descriptions_.size()));
-  EXPECT_CALL(*this, DeviceDescriptionsReceived());
-  audio_system_->GetDeviceDescriptions(
-      true, base::Bind(&AudioSystemImplTest::OnGetDeviceDescriptions,
-                       base::Unretained(this), input_device_descriptions_));
-  WaitForCallback();
-}
-
-TEST_P(AudioSystemImplTest, GetInputDeviceDescriptions) {
-  output_device_descriptions_.emplace_back("output_device_name",
-                                           "output_device_id", "group_id");
-  input_device_descriptions_.emplace_back("input_device_name1",
-                                          "input_device_id1", "group_id1");
-  input_device_descriptions_.emplace_back("input_device_name2",
-                                          "input_device_id2", "group_id2");
-  EXPECT_EQ(2, static_cast<int>(input_device_descriptions_.size()));
-  EXPECT_EQ(1, static_cast<int>(output_device_descriptions_.size()));
-  EXPECT_CALL(*this, DeviceDescriptionsReceived());
-  audio_system_->GetDeviceDescriptions(
-      true, base::Bind(&AudioSystemImplTest::OnGetDeviceDescriptions,
-                       base::Unretained(this), input_device_descriptions_));
-  WaitForCallback();
-}
-
-TEST_P(AudioSystemImplTest, GetOutputDeviceDescriptionsNoInputDevices) {
-  input_device_descriptions_.emplace_back("input_device_name",
-                                          "input_device_id", "group_id");
-  EXPECT_EQ(0, static_cast<int>(output_device_descriptions_.size()));
-  EXPECT_EQ(1, static_cast<int>(input_device_descriptions_.size()));
-  EXPECT_CALL(*this, DeviceDescriptionsReceived());
-  audio_system_->GetDeviceDescriptions(
-      false, base::Bind(&AudioSystemImplTest::OnGetDeviceDescriptions,
-                        base::Unretained(this), output_device_descriptions_));
-  WaitForCallback();
-}
-
-TEST_P(AudioSystemImplTest, GetOutputDeviceDescriptions) {
-  input_device_descriptions_.emplace_back("input_device_name",
-                                          "input_device_id", "group_id");
-  output_device_descriptions_.emplace_back("output_device_name1",
-                                           "output_device_id1", "group_id1");
-  output_device_descriptions_.emplace_back("output_device_name2",
-                                           "output_device_id2", "group_id2");
-  EXPECT_EQ(2, static_cast<int>(output_device_descriptions_.size()));
-  EXPECT_EQ(1, static_cast<int>(input_device_descriptions_.size()));
-  EXPECT_CALL(*this, DeviceDescriptionsReceived());
-  audio_system_->GetDeviceDescriptions(
-      false, base::Bind(&AudioSystemImplTest::OnGetDeviceDescriptions,
-                        base::Unretained(this), output_device_descriptions_));
-  WaitForCallback();
-}
-
-TEST_P(AudioSystemImplTest, GetAssociatedOutputDeviceID) {
-  const std::string associated_id("associated_id");
-  audio_manager_->SetAssociatedOutputDeviceIDCallback(
-      base::Bind([](const std::string& result,
-                    const std::string&) -> std::string { return result; },
-                 associated_id));
-
-  EXPECT_CALL(*this, AssociatedOutputDeviceIDReceived(associated_id));
-
-  audio_system_->GetAssociatedOutputDeviceID(
-      std::string(),
-      base::Bind(&AudioSystemImplTest::AssociatedOutputDeviceIDReceived,
-                 base::Unretained(this)));
-  WaitForCallback();
-}
-
-TEST_P(AudioSystemImplTest, GetInputDeviceInfoNoAssociation) {
-  EXPECT_CALL(*this, InputDeviceInfoReceived());
-
-  audio_system_->GetInputDeviceInfo(
-      kNonDefaultDeviceId,
-      base::Bind(&AudioSystemImplTest::OnInputDeviceInfo,
-                 base::Unretained(this), input_params_,
-                 base::Optional<AudioParameters>(), std::string()));
-  WaitForCallback();
-}
-
-TEST_P(AudioSystemImplTest, GetInputDeviceInfoWithAssociation) {
-  EXPECT_CALL(*this, InputDeviceInfoReceived());
-
-  const std::string associated_id("associated_id");
-  audio_manager_->SetAssociatedOutputDeviceIDCallback(
-      base::Bind([](const std::string& result,
-                    const std::string&) -> std::string { return result; },
-                 associated_id));
-
-  audio_system_->GetInputDeviceInfo(
-      kNonDefaultDeviceId, base::Bind(&AudioSystemImplTest::OnInputDeviceInfo,
-                                      base::Unretained(this), input_params_,
-                                      output_params_, associated_id));
-  WaitForCallback();
-}
+using AudioSystemTestBaseVariations =
+    testing::Types<AudioSystemImplTestBase<false>,
+                   AudioSystemImplTestBase<true>>;
 
-INSTANTIATE_TEST_CASE_P(, AudioSystemImplTest, testing::Values(false, true));
+INSTANTIATE_TYPED_TEST_CASE_P(AudioSystemImpl,
+                              AudioSystemTestTemplate,
+                              AudioSystemTestBaseVariations);
 
 }  // namespace media

media/audio/audio_system_test_util.cc

+// Copyright 2017 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 "media/audio/audio_system_test_util.h"
+
+#include "base/bind.h"
+#include "base/memory/ptr_util.h"
+
+namespace media {
+
+bool operator==(const AudioDeviceDescription& lhs,
+                const AudioDeviceDescription& rhs) {
+  return lhs.device_name == rhs.device_name && lhs.unique_id == rhs.unique_id &&
+         lhs.group_id == rhs.group_id;
+}
+
+AudioSystem::OnAudioParamsCallback
+AudioSystemCallbackExpectations::GetAudioParamsCallback(
+    const base::Location& location,
+    base::OnceClosure on_cb_received,
+    const base::Optional<AudioParameters>& expected_params) {
+  return base::BindOnce(&AudioSystemCallbackExpectations::OnAudioParams,
+                        base::Unretained(this), location.ToString(),
+                        std::move(on_cb_received), expected_params);
+}
+
+AudioSystem::OnBoolCallback AudioSystemCallbackExpectations::GetBoolCallback(
+    const base::Location& location,
+    base::OnceClosure on_cb_received,
+    bool expected) {
+  return base::BindOnce(&AudioSystemCallbackExpectations::OnBool,
+                        base::Unretained(this), location.ToString(),
+                        std::move(on_cb_received), expected);
+}
+
+AudioSystem::OnDeviceDescriptionsCallback
+AudioSystemCallbackExpectations::GetDeviceDescriptionsCallback(
+    const base::Location& location,
+    base::OnceClosure on_cb_received,
+    const AudioDeviceDescriptions& expected_descriptions) {
+  return base::BindOnce(&AudioSystemCallbackExpectations::OnDeviceDescriptions,
+                        base::Unretained(this), location.ToString(),
+                        std::move(on_cb_received), expected_descriptions);
+}
+
+AudioSystem::OnInputDeviceInfoCallback
+AudioSystemCallbackExpectations::GetInputDeviceInfoCallback(
+    const base::Location& location,
+    base::OnceClosure on_cb_received,
+    const base::Optional<AudioParameters>& expected_input,
+    const base::Optional<AudioParameters>& expected_associated_output,
+    const std::string& expected_associated_device_id) {
+  return base::BindOnce(&AudioSystemCallbackExpectations::OnInputDeviceInfo,
+                        base::Unretained(this), location.ToString(),
+                        std::move(on_cb_received), expected_input,
+                        expected_associated_output,
+                        expected_associated_device_id);
+}
+
+AudioSystem::OnDeviceIdCallback
+AudioSystemCallbackExpectations::GetDeviceIdCallback(
+    const base::Location& location,
+    base::OnceClosure on_cb_received,
+    const std::string& expected_id) {
+  return base::BindOnce(&AudioSystemCallbackExpectations::OnDeviceId,
+                        base::Unretained(this), location.ToString(),
+                        std::move(on_cb_received), expected_id);
+}
+
+void AudioSystemCallbackExpectations::OnAudioParams(
+    const std::string& from_here,
+    base::OnceClosure on_cb_received,
+    const base::Optional<AudioParameters>& expected,
+    const base::Optional<AudioParameters>& received) {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_) << from_here;
+  if (expected) {
+    EXPECT_TRUE(received) << from_here;
+    EXPECT_EQ(expected->AsHumanReadableString(),
+              received->AsHumanReadableString())
+        << from_here;
+  } else {
+    EXPECT_FALSE(received) << from_here;
+  }
+  std::move(on_cb_received).Run();
+}
+
+void AudioSystemCallbackExpectations::OnBool(const std::string& from_here,
+                                             base::OnceClosure on_cb_received,
+                                             bool expected,
+                                             bool result) {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_) << from_here;
+  EXPECT_EQ(expected, result) << from_here;
+  std::move(on_cb_received).Run();
+}
+
+void AudioSystemCallbackExpectations::OnDeviceDescriptions(
+    const std::string& from_here,
+    base::OnceClosure on_cb_received,
+    const AudioDeviceDescriptions& expected_descriptions,
+    AudioDeviceDescriptions descriptions) {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_) << from_here;
+  EXPECT_EQ(expected_descriptions, descriptions);
+  std::move(on_cb_received).Run();
+}
+
+void AudioSystemCallbackExpectations::OnInputDeviceInfo(
+    const std::string& from_here,
+    base::OnceClosure on_cb_received,
+    const base::Optional<AudioParameters>& expected_input,
+    const base::Optional<AudioParameters>& expected_associated_output,
+    const std::string& expected_associated_device_id,
+    const base::Optional<AudioParameters>& input,
+    const base::Optional<AudioParameters>& associated_output,
+    const std::string& associated_device_id) {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_) << from_here;
+  if (expected_input) {
+    EXPECT_TRUE(input) << from_here;
+    EXPECT_EQ(expected_input->AsHumanReadableString(),
+              input->AsHumanReadableString())
+        << from_here;
+  } else {
+    EXPECT_FALSE(input) << from_here;
+  }
+  if (expected_associated_output) {
+    EXPECT_TRUE(associated_output) << from_here;
+    EXPECT_EQ(expected_associated_output->AsHumanReadableString(),
+              associated_output->AsHumanReadableString())
+        << from_here;
+  } else {
+    EXPECT_FALSE(associated_output) << from_here;
+  }
+  EXPECT_EQ(expected_associated_device_id, associated_device_id) << from_here;
+  std::move(on_cb_received).Run();
+}
+
+void AudioSystemCallbackExpectations::OnDeviceId(
+    const std::string& from_here,
+    base::OnceClosure on_cb_received,
+    const std::string& expected_id,
+    const std::string& result_id) {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_) << from_here;
+  EXPECT_EQ(expected_id, result_id) << from_here;
+  std::move(on_cb_received).Run();
+}
+
+}  // namespace media

media/audio/audio_system_test_util.h

+// Copyright 2017 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.
+
+#ifndef MEDIA_AUDIO_AUDIO_SYSTEM_TEST_UTIL_H_
+#define MEDIA_AUDIO_AUDIO_SYSTEM_TEST_UTIL_H_
+
+#include "base/bind.h"
+#include "base/location.h"
+#include "base/macros.h"
+#include "base/message_loop/message_loop.h"
+#include "base/optional.h"
+#include "base/run_loop.h"
+#include "base/threading/thread_checker.h"
+#include "media/audio/audio_device_description.h"
+#include "media/audio/audio_system.h"
+#include "media/audio/mock_audio_manager.h"
+#include "media/base/audio_parameters.h"
+#include "testing/gmock/include/gmock/gmock.h"
+
+namespace media {
+
+// For tests only. Creates AudioSystem callbacks to be passed to AudioSystem
+// methods. When AudioSystem calls such a callback, it verifies treading
+// expectations and checks recieved parameters against expected values passed
+// during its creation. After that it calls |on_cb_received| closure.
+// Note AudioSystemCallbackExpectations object must outlive all the callbacks
+// it produced, since they contain raw pointers to it.
+class AudioSystemCallbackExpectations {
+ public:
+  AudioSystemCallbackExpectations() = default;
+  AudioSystem::OnAudioParamsCallback GetAudioParamsCallback(
+      const base::Location& location,
+      base::OnceClosure on_cb_received,
+      const base::Optional<AudioParameters>& expected_params);
+
+  AudioSystem::OnBoolCallback GetBoolCallback(const base::Location& location,
+                                              base::OnceClosure on_cb_received,
+                                              bool expected);
+
+  AudioSystem::OnDeviceDescriptionsCallback GetDeviceDescriptionsCallback(
+      const base::Location& location,
+      base::OnceClosure on_cb_received,
+      const AudioDeviceDescriptions& expected_descriptions);
+
+  AudioSystem::OnInputDeviceInfoCallback GetInputDeviceInfoCallback(
+      const base::Location& location,
+      base::OnceClosure on_cb_received,
+      const base::Optional<AudioParameters>& expected_input,
+      const base::Optional<AudioParameters>& expected_associated_output,
+      const std::string& expected_associated_device_id);
+
+  AudioSystem::OnDeviceIdCallback GetDeviceIdCallback(
+      const base::Location& location,
+      base::OnceClosure on_cb_received,
+      const std::string& expected_id);
+
+ private:
+  // Methods to verify correctness of received data.
+  void OnAudioParams(const std::string& from_here,
+                     base::OnceClosure on_cb_received,
+                     const base::Optional<AudioParameters>& expected,
+                     const base::Optional<AudioParameters>& received);
+
+  void OnBool(const std::string& from_here,
+              base::OnceClosure on_cb_received,
+              bool expected,
+              bool result);
+
+  void OnDeviceDescriptions(
+      const std::string& from_here,
+      base::OnceClosure on_cb_received,
+      const AudioDeviceDescriptions& expected_descriptions,
+      AudioDeviceDescriptions descriptions);
+
+  void OnInputDeviceInfo(
+      const std::string& from_here,
+      base::OnceClosure on_cb_received,
+      const base::Optional<AudioParameters>& expected_input,
+      const base::Optional<AudioParameters>& expected_associated_output,
+      const std::string& expected_associated_device_id,
+      const base::Optional<AudioParameters>& input,
+      const base::Optional<AudioParameters>& associated_output,
+      const std::string& associated_device_id);
+
+  void OnDeviceId(const std::string& from_here,
+                  base::OnceClosure on_cb_received,
+                  const std::string& expected_id,
+                  const std::string& result_id);
+
+  THREAD_CHECKER(thread_checker_);
+  DISALLOW_COPY_AND_ASSIGN(AudioSystemCallbackExpectations);
+};
+
+// Template test case to test AudioSystem implementations.
+template <class T>
+class AudioSystemTestTemplate : public T {
+ public:
+  AudioSystemTestTemplate() {}
+  ~AudioSystemTestTemplate() override {}
+
+  void SetUp() override {
+    T::SetUp();
+    input_params_ =
+        AudioParameters(AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_MONO,
+                        AudioParameters::kTelephoneSampleRate, 16,
+                        AudioParameters::kTelephoneSampleRate / 10);
+    output_params_ =
+        AudioParameters(AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_MONO,
+                        AudioParameters::kTelephoneSampleRate, 16,
+                        AudioParameters::kTelephoneSampleRate / 20);
+    default_output_params_ =
+        AudioParameters(AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_MONO,
+                        AudioParameters::kTelephoneSampleRate, 16,
+                        AudioParameters::kTelephoneSampleRate / 30);
+    audio_manager()->SetInputStreamParameters(input_params_);
+    audio_manager()->SetOutputStreamParameters(output_params_);
+    audio_manager()->SetDefaultOutputStreamParameters(default_output_params_);
+
+    auto get_device_descriptions = [](const AudioDeviceDescriptions* source,
+                                      AudioDeviceDescriptions* destination) {
+      destination->insert(destination->end(), source->begin(), source->end());
+    };
+
+    audio_manager()->SetInputDeviceDescriptionsCallback(
+        base::Bind(get_device_descriptions,
+                   base::Unretained(&input_device_descriptions_)));
+    audio_manager()->SetOutputDeviceDescriptionsCallback(
+        base::Bind(get_device_descriptions,
+                   base::Unretained(&output_device_descriptions_)));
+  }
+
+ protected:
+  MockAudioManager* audio_manager() { return T::audio_manager(); }
+  AudioSystem* audio_system() { return T::audio_system(); }
+
+  AudioSystemCallbackExpectations expectations_;
+  AudioParameters input_params_;
+  AudioParameters output_params_;
+  AudioParameters default_output_params_;
+  AudioDeviceDescriptions input_device_descriptions_;
+  AudioDeviceDescriptions output_device_descriptions_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AudioSystemTestTemplate);
+};
+
+TYPED_TEST_CASE_P(AudioSystemTestTemplate);
+
+TYPED_TEST_P(AudioSystemTestTemplate, GetInputStreamParametersNormal) {
+  base::RunLoop wait_loop;
+  this->audio_system()->GetInputStreamParameters(
+      AudioDeviceDescription::kDefaultDeviceId,
+      this->expectations_.GetAudioParamsCallback(
+          FROM_HERE, wait_loop.QuitClosure(), this->input_params_));
+  wait_loop.Run();
+}
+
+TYPED_TEST_P(AudioSystemTestTemplate, GetInputStreamParametersNoDevice) {
+  this->audio_manager()->SetHasInputDevices(false);
+
+  base::RunLoop wait_loop;
+  this->audio_system()->GetInputStreamParameters(
+      AudioDeviceDescription::kDefaultDeviceId,
+      this->expectations_.GetAudioParamsCallback(
+          FROM_HERE, wait_loop.QuitClosure(),
+          base::Optional<AudioParameters>()));
+  wait_loop.Run();
+}
+
+TYPED_TEST_P(AudioSystemTestTemplate, GetOutputStreamParameters) {
+  base::RunLoop wait_loop;
+  this->audio_system()->GetOutputStreamParameters(
+      "non-default-device-id",
+      this->expectations_.GetAudioParamsCallback(
+          FROM_HERE, wait_loop.QuitClosure(), this->output_params_));
+  wait_loop.Run();
+}
+
+TYPED_TEST_P(AudioSystemTestTemplate, GetDefaultOutputStreamParameters) {
+  base::RunLoop wait_loop;
+  this->audio_system()->GetOutputStreamParameters(
+      AudioDeviceDescription::kDefaultDeviceId,
+      this->expectations_.GetAudioParamsCallback(
+          FROM_HERE, wait_loop.QuitClosure(), this->default_output_params_));
+  wait_loop.Run();
+}
+
+TYPED_TEST_P(AudioSystemTestTemplate,
+             GetOutputStreamParametersForDefaultDeviceNoDevices) {
+  this->audio_manager()->SetHasOutputDevices(false);
+  base::RunLoop wait_loop;
+  this->audio_system()->GetOutputStreamParameters(
+      AudioDeviceDescription::kDefaultDeviceId,
+      this->expectations_.GetAudioParamsCallback(
+          FROM_HERE, wait_loop.QuitClosure(),
+          base::Optional<AudioParameters>()));
+  wait_loop.Run();
+}
+
+TYPED_TEST_P(AudioSystemTestTemplate,
+             GetOutputStreamParametersForNonDefaultDeviceNoDevices) {
+  this->audio_manager()->SetHasOutputDevices(false);
+  base::RunLoop wait_loop;
+  this->audio_system()->GetOutputStreamParameters(
+      "non-default-device-id", this->expectations_.GetAudioParamsCallback(
+                                   FROM_HERE, wait_loop.QuitClosure(),
+                                   base::Optional<AudioParameters>()));
+  wait_loop.Run();
+}
+
+TYPED_TEST_P(AudioSystemTestTemplate, HasInputDevices) {
+  base::RunLoop wait_loop;
+  this->audio_system()->HasInputDevices(this->expectations_.GetBoolCallback(
+      FROM_HERE, wait_loop.QuitClosure(), true));
+  wait_loop.Run();
+}
+
+TYPED_TEST_P(AudioSystemTestTemplate, HasNoInputDevices) {
+  this->audio_manager()->SetHasInputDevices(false);
+  base::RunLoop wait_loop;
+  this->audio_system()->HasInputDevices(this->expectations_.GetBoolCallback(
+      FROM_HERE, wait_loop.QuitClosure(), false));
+  wait_loop.Run();
+}
+
+TYPED_TEST_P(AudioSystemTestTemplate, HasOutputDevices) {
+  base::RunLoop wait_loop;
+  this->audio_system()->HasOutputDevices(this->expectations_.GetBoolCallback(
+      FROM_HERE, wait_loop.QuitClosure(), true));
+  wait_loop.Run();
+}
+
+TYPED_TEST_P(AudioSystemTestTemplate, HasNoOutputDevices) {
+  this->audio_manager()->SetHasOutputDevices(false);
+  base::RunLoop wait_loop;
+  this->audio_system()->HasOutputDevices(this->expectations_.GetBoolCallback(
+      FROM_HERE, wait_loop.QuitClosure(), false));
+  wait_loop.Run();
+}
+
+TYPED_TEST_P(AudioSystemTestTemplate,
+             GetInputDeviceDescriptionsNoInputDevices) {
+  this->output_device_descriptions_.emplace_back(
+      "output_device_name", "output_device_id", "group_id");
+  EXPECT_EQ(0, static_cast<int>(this->input_device_descriptions_.size()));
+  EXPECT_EQ(1, static_cast<int>(this->output_device_descriptions_.size()));
+
+  base::RunLoop wait_loop;
+  this->audio_system()->GetDeviceDescriptions(
+      true, this->expectations_.GetDeviceDescriptionsCallback(
+                FROM_HERE, wait_loop.QuitClosure(),
+                this->input_device_descriptions_));
+  wait_loop.Run();
+}
+
+TYPED_TEST_P(AudioSystemTestTemplate, GetInputDeviceDescriptions) {
+  this->output_device_descriptions_.emplace_back(
+      "output_device_name", "output_device_id", "group_id");
+  this->input_device_descriptions_.emplace_back(
+      "input_device_name1", "input_device_id1", "group_id1");
+  this->input_device_descriptions_.emplace_back(
+      "input_device_name2", "input_device_id2", "group_id2");
+  EXPECT_EQ(2, static_cast<int>(this->input_device_descriptions_.size()));
+  EXPECT_EQ(1, static_cast<int>(this->output_device_descriptions_.size()));
+
+  base::RunLoop wait_loop;
+  this->audio_system()->GetDeviceDescriptions(
+      true, this->expectations_.GetDeviceDescriptionsCallback(
+                FROM_HERE, wait_loop.QuitClosure(),
+                this->input_device_descriptions_));
+  wait_loop.Run();
+}
+
+TYPED_TEST_P(AudioSystemTestTemplate,
+             GetOutputDeviceDescriptionsNoInputDevices) {
+  this->input_device_descriptions_.emplace_back("input_device_name",
+                                                "input_device_id", "group_id");
+  EXPECT_EQ(0, static_cast<int>(this->output_device_descriptions_.size()));
+  EXPECT_EQ(1, static_cast<int>(this->input_device_descriptions_.size()));
+
+  base::RunLoop wait_loop;
+  this->audio_system()->GetDeviceDescriptions(
+      false, this->expectations_.GetDeviceDescriptionsCallback(
+                 FROM_HERE, wait_loop.QuitClosure(),
+                 this->output_device_descriptions_));
+  wait_loop.Run();
+}
+
+TYPED_TEST_P(AudioSystemTestTemplate, GetOutputDeviceDescriptions) {
+  this->input_device_descriptions_.emplace_back("input_device_name",
+                                                "input_device_id", "group_id");
+  this->output_device_descriptions_.emplace_back(
+      "output_device_name1", "output_device_id1", "group_id1");
+  this->output_device_descriptions_.emplace_back(
+      "output_device_name2", "output_device_id2", "group_id2");
+  EXPECT_EQ(2, static_cast<int>(this->output_device_descriptions_.size()));
+  EXPECT_EQ(1, static_cast<int>(this->input_device_descriptions_.size()));
+
+  base::RunLoop wait_loop;
+  this->audio_system()->GetDeviceDescriptions(
+      false, this->expectations_.GetDeviceDescriptionsCallback(
+                 FROM_HERE, wait_loop.QuitClosure(),
+                 this->output_device_descriptions_));
+  wait_loop.Run();
+}
+
+TYPED_TEST_P(AudioSystemTestTemplate, GetAssociatedOutputDeviceID) {
+  const std::string associated_id("associated_id");
+  this->audio_manager()->SetAssociatedOutputDeviceIDCallback(
+      base::Bind([](const std::string& result,
+                    const std::string&) -> std::string { return result; },
+                 associated_id));
+
+  base::RunLoop wait_loop;
+  this->audio_system()->GetAssociatedOutputDeviceID(
+      std::string(), this->expectations_.GetDeviceIdCallback(
+                         FROM_HERE, wait_loop.QuitClosure(), associated_id));
+  wait_loop.Run();
+}
+
+TYPED_TEST_P(AudioSystemTestTemplate, GetInputDeviceInfoNoAssociation) {
+  base::RunLoop wait_loop;
+  this->audio_system()->GetInputDeviceInfo(
+      "non-default-device-id",
+      this->expectations_.GetInputDeviceInfoCallback(
+          FROM_HERE, wait_loop.QuitClosure(), this->input_params_,
+          base::Optional<AudioParameters>(), std::string()));
+  wait_loop.Run();
+}
+
+TYPED_TEST_P(AudioSystemTestTemplate, GetInputDeviceInfoWithAssociation) {
+  const std::string associated_id("associated_id");
+  this->audio_manager()->SetAssociatedOutputDeviceIDCallback(
+      base::Bind([](const std::string& result,
+                    const std::string&) -> std::string { return result; },
+                 associated_id));
+
+  base::RunLoop wait_loop;
+  this->audio_system()->GetInputDeviceInfo(
+      "non-default-device-id",
+      this->expectations_.GetInputDeviceInfoCallback(
+          FROM_HERE, wait_loop.QuitClosure(), this->input_params_,
+          this->output_params_, associated_id));
+  wait_loop.Run();
+}
+
+REGISTER_TYPED_TEST_CASE_P(
+    AudioSystemTestTemplate,
+    GetInputStreamParametersNormal,
+    GetInputStreamParametersNoDevice,
+    GetOutputStreamParameters,
+    GetDefaultOutputStreamParameters,
+    GetOutputStreamParametersForDefaultDeviceNoDevices,
+    GetOutputStreamParametersForNonDefaultDeviceNoDevices,
+    HasInputDevices,
+    HasNoInputDevices,
+    HasOutputDevices,
+    HasNoOutputDevices,
+    GetInputDeviceDescriptionsNoInputDevices,
+    GetInputDeviceDescriptions,
+    GetOutputDeviceDescriptionsNoInputDevices,
+    GetOutputDeviceDescriptions,
+    GetAssociatedOutputDeviceID,
+    GetInputDeviceInfoNoAssociation,
+    GetInputDeviceInfoWithAssociation);
+
+}  // namespace media
+
+#endif  // MEDIA_AUDIO_AUDIO_SYSTEM_TEST_UTIL_H_