| // Copyright 2018 The Chromium OS 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 <memory> |
| #include <utility> |
| #include <vector> |
| |
| #include <base/bind.h> |
| #include <base/run_loop.h> |
| #include <gmock/gmock.h> |
| #include <gtest/gtest.h> |
| |
| #include "media_perception/device_management.pb.h" |
| #include "media_perception/fake_chrome_audio_service_client.h" |
| #include "media_perception/fake_rtanalytics.h" |
| #include "media_perception/fake_video_capture_service_client.h" |
| #include "media_perception/media_perception_impl.h" |
| #include "media_perception/proto_mojom_conversion.h" |
| #include "media_perception/serialized_proto.h" |
| |
| namespace mri { |
| namespace { |
| |
| class MediaPerceptionImplTest : public testing::Test { |
| protected: |
| void SetUp() override { |
| fake_vidcap_client_ = new FakeVideoCaptureServiceClient(); |
| vidcap_client_ = std::shared_ptr<VideoCaptureServiceClient>( |
| fake_vidcap_client_); |
| fake_cras_client_ = new FakeChromeAudioServiceClient(); |
| cras_client_ = std::shared_ptr<ChromeAudioServiceClient>( |
| fake_cras_client_); |
| fake_rtanalytics_ = new FakeRtanalytics(); |
| rtanalytics_ = std::shared_ptr<Rtanalytics>(fake_rtanalytics_); |
| media_perception_impl_ = std::make_unique<MediaPerceptionImpl>( |
| mojo::MakeRequest(&media_perception_ptr_), |
| vidcap_client_, cras_client_, rtanalytics_); |
| } |
| |
| chromeos::media_perception::mojom::MediaPerceptionPtr media_perception_ptr_; |
| FakeVideoCaptureServiceClient* fake_vidcap_client_; |
| std::shared_ptr<VideoCaptureServiceClient> vidcap_client_; |
| FakeChromeAudioServiceClient* fake_cras_client_; |
| std::shared_ptr<ChromeAudioServiceClient> cras_client_; |
| FakeRtanalytics* fake_rtanalytics_; |
| std::shared_ptr<Rtanalytics> rtanalytics_; |
| std::unique_ptr<MediaPerceptionImpl> media_perception_impl_; |
| }; |
| |
| TEST_F(MediaPerceptionImplTest, TestGetVideoDevices) { |
| bool get_devices_callback_done = false; |
| media_perception_ptr_->GetVideoDevices( |
| base::Bind([](bool* get_devices_callback_done, |
| std::vector<chromeos::media_perception::mojom::VideoDevicePtr> |
| devices) { |
| EXPECT_EQ(devices.size(), 0); |
| *get_devices_callback_done = true; |
| }, &get_devices_callback_done)); |
| base::RunLoop().RunUntilIdle(); |
| ASSERT_TRUE(get_devices_callback_done); |
| |
| // Set up a couple of fake devices. |
| std::vector<SerializedVideoDevice> serialized_devices; |
| VideoDevice device; |
| device.set_id("1"); |
| serialized_devices.push_back(Serialized<VideoDevice>(device).GetBytes()); |
| device.set_id("2"); |
| serialized_devices.push_back(Serialized<VideoDevice>(device).GetBytes()); |
| fake_vidcap_client_->SetDevicesForGetDevices(serialized_devices); |
| |
| get_devices_callback_done = false; |
| media_perception_ptr_->GetVideoDevices( |
| base::Bind([](bool *get_devices_callback_done, |
| std::vector<chromeos::media_perception::mojom::VideoDevicePtr> |
| devices) { |
| EXPECT_EQ(devices.size(), 2); |
| EXPECT_EQ(devices[0]->id, "1"); |
| EXPECT_EQ(devices[1]->id, "2"); |
| *get_devices_callback_done = true; |
| }, &get_devices_callback_done)); |
| base::RunLoop().RunUntilIdle(); |
| ASSERT_TRUE(get_devices_callback_done); |
| } |
| |
| TEST_F(MediaPerceptionImplTest, TestGetAudioDevices) { |
| bool get_devices_callback_done = false; |
| media_perception_ptr_->GetAudioDevices( |
| base::Bind([](bool* get_devices_callback_done, |
| std::vector<chromeos::media_perception::mojom::AudioDevicePtr> |
| devices) { |
| EXPECT_EQ(devices.size(), 0); |
| *get_devices_callback_done = true; |
| }, &get_devices_callback_done)); |
| base::RunLoop().RunUntilIdle(); |
| ASSERT_TRUE(get_devices_callback_done); |
| |
| // Set up a couple of fake devices. |
| std::vector<SerializedAudioDevice> serialized_devices; |
| AudioDevice device; |
| device.set_id("1"); |
| serialized_devices.push_back(Serialized<AudioDevice>(device).GetBytes()); |
| device.set_id("2"); |
| serialized_devices.push_back(Serialized<AudioDevice>(device).GetBytes()); |
| fake_cras_client_->SetDevicesForGetInputDevices(serialized_devices); |
| |
| get_devices_callback_done = false; |
| media_perception_ptr_->GetAudioDevices( |
| base::Bind([](bool *get_devices_callback_done, |
| std::vector<chromeos::media_perception::mojom::AudioDevicePtr> |
| devices) { |
| EXPECT_EQ(devices.size(), 2); |
| EXPECT_EQ(devices[0]->id, "1"); |
| EXPECT_EQ(devices[1]->id, "2"); |
| *get_devices_callback_done = true; |
| }, &get_devices_callback_done)); |
| base::RunLoop().RunUntilIdle(); |
| ASSERT_TRUE(get_devices_callback_done); |
| } |
| |
| TEST_F(MediaPerceptionImplTest, TestSetupConfiguration) { |
| bool setup_configuration_callback_done = false; |
| |
| media_perception_ptr_->SetupConfiguration( |
| "test_configuration", |
| base::Bind([]( |
| bool* setup_configuration_callback_done, |
| chromeos::media_perception::mojom::SuccessStatusPtr status, |
| chromeos::media_perception::mojom::PerceptionInterfacesPtr |
| requests) { |
| EXPECT_EQ(status->success, true); |
| EXPECT_EQ(*status->failure_reason, "test_configuration"); |
| *setup_configuration_callback_done = true; |
| }, &setup_configuration_callback_done)); |
| base::RunLoop().RunUntilIdle(); |
| ASSERT_TRUE(setup_configuration_callback_done); |
| } |
| |
| TEST_F(MediaPerceptionImplTest, TestSetTemplateArguments) { |
| bool set_template_arguments_callback_done = false; |
| std::vector<uint8_t> arguments; |
| |
| media_perception_ptr_->SetTemplateArguments( |
| "test_configuration", arguments, |
| base::Bind([]( |
| bool* set_template_arguments_callback_done, |
| chromeos::media_perception::mojom::SuccessStatusPtr status) { |
| EXPECT_EQ(status->success, true); |
| EXPECT_EQ(*status->failure_reason, "test_configuration"); |
| *set_template_arguments_callback_done = true; |
| }, &set_template_arguments_callback_done)); |
| base::RunLoop().RunUntilIdle(); |
| ASSERT_TRUE(set_template_arguments_callback_done); |
| } |
| |
| TEST_F(MediaPerceptionImplTest, TestGetTemplateDevices) { |
| DeviceTemplate template_one; |
| template_one.set_template_name("one"); |
| DeviceTemplate template_two; |
| template_two.set_template_name("two"); |
| std::vector<SerializedDeviceTemplate> device_templates; |
| device_templates.push_back( |
| Serialized<DeviceTemplate>(template_one).GetBytes()); |
| device_templates.push_back( |
| Serialized<DeviceTemplate>(template_two).GetBytes()); |
| fake_rtanalytics_->SetSerializedDeviceTemplates(device_templates); |
| |
| bool get_template_devices_callback_done = false; |
| media_perception_ptr_->GetTemplateDevices( |
| "test_configuration", |
| base::Bind([]( |
| bool* get_template_devices_callback_done, |
| std::vector<chromeos::media_perception::mojom::DeviceTemplatePtr> |
| device_templates) { |
| EXPECT_EQ(device_templates.size(), 2); |
| EXPECT_EQ(device_templates[0]->template_name, "one"); |
| EXPECT_EQ(device_templates[1]->template_name, "two"); |
| *get_template_devices_callback_done = true; |
| }, &get_template_devices_callback_done)); |
| base::RunLoop().RunUntilIdle(); |
| ASSERT_TRUE(get_template_devices_callback_done); |
| } |
| |
| TEST_F(MediaPerceptionImplTest, TestSetVideoDeviceForTemplateName) { |
| bool callback_done = false; |
| |
| chromeos::media_perception::mojom::VideoDevicePtr video_device = |
| chromeos::media_perception::mojom::VideoDevice::New(); |
| media_perception_ptr_->SetVideoDeviceForTemplateName( |
| "test_configuration", |
| "test_template", |
| std::move(video_device), |
| base::Bind([]( |
| bool* callback_done, |
| chromeos::media_perception::mojom::SuccessStatusPtr status) { |
| EXPECT_EQ(status->success, true); |
| EXPECT_EQ(*status->failure_reason, "test_template"); |
| *callback_done = true; |
| }, &callback_done)); |
| base::RunLoop().RunUntilIdle(); |
| ASSERT_TRUE(callback_done); |
| } |
| |
| TEST_F(MediaPerceptionImplTest, TestSetAudioDeviceForTemplateName) { |
| bool callback_done = false; |
| |
| chromeos::media_perception::mojom::AudioDevicePtr audio_device = |
| chromeos::media_perception::mojom::AudioDevice::New(); |
| media_perception_ptr_->SetAudioDeviceForTemplateName( |
| "test_configuration", |
| "test_template", |
| std::move(audio_device), |
| base::Bind([]( |
| bool* callback_done, |
| chromeos::media_perception::mojom::SuccessStatusPtr status) { |
| EXPECT_EQ(status->success, true); |
| EXPECT_EQ(*status->failure_reason, "test_template"); |
| *callback_done = true; |
| }, &callback_done)); |
| base::RunLoop().RunUntilIdle(); |
| ASSERT_TRUE(callback_done); |
| } |
| |
| TEST_F(MediaPerceptionImplTest, TestSetVirtualVideoDeviceForTemplateName) { |
| bool callback_done = false; |
| |
| chromeos::media_perception::mojom::VirtualVideoDevicePtr video_device = |
| chromeos::media_perception::mojom::VirtualVideoDevice::New(); |
| video_device->video_device = |
| chromeos::media_perception::mojom::VideoDevice::New(); |
| media_perception_ptr_->SetVirtualVideoDeviceForTemplateName( |
| "test_configuration", |
| "test_template", |
| std::move(video_device), |
| base::Bind([]( |
| bool* callback_done, |
| chromeos::media_perception::mojom::SuccessStatusPtr status) { |
| EXPECT_EQ(status->success, true); |
| EXPECT_EQ(*status->failure_reason, "test_template"); |
| *callback_done = true; |
| }, &callback_done)); |
| base::RunLoop().RunUntilIdle(); |
| ASSERT_TRUE(callback_done); |
| } |
| |
| TEST_F(MediaPerceptionImplTest, TestGetPipelineState) { |
| bool get_pipeline_callback_done = false; |
| |
| media_perception_ptr_->GetPipelineState( |
| "test_configuration", |
| base::Bind([]( |
| bool* get_pipeline_callback_done, |
| chromeos::media_perception::mojom::PipelineStatePtr pipeline_state) { |
| EXPECT_EQ(pipeline_state->status, |
| chromeos::media_perception::mojom::PipelineStatus::SUSPENDED); |
| *get_pipeline_callback_done = true; |
| }, &get_pipeline_callback_done)); |
| base::RunLoop().RunUntilIdle(); |
| ASSERT_TRUE(get_pipeline_callback_done); |
| } |
| |
| TEST_F(MediaPerceptionImplTest, TestSetPipelineState) { |
| bool set_pipeline_callback_done = false; |
| |
| chromeos::media_perception::mojom::PipelineStatePtr desired_pipeline_state = |
| chromeos::media_perception::mojom::PipelineState::New(); |
| desired_pipeline_state->status = |
| chromeos::media_perception::mojom::PipelineStatus::RUNNING; |
| media_perception_ptr_->SetPipelineState( |
| "test_configuration", |
| std::move(desired_pipeline_state), |
| base::Bind([]( |
| bool* set_pipeline_callback_done, |
| chromeos::media_perception::mojom::PipelineStatePtr pipeline_state) { |
| EXPECT_EQ(pipeline_state->status, |
| chromeos::media_perception::mojom::PipelineStatus::RUNNING); |
| *set_pipeline_callback_done = true; |
| }, &set_pipeline_callback_done)); |
| base::RunLoop().RunUntilIdle(); |
| ASSERT_TRUE(set_pipeline_callback_done); |
| } |
| |
| TEST_F(MediaPerceptionImplTest, TestGetGlobalPipelineState) { |
| bool get_global_pipeline_callback_done = false; |
| |
| media_perception_ptr_->GetGlobalPipelineState( |
| base::Bind([]( |
| bool* get_global_pipeline_callback_done, |
| chromeos::media_perception::mojom::GlobalPipelineStatePtr state) { |
| EXPECT_EQ(*state->states[0]->configuration_name, |
| "fake_configuration"); |
| *get_global_pipeline_callback_done = true; |
| }, &get_global_pipeline_callback_done)); |
| base::RunLoop().RunUntilIdle(); |
| ASSERT_TRUE(get_global_pipeline_callback_done); |
| } |
| |
| } // namespace |
| } // namespace mri |