From 37d1f3380e17913724f132a3fef8d4e2457503a4 Mon Sep 17 00:00:00 2001 From: zhangwt3652 Date: Mon, 18 Aug 2025 18:34:02 +0800 Subject: [PATCH] =?UTF-8?q?=E8=A1=A5=E5=85=85ut?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zhangwt3652 --- services/audio_policy/test/BUILD.gn | 429 ++++++++- .../audio_adapter_manager_ext_unit_test.h | 58 ++ .../audio_adapter_manager_ext_unit_test.cpp | 460 ++++++++++ .../src/audio_ec_manager_unit_test.cpp | 203 +++++ .../audio_policy_service_extended_unit_test.h | 57 ++ ...udio_policy_service_extended_unit_test.cpp | 831 ++++++++++++++++++ .../audio_volume_manager_ext_unit_test.h | 37 + .../audio_volume_manager_ext_unit_test.cpp | 377 ++++++++ .../src/privacy_priority_router_unit_test.cpp | 59 ++ .../user_select_router_ext_unit_test.h | 39 + .../src/user_select_router_ext_unit_test.cpp | 227 +++++ .../src/volume_data_maintainer_unit_test.cpp | 307 +++++++ 12 files changed, 3082 insertions(+), 2 deletions(-) create mode 100644 services/audio_policy/test/unittest/audio_adapter_manager_unit_test/include/audio_adapter_manager_ext_unit_test.h create mode 100644 services/audio_policy/test/unittest/audio_adapter_manager_unit_test/src/audio_adapter_manager_ext_unit_test.cpp create mode 100644 services/audio_policy/test/unittest/audio_policy_service_unit_test/include/audio_policy_service_extended_unit_test.h create mode 100644 services/audio_policy/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_extended_unit_test.cpp create mode 100644 services/audio_policy/test/unittest/audio_volume_manager_unit_test/include/audio_volume_manager_ext_unit_test.h create mode 100644 services/audio_policy/test/unittest/audio_volume_manager_unit_test/src/audio_volume_manager_ext_unit_test.cpp create mode 100644 services/audio_policy/test/unittest/user_select_router_unit_test/include/user_select_router_ext_unit_test.h create mode 100644 services/audio_policy/test/unittest/user_select_router_unit_test/src/user_select_router_ext_unit_test.cpp diff --git a/services/audio_policy/test/BUILD.gn b/services/audio_policy/test/BUILD.gn index c75bad0653..2d9116a2d2 100644 --- a/services/audio_policy/test/BUILD.gn +++ b/services/audio_policy/test/BUILD.gn @@ -26,6 +26,7 @@ group("audio_policy_unittest_packages") { deps = [ ":audio_a2dp_device_unit_test", ":audio_active_device_unit_test", + ":audio_adapter_manager_ext_unit_test", ":audio_adapter_manager_unit_test", ":audio_affinity_manager_unit_test", ":audio_affinity_parser_test", @@ -64,6 +65,7 @@ group("audio_policy_unittest_packages") { ":audio_policy_server_handler_unit_test", ":audio_policy_server_unit_test", ":audio_microphone_descriptor_unit_test", + ":audio_policy_service_extended_unit_test", ":audio_policy_service_first_unit_test", ":audio_policy_service_second_unit_test", ":audio_policy_service_third_unit_test", @@ -85,6 +87,7 @@ group("audio_policy_unittest_packages") { ":audio_setting_provider_unit_test", ":audio_tone_parser_unit_test", ":audio_usb_manager_unit_test", + ":audio_volume_manager_ext_unit_test", ":audio_volume_manager_unit_test", ":audio_zone_service_unit_test", ":audio_zone_unit_test", @@ -98,8 +101,8 @@ group("audio_policy_unittest_packages") { ":volume_data_maintainer_unit_test", ":audio_ipc_serialization_unit_test", ":audio_device_manager_unit_test", - ":user_select_router_unit_test", - "../server/domain/pipe/test/unittest:pipe_domain_unit_test_group" + ":user_select_router_ext_unit_test", + ":user_select_router_unit_test" ] } @@ -1341,6 +1344,198 @@ ohos_unittest("audio_policy_service_third_unit_test") { } } +ohos_unittest("audio_policy_service_extended_unit_test") { + module_out_path = module_output_path1 + include_dirs = [ + "./unittest/audio_policy_service_unit_test/include", + "../../audio_policy/server/include/service", + "../../audio_policy/server/include/service/service", + "../../audio_policy/server/domain/device/include", + "../../audio_policy/server/domain/device/src/a2dp", + "../../audio_policy/server/include", + "../../audio_policy/server/include/service/listener", + "../../audio_engine/manager/include", + "../../audio_service/server/include", + ] + + use_exceptions = true + + cflags = [ + "-Wall", + "-Werror", + "-Wno-macro-redefined", + ] + + cflags_cc = cflags + cflags_cc += [ "-fno-access-control" ] + + external_deps = [ + "ability_base:session_info", + "ability_base:want", + "ability_base:zuri", + "ability_runtime:ability_connect_callback_stub", + "ability_runtime:ability_context_native", + "ability_runtime:app_context", + "ability_runtime:dataobs_manager", + "ability_runtime:extension_manager", + "access_token:libaccesstoken_sdk", + "access_token:libnativetoken_shared", + "access_token:libprivacy_sdk", + "access_token:libtokenid_sdk", + "access_token:libtokensetproc_shared", + "bounds_checking_function:libsec_shared", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "data_share:datashare_common", + "data_share:datashare_consumer", + "drivers_interface_audio:libaudio_proxy_5.0", + "eventhandler:libeventhandler", + "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", + "hdf_core:libhdi", + "hdf_core:libpub_utils", + "hilog:libhilog", + "hisysevent:libhisysevent", + "init:libbegetutil", + "ipc:ipc_single", + "kv_store:distributeddata_inner", + "media_foundation:media_monitor_client", + "media_foundation:media_monitor_common", + "os_account:os_account_innerkits", + "power_manager:power_setting", + "power_manager:powermgr_client", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] + + public_external_deps = [ "ffrt:libffrt" ] + + public_external_deps += [ + "libxml2:libxml2", + "openssl:libcrypto_shared", + ] + + sources = [ + "./unittest/audio_policy_service_unit_test/src/audio_policy_service_extended_unit_test.cpp", + "./unittest/audio_policy_service_unit_test/src/get_server_util.cpp", + ] + + configs = [ "../../../services/audio_policy:audio_policy_public_config" ] + + deps = [ + "${audio_framework_root}/services/audio_service/idl:audio_framework_interface", + "../../../frameworks/native/hdiadapter_new:hdiadapter_new", + "../../../services/audio_engine:audio_engine_manager", + "../../../services/audio_policy:audio_policy_client", + "../../audio_policy:audio_policy_service_static", + "../../audio_service:audio_client", + ] + + if (accessibility_enable == true) { + external_deps += [ + "accessibility:accessibility_common", + "accessibility:accessibilityconfig", + ] + } + + defines = [] + + if (build_variant == "user") { + defines += [ "AUDIO_BUILD_VARIANT_USER" ] + } else if (build_variant == "root") { + defines += [ "AUDIO_BUILD_VARIANT_ROOT" ] + } + + if (use_libfuzzer || use_clang_coverage) { + defines += [ "TEST_COVERAGE" ] + } + + if (audio_framework_feature_support_os_account) { + defines += [ "SUPPORT_USER_ACCOUNT" ] + } + + if (audio_framework_feature_dtmf_tone) { + defines += [ "FEATURE_DTMF_TONE" ] + } + + if (audio_framework_feature_usb_audio) { + defines += [ "USB_ENABLE" ] + external_deps += [ "usb_manager:usbsrv_client" ] + } + + if (audio_framework_config_policy_enable) { + defines += [ "USE_CONFIG_POLICY" ] + external_deps += [ "config_policy:configpolicy_util" ] + } + + if (appgallery_part_enable == true) { + defines += [ "FEATURE_APPGALLERY" ] + } + + if (bluetooth_part_enable == true) { + deps += + [ "../../../frameworks/native/bluetoothclient:audio_bluetooth_client" ] + external_deps += [ "bluetooth:btframework" ] + } + + if (audio_framework_feature_wired_audio) { + defines += [ "AUDIO_WIRED_DETECT" ] + } + + if (audio_framework_feature_inner_capturer) { + defines += [ "HAS_FEATURE_INNERCAPTURER" ] + } + + if (audio_framework_feature_offline_effect) { + defines += [ "FEATURE_OFFLINE_EFFECT" ] + } + + if (audio_framework_feature_distributed_audio) { + defines += [ "FEATURE_DISTRIBUTE_AUDIO" ] + } + + if (audio_framework_feature_file_io == true) { + defines += [ "FEATURE_FILE_IO" ] + } + + if (audio_framework_feature_low_latency) { + defines += [ "SUPPORT_LOW_LATENCY" ] + } + + if (avsession_part_enable == true) { + external_deps += [ + "ability_base:want", + "ability_runtime:wantagent_innerkits", + "av_session:avsession_client", + "input:libmmi-client", + ] + } + + if (audio_framework_feature_input) { + defines += [ "FEATURE_MULTIMODALINPUT_INPUT" ] + external_deps += [ "input:libmmi-client" ] + } + + if (audio_framework_feature_device_manager) { + defines += [ "FEATURE_DEVICE_MANAGER" ] + external_deps += [ "device_manager:devicemanagersdk" ] + } + + if (accessibility_enable == true) { + cflags += [ "-DACCESSIBILITY_ENABLE" ] + } + + if (bluetooth_part_enable == true) { + cflags += [ "-DBLUETOOTH_ENABLE" ] + } + + if (avsession_part_enable == true) { + cflags += [ "-DAVSESSION_ENABLE" ] + } +} + ohos_unittest("audio_microphone_descriptor_unit_test") { module_out_path = module_output_path1 include_dirs = [ @@ -4114,6 +4309,55 @@ ohos_unittest("audio_volume_manager_unit_test") { defines = [ "BLUETOOTH_ENABLE" ] } +ohos_unittest("audio_volume_manager_ext_unit_test") { + module_out_path = module_output_path + + include_dirs = [ + "../../audio_policy/server/include/service/service", + "../../audio_policy/server/domain/device/include", + "./unittest/audio_volume_manager_unit_test/include", + ] + + use_exceptions = true + + cflags = [ + "-Wall", + "-Werror", + "-Wno-macro-redefined", + "-fno-access-control", + ] + + external_deps = [ + "bluetooth:btframework", + "c_utils:utils", + "common_event_service:cesfwk_innerkits", + "data_share:datashare_common", + "data_share:datashare_consumer", + "googletest:gmock", + "hilog:libhilog", + "hisysevent:libhisysevent", + "init:libbegetutil", + "ipc:ipc_single", + "kv_store:distributeddata_inner", + "os_account:os_account_innerkits", + "power_manager:power_setting", + "power_manager:powermgr_client", + "eventhandler:libeventhandler", + ] + + sources = [ + "./unittest/audio_volume_manager_unit_test/src/audio_volume_manager_ext_unit_test.cpp", + ] + + deps = [ + "${audio_framework_root}/services/audio_service/idl:audio_framework_interface", + "../../audio_policy:audio_policy_service_static", + ] + + defines = [ "BLUETOOTH_ENABLE" ] +} + + ohos_unittest("audio_adapter_manager_unit_test") { module_out_path = module_output_path include_dirs = [ @@ -4192,6 +4436,84 @@ ohos_unittest("audio_adapter_manager_unit_test") { ] } +ohos_unittest("audio_adapter_manager_ext_unit_test") { + module_out_path = module_output_path + include_dirs = [ + "../server/include", + "./unittest/audio_adapter_manager_unit_test/include", + "../../../services/audio_policy/server/infra/datashare/include", + "../../../frameworks/native/audiodefinitions/include", + "../../../services/audio_policy/server/domain/interrupt/include", + ] + + use_exceptions = true + + cflags = [ + "-Wall", + "-Werror", + "-Wno-macro-redefined", + "-fno-access-control", + ] + + sources = [ "./unittest/audio_adapter_manager_unit_test/src/audio_adapter_manager_ext_unit_test.cpp" ] + + deps = [ + "../../../frameworks/native/audiodefinitions:audio_definitions", + "../../../frameworks/native/audioeffect:audio_effect", + "../../../frameworks/native/audioschedule:audio_schedule", + "../../../frameworks/native/audioutils:audio_utils", + "../../../services/audio_policy:audio_policy_client", + "../../../services/audio_policy:audio_policy_service_static", + "../../../services/audio_service:audio_client", + "../../../services/audio_service:audio_common", + "../../../services/audio_service:audio_process_service", + "../../../services/audio_service:audio_service", + ] + + external_deps = [ + "ability_base:session_info", + "ability_base:want", + "ability_base:zuri", + "ability_runtime:ability_connect_callback_stub", + "ability_runtime:ability_context_native", + "ability_runtime:app_context", + "ability_runtime:dataobs_manager", + "ability_runtime:extension_manager", + "ability_runtime:wantagent_innerkits", + "access_token:libaccesstoken_sdk", + "access_token:libprivacy_sdk", + "access_token:libtokenid_sdk", + "access_token:libtokensetproc_shared", + "background_task_mgr:bgtaskmgr_innerkits", + "bluetooth:btframework", + "bounds_checking_function:libsec_shared", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "data_share:datashare_common", + "data_share:datashare_consumer", + "drivers_interface_audio:libaudio_proxy_5.0", + "eventhandler:libeventhandler", + "googletest:gmock", + "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", + "hdf_core:libhdi", + "hdf_core:libpub_utils", + "hilog:libhilog", + "hisysevent:libhisysevent", + "init:libbegetutil", + "ipc:ipc_single", + "media_foundation:media_monitor_client", + "media_foundation:media_monitor_common", + "os_account:os_account_innerkits", + "power_manager:power_setting", + "power_manager:powermgr_client", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] +} + ohos_unittest("audio_pipe_selector_unit_test") { module_out_path = module_output_path include_dirs = [ @@ -6184,6 +6506,109 @@ ohos_unittest("user_select_router_unit_test") { external_deps += [ "device_manager:devicemanagersdk" ] } + if (audio_framework_feature_usb_audio) { + defines += [ "USB_ENABLE" ] + external_deps += [ "usb_manager:usbsrv_client" ] + } +} + +ohos_unittest("user_select_router_ext_unit_test") { + module_out_path = module_output_path + include_dirs = [ + "./unittest/user_select_router_unit_test/include", + "../../audio_policy/server/domain/router", + ] + + use_exceptions = true + + cflags = [ + "-Wall", + "-Werror", + "-Wno-macro-redefined", + ] + + cflags_cc = cflags + cflags_cc += [ "-fno-access-control" ] + + external_deps = [ + "ability_base:want", + "ability_runtime:app_manager", + "ability_runtime:wantagent_innerkits", + "access_token:libaccesstoken_sdk", + "access_token:libprivacy_sdk", + "access_token:libtokenid_sdk", + "access_token:libtokensetproc_shared", + "background_task_mgr:bgtaskmgr_innerkits", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "data_share:datashare_common", + "data_share:datashare_consumer", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdi", + "hdf_core:libpub_utils", + "hilog:libhilog", + "ipc:ipc_single", + "kv_store:distributeddata_inner", + "media_foundation:media_monitor_client", + "media_foundation:media_monitor_common", + "os_account:os_account_innerkits", + "power_manager:powermgr_client", + "pulseaudio:pulse", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] + + sources = [ "./unittest/user_select_router_unit_test/src/user_select_router_ext_unit_test.cpp" ] + + deps = [ + "../../../frameworks/native/bluetoothclient:audio_bluetooth_client", + "../../audio_policy:audio_policy_client", + "../../audio_policy:audio_policy_service_static", + "../../audio_service:audio_client", + "../../audio_service:audio_common", + ] + + if (accessibility_enable == true) { + external_deps += [ + "accessibility:accessibility_common", + "accessibility:accessibilityconfig", + ] + } + + defines = [] + if (audio_framework_feature_dtmf_tone) { + defines += [ "FEATURE_DTMF_TONE" ] + } + + if (audio_framework_feature_support_os_account) { + defines += [ "SUPPORT_USER_ACCOUNT" ] + } + + if (build_variant == "user") { + defines += [ "AUDIO_BUILD_VARIANT_USER" ] + } else if (build_variant == "root") { + defines += [ "AUDIO_BUILD_VARIANT_ROOT" ] + } + + if (appgallery_part_enable == true) { + defines += [ "FEATURE_APPGALLERY" ] + } + + if (bluetooth_part_enable == true) { + external_deps += [ "bluetooth:btframework" ] + } + + if (audio_framework_feature_input) { + defines += [ "FEATURE_MULTIMODALINPUT_INPUT" ] + external_deps += [ "input:libmmi-client" ] + } + + if (audio_framework_feature_device_manager) { + defines += [ "FEATURE_DEVICE_MANAGER" ] + external_deps += [ "device_manager:devicemanagersdk" ] + } + if (audio_framework_feature_usb_audio) { defines += [ "USB_ENABLE" ] external_deps += [ "usb_manager:usbsrv_client" ] diff --git a/services/audio_policy/test/unittest/audio_adapter_manager_unit_test/include/audio_adapter_manager_ext_unit_test.h b/services/audio_policy/test/unittest/audio_adapter_manager_unit_test/include/audio_adapter_manager_ext_unit_test.h new file mode 100644 index 0000000000..7f405c1b92 --- /dev/null +++ b/services/audio_policy/test/unittest/audio_adapter_manager_unit_test/include/audio_adapter_manager_ext_unit_test.h @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AUDIO_ADAPTER_MANAGER_EXT_UNIT_TEST_H +#define AUDIO_ADAPTER_MANAGER_EXT_UNIT_TEST_H + +#include "gtest/gtest.h" +#include "audio_adapter_manager.h" +#include "audio_interrupt_service.h" +#include "audio_policy_server_handler.h" +#include "audio_zone_service.h" +#include "audio_volume.h" + +namespace OHOS { +namespace AudioStandard { + +class AudioAdapterManagerExtUnitTest : public testing::Test { +public: + // SetUpTestCase: Called before all test cases + static void SetUpTestCase(void); + // TearDownTestCase: Called after all test case + static void TearDownTestCase(void); + + void SetUp() override + { + std::shared_ptr handler = std::make_shared(); + std::shared_ptr interruptService = std::make_shared(); + AudioZoneService::GetInstance().Init(handler, interruptService); + AudioZoneContext context; + zoneId1_ = AudioZoneService::GetInstance().CreateAudioZone("TestZone1", context, 0); + zoneId2_ = AudioZoneService::GetInstance().CreateAudioZone("TestZone2", context, 0); + } + + void TearDown() override + { + zoneId1_ = 0; + zoneId2_ = 0; + AudioZoneService::GetInstance().DeInit(); + } + + int32_t zoneId1_ = 0; + int32_t zoneId2_ = 0; +}; +} // namespace AudioStandard +} // namespace OHOS +#endif //AUDIO_ADAPTER_MANAGER_EXT_UNIT_TEST_H \ No newline at end of file diff --git a/services/audio_policy/test/unittest/audio_adapter_manager_unit_test/src/audio_adapter_manager_ext_unit_test.cpp b/services/audio_policy/test/unittest/audio_adapter_manager_unit_test/src/audio_adapter_manager_ext_unit_test.cpp new file mode 100644 index 0000000000..207d2778a1 --- /dev/null +++ b/services/audio_policy/test/unittest/audio_adapter_manager_unit_test/src/audio_adapter_manager_ext_unit_test.cpp @@ -0,0 +1,460 @@ +/* +* Copyright (c) 2025 Huawei Device Co., Ltd. +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +#include "audio_policy_utils.h" +#include "audio_adapter_manager_ext_unit_test.h" +#include "audio_stream_descriptor.h" +#include "audio_interrupt_service.h" +#include "audio_adapter_manager_handler.h" + +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { + +static AudioAdapterManager *audioAdapterManager_; + +void AudioAdapterManagerExtUnitTest::SetUpTestCase(void) {} +void AudioAdapterManagerExtUnitTest::TearDownTestCase(void) {} + +std::shared_ptr GetInterruptServiceTest() +{ + return std::make_shared(); +} + +/** + * @tc.name: SetAudioVolume_001 + * @tc.desc: Test SetAudioVolume + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetAudioVolume_001, TestSize.Level4) +{ + auto adapterManager = std::make_shared(); + adapterManager->currentActiveDevice_.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP; + adapterManager->isAbsVolumeScene_ = true; + VolumeUtils::isPCVolumeEnable_ = true; + float temp = 1.0f; + EXPECT_NO_THROW( + adapterManager->SetAudioVolume(STREAM_MUSIC, temp); + ); +} + +/** + * @tc.name: SetAudioVolume_002 + * @tc.desc: Test SetAudioVolume + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetAudioVolume_002, TestSize.Level4) +{ + auto adapterManager = std::make_shared(); + adapterManager->currentActiveDevice_.deviceType_ = DEVICE_TYPE_SPEAKER; + adapterManager->currentActiveDevice_.networkId_ = ""; + float temp = 1.0f; + VolumeUtils::isPCVolumeEnable_ = true; + EXPECT_NO_THROW( + adapterManager->SetAudioVolume(STREAM_MUSIC, temp); + ); +} + +/** + * @tc.name: SetAudioVolume_003 + * @tc.desc: Test SetAudioVolume + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetAudioVolume_003, TestSize.Level4) +{ + auto adapterManager = std::make_shared(); + adapterManager->currentActiveDevice_.deviceType_ = DEVICE_TYPE_NEARLINK; + float temp = 1.0f; + VolumeUtils::isPCVolumeEnable_ = true; + adapterManager->isSleVoiceStatus_ = false; + EXPECT_NO_THROW( + adapterManager->SetAudioVolume(STREAM_MUSIC, temp); + ); +} + +/** + * @tc.name: SetAudioVolume_004 + * @tc.desc: Test SetAudioVolume + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetAudioVolume_004, TestSize.Level4) +{ + auto adapterManager = std::make_shared(); + adapterManager->currentActiveDevice_.deviceType_ = DEVICE_TYPE_NEARLINK; + float temp = 1.0f; + VolumeUtils::isPCVolumeEnable_ = false; + EXPECT_NO_THROW( + adapterManager->SetAudioVolume(STREAM_VOICE_COMMUNICATION, temp); + ); +} + +/** + * @tc.name: SetAudioVolumeThree_001 + * @tc.desc: Test SetAudioVolume + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetAudioVolumeThree_001, TestSize.Level4) +{ + auto audioAdapterManager = std::make_shared(); + EXPECT_NE(audioAdapterManager, nullptr); + std::shared_ptr desc = + std::make_shared(DEVICE_TYPE_SPEAKER, OUTPUT_DEVICE); + desc->networkId_ = ""; + AudioStreamType streamType = STREAM_MUSIC; + float volumeDb = 0.0f; + audioAdapterManager->volumeDataExtMaintainer_[desc->GetKey()] = std::make_shared(); + EXPECT_NO_THROW( + audioAdapterManager->SetAudioVolume(desc, streamType, volumeDb); + ); +} + +/** + * @tc.name: SetAudioVolumeThree_002 + * @tc.desc: Test SetAudioVolume + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetAudioVolumeThree_002, TestSize.Level4) +{ + auto audioAdapterManager = std::make_shared(); + EXPECT_NE(audioAdapterManager, nullptr); + std::shared_ptr desc = + std::make_shared(DEVICE_TYPE_SPEAKER, OUTPUT_DEVICE); + AudioStreamType streamType = STREAM_MUSIC; + desc->networkId_ = "LocalDevice"; + float volumeDb = 0.0f; + audioAdapterManager->volumeDataExtMaintainer_[desc->GetKey()] = std::make_shared(); + EXPECT_NO_THROW( + audioAdapterManager->SetAudioVolume(desc, streamType, volumeDb); + ); +} + +/** + * @tc.name: SetAudioVolumeThree_003 + * @tc.desc: Test SetAudioVolume + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetAudioVolumeThree_003, TestSize.Level4) +{ + auto audioAdapterManager = std::make_shared(); + EXPECT_NE(audioAdapterManager, nullptr); + std::shared_ptr desc = + std::make_shared(DEVICE_TYPE_NONE, OUTPUT_DEVICE); + AudioStreamType streamType = STREAM_MUSIC; + desc->networkId_ = "LocalDevice"; + float volumeDb = 0.0f; + audioAdapterManager->volumeDataExtMaintainer_[desc->GetKey()] = std::make_shared(); + EXPECT_NO_THROW( + audioAdapterManager->SetAudioVolume(desc, streamType, volumeDb); + ); +} + +/** + * @tc.name: SetOffloadVolume_001 + * @tc.desc: Test SetOffloadVolume + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetOffloadVolume_001, TestSize.Level4) +{ + auto audioAdapterManager = std::make_shared(); + EXPECT_NE(audioAdapterManager, nullptr); + AudioStreamType streamType = STREAM_MUSIC; + float volumeDb = 0.0f; + std::string deviceClass = ""; + std::string networkId = ""; + EXPECT_NO_THROW( + audioAdapterManager->SetOffloadVolume(streamType, volumeDb, deviceClass, networkId); + ); +} + +/** + * @tc.name: SetOffloadVolume_002 + * @tc.desc: Test SetOffloadVolume + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetOffloadVolume_002, TestSize.Level4) +{ + auto audioAdapterManager = std::make_shared(); + EXPECT_NE(audioAdapterManager, nullptr); + AudioStreamType streamType = STREAM_SPEECH; + float volumeDb = 0.0f; + std::string deviceClass = ""; + std::string networkId = ""; + EXPECT_NO_THROW( + audioAdapterManager->SetOffloadVolume(streamType, volumeDb, deviceClass, networkId); + ); +} + +/** + * @tc.name: SetOffloadVolume_003 + * @tc.desc: Test SetOffloadVolume + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetOffloadVolume_003, TestSize.Level4) +{ + auto audioAdapterManager = std::make_shared(); + EXPECT_NE(audioAdapterManager, nullptr); + AudioStreamType streamType = STREAM_RING; + float volumeDb = 0.0f; + std::string deviceClass = ""; + std::string networkId = ""; + uint32_t sessionId = MIN_STREAMID + 1; + audioAdapterManager->SetOffloadSessionId(sessionId); + EXPECT_NO_THROW( + audioAdapterManager->SetOffloadVolume(streamType, volumeDb, deviceClass, networkId); + ); +} + +/** + * @tc.name: SetOffloadVolume_004 + * @tc.desc: Test SetOffloadVolume + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetOffloadVolume_004, TestSize.Level4) +{ + auto audioAdapterManager = std::make_shared(); + EXPECT_NE(audioAdapterManager, nullptr); + AudioStreamType streamType = STREAM_RING; + float volumeDb = 0.0f; + std::string deviceClass = ""; + std::string networkId = ""; + uint32_t sessionId = 1; + audioAdapterManager->SetOffloadSessionId(sessionId); + EXPECT_NO_THROW( + audioAdapterManager->SetOffloadVolume(streamType, volumeDb, deviceClass, networkId); + ); +} + +/** + * @tc.name: SetDoubleRingVolumeDb_002 + * @tc.desc: Test SetDoubleRingVolumeDb + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetDoubleRingVolumeDb_002, TestSize.Level1) +{ + auto audioAdapterManager = std::make_shared(); + EXPECT_NE(audioAdapterManager, nullptr); + audioAdapterManager->Init(); + + uint32_t sessionId = MIN_STREAMID + 1; + audioAdapterManager->SetOffloadSessionId(sessionId); + audioAdapterManager->ResetOffloadSessionId(); + audioAdapterManager->currentActiveDevice_.deviceType_ = DEVICE_TYPE_SPEAKER; + AudioStreamType streamType = STREAM_RING; + int32_t volumeLevel = 5; + audioAdapterManager->useNonlinearAlgo_ = true; + int32_t result = audioAdapterManager->SetDoubleRingVolumeDb(streamType, volumeLevel); + EXPECT_EQ(result, SUCCESS); +} + +/** + * @tc.name: SetStreamMuteInternal_001 + * @tc.desc: Test SetStreamMuteInternal + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetStreamMuteInternal_001, TestSize.Level1) +{ + auto audioAdapterManager = std::make_shared(); + EXPECT_NE(audioAdapterManager, nullptr); + std::shared_ptr desc = + std::make_shared(DEVICE_TYPE_NONE, OUTPUT_DEVICE); + audioAdapterManager->volumeDataExtMaintainer_[desc->GetKey()] = std::make_shared(); + int32_t res = audioAdapterManager->SetRingerModeInternal(RINGER_MODE_VIBRATE); + EXPECT_EQ(res, SUCCESS); + bool mute = true; + AudioStreamType streamType = STREAM_RING; + StreamUsage streamUsage = STREAM_USAGE_ALARM; + DeviceType deviceType = DEVICE_TYPE_WIRED_HEADSET; + int32_t ret = audioAdapterManager->SetStreamMuteInternal(desc, streamType, mute, streamUsage, deviceType); + EXPECT_EQ(ret, SUCCESS); +} + +/** + * @tc.name: SetStreamMuteInternal_002 + * @tc.desc: Test SetStreamMuteInternal + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetStreamMuteInternal_002, TestSize.Level1) +{ + auto audioAdapterManager = std::make_shared(); + EXPECT_NE(audioAdapterManager, nullptr); + std::shared_ptr desc = + std::make_shared(DEVICE_TYPE_NONE, OUTPUT_DEVICE); + audioAdapterManager->volumeDataExtMaintainer_[desc->GetKey()] = std::make_shared(); + int32_t res = audioAdapterManager->SetRingerModeInternal(RINGER_MODE_VIBRATE); + EXPECT_EQ(res, SUCCESS); + bool mute = false; + AudioStreamType streamType = STREAM_RING; + StreamUsage streamUsage = STREAM_USAGE_ALARM; + DeviceType deviceType = DEVICE_TYPE_WIRED_HEADSET; + int32_t ret = audioAdapterManager->SetStreamMuteInternal(desc, streamType, mute, streamUsage, deviceType); + EXPECT_NE(ret, SUCCESS); +} + +/** + * @tc.name: SetStreamMuteInternal_003 + * @tc.desc: Test SetStreamMuteInternal + * @tc.type: FUNC + * @tc.require: #I5Y4MZ + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetStreamMuteInternal_003, TestSize.Level1) +{ + auto audioAdapterManager = std::make_shared(); + EXPECT_NE(audioAdapterManager, nullptr); + audioAdapterManager->Init(); + std::shared_ptr desc = + std::make_shared(DEVICE_TYPE_NONE, OUTPUT_DEVICE); + audioAdapterManager->volumeDataExtMaintainer_[desc->GetKey()] = std::make_shared(); + int32_t res = audioAdapterManager->SetRingerModeInternal(RINGER_MODE_VIBRATE); + EXPECT_EQ(res, SUCCESS); + bool mute = false; + AudioStreamType streamType = STREAM_RING; + StreamUsage streamUsage = STREAM_USAGE_ALARM; + DeviceType deviceType = DEVICE_TYPE_WIRED_HEADSET; + int32_t ret = audioAdapterManager->SetStreamMuteInternal(desc, streamType, mute, streamUsage, deviceType); + EXPECT_NE(ret, SUCCESS); +} + +/** + * @tc.name: SetStreamMuteInternal_004 + * @tc.desc: Test SetStreamMuteInternal + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetStreamMuteInternal_004, TestSize.Level4) +{ + auto adapterManager = std::make_shared(); + adapterManager->currentActiveDevice_.volumeBehavior_.databaseVolumeName = "databaseVolumeName"; + VolumeUtils::isPCVolumeEnable_ = true; + adapterManager->currentActiveDevice_.volumeBehavior_.isVolumeControlDisabled = false; + EXPECT_NO_THROW( + adapterManager->SetStreamMuteInternal(STREAM_MUSIC, false, STREAM_USAGE_MEDIA, DEVICE_TYPE_NONE, ""); + ); +} + +/** + * @tc.name: SetAppRingMuted_001 + * @tc.desc: Test SetAppRingMuted + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetAppRingMuted_001, TestSize.Level4) +{ + StreamVolumeParams volumeParams; + volumeParams.streamType = STREAM_RING; + volumeParams.uid = 42; + AudioVolume::GetInstance()->AddStreamVolume(volumeParams); + + ASSERT_EQ(AudioAdapterManager::GetInstance().SetAppRingMuted(42, true), SUCCESS); + ASSERT_EQ(AudioAdapterManager::GetInstance().SetAppRingMuted(42, false), SUCCESS); +} + +/** + * @tc.name: IsAppRingMuted_001 + * @tc.desc: Test IsAppRingMuted + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, IsAppRingMuted_001, TestSize.Level4) +{ + StreamVolumeParams volumeParams; + volumeParams.streamType = STREAM_RING; + volumeParams.uid = 42; + AudioVolume::GetInstance()->AddStreamVolume(volumeParams); + + auto &adapterManager = AudioAdapterManager::GetInstance(); + std::vector> devices; + std::shared_ptr desc = + std::make_shared(DEVICE_TYPE_REMOTE_CAST, OUTPUT_DEVICE); + desc->networkId_ = "NotLocalDevice"; + desc->deviceType_ = DEVICE_TYPE_SPEAKER; + devices.push_back(desc); + AudioZoneService::GetInstance().BindDeviceToAudioZone(zoneId1_, devices); + + ASSERT_EQ(AudioAdapterManager::GetInstance().SetAppRingMuted(42, true), SUCCESS); + ASSERT_EQ(AudioAdapterManager::GetInstance().IsAppRingMuted(42), true); + ASSERT_EQ(AudioAdapterManager::GetInstance().IsAppRingMuted(43), false); + ASSERT_EQ(AudioAdapterManager::GetInstance().SetAppRingMuted(42, false), SUCCESS); + ASSERT_EQ(AudioAdapterManager::GetInstance().IsAppRingMuted(42), false); + ASSERT_EQ(AudioAdapterManager::GetInstance().IsAppRingMuted(43), false); +} + +/** + * @tc.name: GetVolumeAdjustZoneId_001 + * @tc.desc: Test GetVolumeAdjustZoneId + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, GetVolumeAdjustZoneId_001, TestSize.Level4) +{ + StreamVolumeParams volumeParams; + volumeParams.streamType = STREAM_RING; + volumeParams.uid = 42; + AudioVolume::GetInstance()->AddStreamVolume(volumeParams); + + auto &adapterManager = AudioAdapterManager::GetInstance(); + std::vector> devices; + std::shared_ptr desc = + std::make_shared(DEVICE_TYPE_REMOTE_CAST, OUTPUT_DEVICE); + desc->networkId_ = "LocalDevice"; + devices.push_back(desc); + AudioZoneService::GetInstance().BindDeviceToAudioZone(zoneId1_, devices); + AudioConnectedDevice::GetInstance().AddConnectedDevice(desc); + AudioZoneService::GetInstance().UpdateDeviceFromGlobalForAllZone(desc); + ASSERT_EQ(adapterManager.GetVolumeAdjustZoneId(), 0); + ASSERT_EQ(adapterManager.SetAdjustVolumeForZone(zoneId1_), SUCCESS); + ASSERT_EQ(adapterManager.GetVolumeAdjustZoneId(), zoneId1_); +} + +/** + * @tc.name: SetAdjustVolumeForZone_002 + * @tc.desc: Test SetAdjustVolumeForZone + * @tc.type: FUNC + * @tc.require: #ICDC94 + */ +HWTEST_F(AudioAdapterManagerExtUnitTest, SetAdjustVolumeForZone_002, TestSize.Level4) +{ + StreamVolumeParams volumeParams; + volumeParams.streamType = STREAM_RING; + volumeParams.uid = 42; + AudioVolume::GetInstance()->AddStreamVolume(volumeParams); + + auto &adapterManager = AudioAdapterManager::GetInstance(); + std::vector> devices; + std::shared_ptr desc = + std::make_shared(DEVICE_TYPE_REMOTE_CAST, OUTPUT_DEVICE); + desc->networkId_ = "LocalDevice"; + devices.push_back(desc); + AudioZoneService::GetInstance().BindDeviceToAudioZone(zoneId1_, devices); + AudioConnectedDevice::GetInstance().AddConnectedDevice(desc); + AudioZoneService::GetInstance().UpdateDeviceFromGlobalForAllZone(desc); + ASSERT_EQ(adapterManager.SetAdjustVolumeForZone(zoneId1_), SUCCESS); + ASSERT_EQ(adapterManager.GetVolumeAdjustZoneId(), zoneId1_); +} +} // namespace AudioStandard +} // namespace OHOS diff --git a/services/audio_policy/test/unittest/audio_ec_manager_unit_test/src/audio_ec_manager_unit_test.cpp b/services/audio_policy/test/unittest/audio_ec_manager_unit_test/src/audio_ec_manager_unit_test.cpp index 2990179407..d40c2e83f2 100644 --- a/services/audio_policy/test/unittest/audio_ec_manager_unit_test/src/audio_ec_manager_unit_test.cpp +++ b/services/audio_policy/test/unittest/audio_ec_manager_unit_test/src/audio_ec_manager_unit_test.cpp @@ -646,5 +646,208 @@ HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_027, TestSize.Level4) ecManager.GetTargetSourceTypeAndMatchingFlag(source, targetSource, useMatchingPropInfo); EXPECT_EQ(targetSource, SOURCE_TYPE_LIVE); } + +/** +* @tc.name : Test AudioEcManager. +* @tc.number: AudioEcManager_028 +* @tc.desc : Test UpdateStreamCommonInfo interface. +*/ +HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_028, TestSize.Level4) +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + bool originIsEcFeatureEnable = ecManager.isEcFeatureEnable_; + ecManager.isEcFeatureEnable_ = false; + AudioModuleInfo moduleInfo = {}; + PipeStreamPropInfo targetInfo = PipeStreamPropInfo(); + SourceType sourceType = SourceType::SOURCE_TYPE_MIC; + ecManager.UpdateStreamCommonInfo(moduleInfo, targetInfo, sourceType); + EXPECT_EQ(moduleInfo.sourceType, "0"); + + ecManager.isEcFeatureEnable_ = true; + ecManager.UpdateStreamCommonInfo(moduleInfo, targetInfo, sourceType); + EXPECT_EQ(moduleInfo.sourceType, "0"); + + ecManager.isEcFeatureEnable_ = originIsEcFeatureEnable; +} + +/** +* @tc.name : Test AudioEcManager. +* @tc.number: AudioEcManager_029 +* @tc.desc : Test UpdateEnhanceEffectState interface. +*/ +HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_029, TestSize.Level4) +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + SourceType sourceType = SourceType::SOURCE_TYPE_MIC; + ecManager.UpdateEnhanceEffectState(sourceType); + EXPECT_EQ(ecManager.isMicRefRecordOn_, false); +} + +/** +* @tc.name : Test AudioEcManager. +* @tc.number: AudioEcManager_030 +* @tc.desc : Test UpdateStreamMicRefInfo interface. +*/ +HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_030, TestSize.Level4) +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + AudioModuleInfo moduleInfo = {}; + SourceType sourceType = SourceType::SOURCE_TYPE_MIC; + EXPECT_NO_THROW( + ecManager.UpdateStreamMicRefInfo(moduleInfo, sourceType); + ); + + sourceType = SourceType::SOURCE_TYPE_VOICE_COMMUNICATION; + EXPECT_NO_THROW( + ecManager.UpdateStreamMicRefInfo(moduleInfo, sourceType); + ); + + sourceType = SOURCE_TYPE_INVALID; + EXPECT_NO_THROW( + ecManager.UpdateStreamMicRefInfo(moduleInfo, sourceType); + ); +} + +/** +* @tc.name : Test AudioEcManager. +* @tc.number: AudioEcManager_031 +* @tc.desc : Test ReloadNormalSource interface. +*/ +HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_031, TestSize.Level4) +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + SessionInfo sessionInfo = {}; + PipeStreamPropInfo targetInfo = PipeStreamPropInfo(); + SourceType targetSource = SourceType::SOURCE_TYPE_MIC; + int32_t ret = ecManager.ReloadNormalSource(sessionInfo, targetInfo, targetSource); + EXPECT_EQ(ret, ERROR); +} + +/** +* @tc.name : Test AudioEcManager. +* @tc.number: AudioEcManager_032 +* @tc.desc : Test GetOpenedNormalSourceSessionId interface. +*/ +HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_032, TestSize.Level4) +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + uint64_t ret = ecManager.GetOpenedNormalSourceSessionId(); + EXPECT_EQ(ret, 0); +} + +/** +* @tc.name : Test AudioEcManager. +* @tc.number: AudioEcManager_033 +* @tc.desc : Test SetOpenedNormalSourceSessionId interface. +*/ +HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_033, TestSize.Level4) +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + uint64_t originSessionId = ecManager.sessionIdUsedToOpenSource_; + uint64_t sessionId = 11; + ecManager.SetOpenedNormalSourceSessionId(sessionId); + EXPECT_EQ(ecManager.sessionIdUsedToOpenSource_, sessionId); + + ecManager.sessionIdUsedToOpenSource_ = originSessionId; +} + +/** +* @tc.name : Test AudioEcManager. +* @tc.number: AudioEcManager_034 +* @tc.desc : Test PrepareNormalSource interface. +*/ +HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_034, TestSize.Level4) +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + AudioModuleInfo moduleInfo = {}; + std::shared_ptr streamDesc = std::make_shared(); + EXPECT_NO_THROW( + ecManager.PrepareNormalSource(moduleInfo, streamDesc); + ); +} + +/** +* @tc.name : Test AudioEcManager. +* @tc.number: AudioEcManager_035 +* @tc.desc : Test SetOpenedNormalSource interface. +*/ +HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_035, TestSize.Level4) +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + SourceType origin = ecManager.normalSourceOpened_; + SourceType sourceType = SourceType::SOURCE_TYPE_MIC; + ecManager.SetOpenedNormalSource(sourceType); + EXPECT_EQ(sourceType, ecManager.normalSourceOpened_); + + ecManager.normalSourceOpened_ = origin; +} + +/** +* @tc.name : Test AudioEcManager. +* @tc.number: AudioEcManager_036 +* @tc.desc : Test SetPrimaryMicModuleInfo interface. +*/ +HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_036, TestSize.Level4) +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + AudioModuleInfo moduleInfo = {}; + moduleInfo.name = "test"; + ecManager.SetPrimaryMicModuleInfo(moduleInfo); + EXPECT_EQ(ecManager.primaryMicModuleInfo_.name, moduleInfo.name); +} + +/** +* @tc.name : Test AudioEcManager. +* @tc.number: AudioEcManager_037 +* @tc.desc : Test SetDpSinkModuleInfo interface. +*/ +HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_037, TestSize.Level4) +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + AudioModuleInfo moduleInfo = {}; + moduleInfo.className = "AudioEcManagerUnitTest"; + ecManager.SetDpSinkModuleInfo(moduleInfo); + EXPECT_EQ(ecManager.dpSinkModuleInfo_.className, moduleInfo.className); +} + +/** +* @tc.name : Test AudioEcManager. +* @tc.number: AudioEcManager_038 +* @tc.desc : Test FetchTargetInfoForSessionAdd interface. +*/ +HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_038, TestSize.Level4) +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + SessionInfo sessionInfo = {}; + PipeStreamPropInfo targetInfo = PipeStreamPropInfo(); + SourceType targetSourceType = SourceType::SOURCE_TYPE_MIC; + int32_t ret = ecManager.FetchTargetInfoForSessionAdd(sessionInfo, targetInfo, targetSourceType); + EXPECT_EQ(ret, ERROR); +} + +/** +* @tc.name : Test AudioEcManager. +* @tc.number: AudioEcManager_039 +* @tc.desc : Test FetchTargetInfoForSessionAdd interface. +*/ +HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_039, TestSize.Level4) +{ + AudioEcManager& ecManager(AudioEcManager::GetInstance()); + SessionInfo sessionInfo = {}; + PipeStreamPropInfo targetInfo = PipeStreamPropInfo(); + SourceType targetSourceType = SourceType::SOURCE_TYPE_MIC; + bool originEcFeatureEnable_ = ecManager.isEcFeatureEnable_; + std::string originMicSpeaker = ecManager.primaryMicModuleInfo_.OpenMicSpeaker; + + ecManager.isEcFeatureEnable_ = false; + ecManager.primaryMicModuleInfo_.OpenMicSpeaker = "0"; + int32_t ret = ecManager.FetchTargetInfoForSessionAdd(sessionInfo, targetInfo, targetSourceType); + EXPECT_EQ(ret, ERROR); + + ecManager.isEcFeatureEnable_ = true; + ecManager.primaryMicModuleInfo_.OpenMicSpeaker = "1"; + ret = ecManager.FetchTargetInfoForSessionAdd(sessionInfo, targetInfo, targetSourceType); + EXPECT_EQ(ret, ERROR); +} } // namespace AudioStandard } // namespace OHOS \ No newline at end of file diff --git a/services/audio_policy/test/unittest/audio_policy_service_unit_test/include/audio_policy_service_extended_unit_test.h b/services/audio_policy/test/unittest/audio_policy_service_unit_test/include/audio_policy_service_extended_unit_test.h new file mode 100644 index 0000000000..673ff01fea --- /dev/null +++ b/services/audio_policy/test/unittest/audio_policy_service_unit_test/include/audio_policy_service_extended_unit_test.h @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AUDIO_POLICY_SERVICE_EXTENDED_UNIT_TEST_H +#define AUDIO_POLICY_SERVICE_EXTENDED_UNIT_TEST_H + +#include + +#include "audio_policy_service.h" +#include "audio_policy_server.h" +#include "audio_policy_utils.h" +#include "audio_info.h" +#include "message_parcel.h" +#include "nativetoken_kit.h" +#include "token_setproc.h" + +namespace OHOS { +namespace AudioStandard { + +class AudioPolicyServiceExtendedUnitTest : public testing::Test { +public: + // SetUpTestCase: Called before all test cases + static void SetUpTestCase(void); + // TearDownTestCase: Called after all test case + static void TearDownTestCase(void); + // SetUp: Called before each test cases + void SetUp(void); + // TearDown: Called after each test cases + void TearDown(void); +}; + +class RemoteObjectTestStub : public IRemoteObject { +public: + RemoteObjectTestStub() : IRemoteObject(u"IRemoteObject") {} + int32_t GetObjectRefCount() { return 0; }; + int SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) { return 0; }; + bool AddDeathRecipient(const sptr &recipient) { return true; }; + bool RemoveDeathRecipient(const sptr &recipient) { return true; }; + int Dump(int fd, const std::vector &args) { return 0; }; + + DECLARE_INTERFACE_DESCRIPTOR(u"RemoteObjectTestStub"); +}; +} // namespace AudioStandard +} // namespace OHOS +#endif // AUDIO_POLICY_SERVICE_EXTENDED_UNIT_TEST_H \ No newline at end of file diff --git a/services/audio_policy/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_extended_unit_test.cpp b/services/audio_policy/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_extended_unit_test.cpp new file mode 100644 index 0000000000..269f4d6cb7 --- /dev/null +++ b/services/audio_policy/test/unittest/audio_policy_service_unit_test/src/audio_policy_service_extended_unit_test.cpp @@ -0,0 +1,831 @@ +/* + * Copyright (c) 2024-2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "audio_policy_service_extended_unit_test.h" +#include "get_server_util.h" + +#include +#include +#include +#include "audio_info.h" +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { + +bool g_hasPermission = false; +static const std::string INNER_CAPTURER_SINK_LEGACY = "InnerCapturer"; +const int32_t CONNECTING_NUMBER = 10; +const int32_t TEST_SESSIONID = MIN_STREAMID + 1010; +const int32_t ROUTER_MAP_ID0 = 1000; +const int32_t ROUTER_MAP_ID1 = 1001; +const int32_t ROUTER_MAP_ID2 = 1002; +const int32_t ROUTER_MAP_ID3 = 1003; +const int32_t ROUTER_MAP_ID4 = 1004; +const int32_t ROUTER_MAP_ID5 = 1005; +const int32_t ROUTER_MAP_ID6 = 1006; +const int32_t VALUE_ZERO = 0; +const int32_t DEFAULT_VOLUME_LEVEL = 7; +const int32_t G_UNKNOWN_PID = -1; +const uint32_t CHANNELS = 2; +const uint32_t RATE = 4; + +void AudioPolicyServiceExtendedUnitTest::SetUpTestCase(void) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest::SetUpTestCase start-end"); +} +void AudioPolicyServiceExtendedUnitTest::TearDownTestCase(void) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest::TearDownTestCase start-end"); +} +void AudioPolicyServiceExtendedUnitTest::SetUp(void) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest::SetUp start-end"); +} +void AudioPolicyServiceExtendedUnitTest::TearDown(void) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest::TearDown start-end"); +} + +static AudioPolicyServer* GetServerPtr() +{ + return GetServerUtil::GetServerPtr(); +} + +static void GetPermission() +{ + if (!g_hasPermission) { + uint64_t tokenId; + constexpr int perNum = 10; + const char *perms[perNum] = { + "ohos.permission.MICROPHONE", + "ohos.permission.MANAGE_INTELLIGENT_VOICE", + "ohos.permission.MANAGE_AUDIO_CONFIG", + "ohos.permission.MICROPHONE_CONTROL", + "ohos.permission.MODIFY_AUDIO_SETTINGS", + "ohos.permission.ACCESS_NOTIFICATION_POLICY", + "ohos.permission.USE_BLUETOOTH", + "ohos.permission.CAPTURE_VOICE_DOWNLINK_AUDIO", + "ohos.permission.RECORD_VOICE_CALL", + "ohos.permission.MANAGE_SYSTEM_AUDIO_EFFECTS", + }; + + NativeTokenInfoParams infoInstance = { + .dcapsNum = 0, + .permsNum = 10, + .aclsNum = 0, + .dcaps = nullptr, + .perms = perms, + .acls = nullptr, + .processName = "audio_policy_service_unit_test", + .aplStr = "system_basic", + }; + tokenId = GetAccessTokenId(&infoInstance); + SetSelfTokenID(tokenId); + OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo(); + g_hasPermission = true; + } +} + +static const std::vector deviceTypes = { + DEVICE_TYPE_NONE, + DEVICE_TYPE_INVALID, + DEVICE_TYPE_EARPIECE, + DEVICE_TYPE_SPEAKER, + DEVICE_TYPE_WIRED_HEADSET, + DEVICE_TYPE_WIRED_HEADPHONES, + DEVICE_TYPE_BLUETOOTH_SCO, + DEVICE_TYPE_BLUETOOTH_A2DP, + DEVICE_TYPE_MIC, + DEVICE_TYPE_WAKEUP, + DEVICE_TYPE_USB_HEADSET, + DEVICE_TYPE_DP, + DEVICE_TYPE_REMOTE_CAST, + DEVICE_TYPE_FILE_SINK, + DEVICE_TYPE_FILE_SOURCE, + DEVICE_TYPE_EXTERN_CABLE, + DEVICE_TYPE_DEFAULT, + DEVICE_TYPE_USB_ARM_HEADSET, + DEVICE_TYPE_HDMI +}; + +static const std::vector streamSetStates = { + STREAM_PAUSE, + STREAM_RESUME, + STREAM_MUTE, + STREAM_UNMUTE +}; + +static const std::vectorisConnecteds = { + true, + false +}; +static const std::vectorflags = { + NO_A2DP_DEVICE, + A2DP_NOT_OFFLOAD, + A2DP_OFFLOAD +}; +static const std::vectorpipeTypes = { + PIPE_TYPE_UNKNOWN, + PIPE_TYPE_NORMAL_OUT, + PIPE_TYPE_NORMAL_IN, + PIPE_TYPE_OFFLOAD, + PIPE_TYPE_MULTICHANNEL +}; +static const std::vectorpreferredTypes = { + Media::MediaMonitor::MEDIA_RENDER, + Media::MediaMonitor::CALL_RENDER, + Media::MediaMonitor::RING_RENDER, + Media::MediaMonitor::TONE_RENDER, + Media::MediaMonitor::CALL_CAPTURE, + Media::MediaMonitor::RECORD_CAPTURE +}; +static const std::vectorstreamUsages = { + STREAM_USAGE_INVALID, + STREAM_USAGE_UNKNOWN, + STREAM_USAGE_MEDIA, + STREAM_USAGE_MUSIC, + STREAM_USAGE_VOICE_COMMUNICATION, + STREAM_USAGE_VOICE_ASSISTANT, + STREAM_USAGE_ALARM, + STREAM_USAGE_VOICE_MESSAGE, + STREAM_USAGE_NOTIFICATION_RINGTONE, + STREAM_USAGE_RINGTONE, + STREAM_USAGE_NOTIFICATION, + STREAM_USAGE_SYSTEM, + STREAM_USAGE_MOVIE, + STREAM_USAGE_GAME, + STREAM_USAGE_AUDIOBOOK, + STREAM_USAGE_NAVIGATION, + STREAM_USAGE_DTMF, + STREAM_USAGE_ENFORCED_TONE, + STREAM_USAGE_ULTRASONIC, + STREAM_USAGE_VIDEO_COMMUNICATION, + STREAM_USAGE_RANGING, + STREAM_USAGE_VOICE_MODEM_COMMUNICATION, + STREAM_USAGE_VOICE_RINGTONE, + STREAM_USAGE_VOICE_CALL_ASSISTANT, + STREAM_USAGE_MAX +}; +static const std::vectoraudioStreamTypes = { + STREAM_DEFAULT, + STREAM_VOICE_CALL, + STREAM_MUSIC, + STREAM_RING, + STREAM_MEDIA, + STREAM_VOICE_ASSISTANT, + STREAM_SYSTEM, + STREAM_ALARM, + STREAM_NOTIFICATION, + STREAM_BLUETOOTH_SCO, + STREAM_ENFORCED_AUDIBLE, + STREAM_DTMF, + STREAM_TTS, + STREAM_RECORDING, + STREAM_MOVIE, + STREAM_GAME, + STREAM_SPEECH, + STREAM_SYSTEM_ENFORCED, + STREAM_ULTRASONIC, + STREAM_WAKEUP, + STREAM_VOICE_MESSAGE, + STREAM_NAVIGATION, + STREAM_INTERNAL_FORCE_STOP, + STREAM_SOURCE_VOICE_CALL, + STREAM_VOICE_COMMUNICATION, + STREAM_VOICE_RING, + STREAM_VOICE_CALL_ASSISTANT, + STREAM_TYPE_MAX, + STREAM_ALL +}; +static const std::vectorisMutes = { + true, + false +}; +static const std::vectordeviceRoles = { + DEVICE_ROLE_NONE, + INPUT_DEVICE, + OUTPUT_DEVICE, + DEVICE_ROLE_MAX +}; +static const std::vectordeviceFlags = { + NONE_DEVICES_FLAG, + OUTPUT_DEVICES_FLAG, + INPUT_DEVICES_FLAG, + ALL_DEVICES_FLAG, + DISTRIBUTED_OUTPUT_DEVICES_FLAG, + DISTRIBUTED_INPUT_DEVICES_FLAG, + ALL_DISTRIBUTED_DEVICES_FLAG, + ALL_L_D_DEVICES_FLAG, + DEVICE_FLAG_MAX +}; +static const std::vectoraudioSampleFormats = { + SAMPLE_U8, + SAMPLE_S16LE, + SAMPLE_S24LE, + SAMPLE_S32LE, + SAMPLE_F32LE, + INVALID_WIDTH +}; +static const std::vectoraudioScenes = { + AUDIO_SCENE_INVALID, + AUDIO_SCENE_DEFAULT, + AUDIO_SCENE_RINGING, + AUDIO_SCENE_PHONE_CALL, + AUDIO_SCENE_PHONE_CHAT, + AUDIO_SCENE_CALL_START, + AUDIO_SCENE_CALL_END, + AUDIO_SCENE_VOICE_RINGING, + AUDIO_SCENE_MAX +}; +static const std::vectoraudioRingerModes = { + RINGER_MODE_SILENT, + RINGER_MODE_VIBRATE, + RINGER_MODE_NORMAL +}; +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: CaptureConcurrentCheck +* @tc.desc : Test CaptureConcurrentCheck. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, CaptureConcurrentCheck, TestSize.Level1) +{ + uint32_t sessionId = 0; + int32_t ret = AudioPolicyService::GetAudioPolicyService().CaptureConcurrentCheck(sessionId); + EXPECT_EQ(ret, ERR_NULL_POINTER); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: SetDefaultAdapterEnable +* @tc.desc : Test SetDefaultAdapterEnable. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, SetDefaultAdapterEnable, TestSize.Level1) +{ + bool isEnable = false; + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().SetDefaultAdapterEnable(isEnable); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: UnregisterBluetoothListener +* @tc.desc : Test UnregisterBluetoothListener. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, UnregisterBluetoothListener, TestSize.Level1) +{ +#ifdef BLUETOOTH_ENABLE + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().UnregisterBluetoothListener(); + ); +#endif +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: OnServiceConnected +* @tc.desc : Test OnServiceConnected. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, OnServiceConnected, TestSize.Level1) +{ + AudioServiceIndex serviceIndex = AudioServiceIndex::HDI_SERVICE_INDEX; + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().OnServiceConnected(serviceIndex); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: SetDefaultDeviceLoadFlag +* @tc.desc : Test SetDefaultDeviceLoadFlag. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, SetDefaultDeviceLoadFlag, TestSize.Level1) +{ + bool isLoad = false; + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().SetDefaultDeviceLoadFlag(isLoad); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: RestoreSession +* @tc.desc : Test RestoreSession. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, RestoreSession, TestSize.Level1) +{ + uint32_t sessionId = 0; + RestoreInfo restoreInfo = {}; + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().RestoreSession(sessionId, restoreInfo); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: UpdateSpatializationSupported +* @tc.desc : Test UpdateSpatializationSupported. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, UpdateSpatializationSupported, TestSize.Level1) +{ + std::string macAddress = "02:7f:3a:9d:1c:5b"; + bool support = false; + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().UpdateSpatializationSupported(macAddress, support); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: SubscribeSafeVolumeEvent +* @tc.desc : Test SubscribeSafeVolumeEvent. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, SubscribeSafeVolumeEvent, TestSize.Level1) +{ + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().SubscribeSafeVolumeEvent(); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: getFastControlParam +* @tc.desc : Test getFastControlParam. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, getFastControlParam, TestSize.Level1) +{ + bool ret = AudioPolicyService::GetAudioPolicyService().getFastControlParam(); + EXPECT_EQ(ret, true); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: NotifyAccountsChanged +* @tc.desc : Test NotifyAccountsChanged. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, NotifyAccountsChanged, TestSize.Level1) +{ + int id = 1; + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().NotifyAccountsChanged(id); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: GetDistributedRoutingRoleInfo +* @tc.desc : Test GetDistributedRoutingRoleInfo. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, GetDistributedRoutingRoleInfo, TestSize.Level1) +{ + DistributedRoutingInfo ret = AudioPolicyService::GetAudioPolicyService().GetDistributedRoutingRoleInfo(); + EXPECT_EQ(ret.descriptor, nullptr); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: GetAndSaveClientType +* @tc.desc : Test GetAndSaveClientType. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, GetAndSaveClientType, TestSize.Level1) +{ + uint32_t uid = 1; + std::string bundleName = "test"; + int32_t ret = AudioPolicyService::GetAudioPolicyService().GetAndSaveClientType(uid, bundleName); + EXPECT_EQ(ret, SUCCESS); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: UpdateDescWhenNoBTPermission +* @tc.desc : Test UpdateDescWhenNoBTPermission. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, UpdateDescWhenNoBTPermission, TestSize.Level1) +{ + vector> descs; + std::shared_ptr audioDeviceDescriptor = std::make_shared(); + audioDeviceDescriptor->deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP; + descs.push_back(std::move(audioDeviceDescriptor)); + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().UpdateDescWhenNoBTPermission(descs); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: RegisterDataObserver +* @tc.desc : Test RegisterDataObserver. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, RegisterDataObserver, TestSize.Level1) +{ + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().RegisterDataObserver(); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: RegisterRemoteDevStatusCallback +* @tc.desc : Test RegisterRemoteDevStatusCallback. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, RegisterRemoteDevStatusCallback, TestSize.Level1) +{ +#ifdef FEATURE_DEVICE_MANAGER + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().RegisterRemoteDevStatusCallback(); + ); +#endif +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: RestoreSession_001 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, RestoreSession_001, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest RestoreSession_001 start"); + GetPermission(); + const int32_t testID = 0; + RestoreInfo restoreInfo; + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().RestoreSession(testID, restoreInfo); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: GetDistributedRoutingRoleInfo_001 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, GetDistributedRoutingRoleInfo_001, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest GetDistributedRoutingRoleInfo_001 start"); + GetPermission(); + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().GetDistributedRoutingRoleInfo(); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: GetFastStreamInfo_001 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, GetFastStreamInfo_001, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest GetFastStreamInfo_001 start"); + GetPermission(); + AudioPolicyService::GetAudioPolicyService().audioConfigManager_.OnFastFormatParsed(AudioSampleFormat::SAMPLE_S32LE); + auto res = AudioPolicyService::GetAudioPolicyService().GetFastStreamInfo(); + ASSERT_EQ(AudioSampleFormat::SAMPLE_S32LE, res.format); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: GetActiveOutputDeviceDescriptor_001 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, GetActiveOutputDeviceDescriptor_001, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest GetActiveOutputDeviceDescriptor_001 start"); + GetPermission(); + auto res = AudioPolicyService::GetAudioPolicyService().GetActiveOutputDeviceDescriptor(); + ASSERT_NE(nullptr, res); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: OnMicrophoneBlockedUpdate_001 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, OnMicrophoneBlockedUpdate_001, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest OnMicrophoneBlockedUpdate_001 start"); + GetPermission(); + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().OnMicrophoneBlockedUpdate(DeviceType::DEVICE_TYPE_EARPIECE, + DeviceBlockStatus::DEVICE_BLOCKED); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: OnMicrophoneBlockedUpdate_002 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, OnMicrophoneBlockedUpdate_002, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest OnMicrophoneBlockedUpdate_002 start"); + GetPermission(); + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().OnMicrophoneBlockedUpdate(DeviceType::DEVICE_TYPE_NONE, + DeviceBlockStatus::DEVICE_BLOCKED); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: GetAllSinkInputs_001 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, GetAllSinkInputs_001, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest GetAllSinkInputs_001 start"); + GetPermission(); + std::vector sinkInputs; + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().GetAllSinkInputs(sinkInputs); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: SubscribeSafeVolumeEvent_001 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, SubscribeSafeVolumeEvent_001, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest SubscribeSafeVolumeEvent_001 start"); + GetPermission(); + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().SubscribeSafeVolumeEvent(); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: SetAvailableDeviceChangeCallback_002 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, SetAvailableDeviceChangeCallback_002, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest SetAvailableDeviceChangeCallback_002 start"); + GetPermission(); + int32_t clientId = 0; + const sptr object = nullptr; + int32_t ret = AudioPolicyService::GetAudioPolicyService().SetAvailableDeviceChangeCallback(clientId, + AudioDeviceUsage::MEDIA_INPUT_DEVICES, object, true); + ASSERT_EQ(SUCCESS, ret); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: SetQueryClientTypeCallback_001 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, SetQueryClientTypeCallback_001, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest SetQueryClientTypeCallback_001 start"); + GetPermission(); + const sptr object = new RemoteObjectTestStub(); + int32_t ret = AudioPolicyService::GetAudioPolicyService().SetQueryClientTypeCallback(object); + ASSERT_EQ(SUCCESS, ret); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: UpdateDescWhenNoBTPermission_001 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, UpdateDescWhenNoBTPermission_001, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest UpdateDescWhenNoBTPermission_001 start"); + GetPermission(); + std::vector> devices; + std::shared_ptr desc = + std::make_shared(DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP, DeviceRole::OUTPUT_DEVICE); + desc->networkId_ = "LocalDevice"; + devices.push_back(desc); + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().UpdateDescWhenNoBTPermission(devices); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: UpdateDescWhenNoBTPermission_002 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, UpdateDescWhenNoBTPermission_002, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest UpdateDescWhenNoBTPermission_002 start"); + GetPermission(); + std::vector> devices; + std::shared_ptr desc = + std::make_shared(DeviceType::DEVICE_TYPE_BLUETOOTH_SCO, DeviceRole::OUTPUT_DEVICE); + desc->networkId_ = "LocalDevice"; + devices.push_back(desc); + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().UpdateDescWhenNoBTPermission(devices); + ); +} + +/** +* @tc.name : Test AudioPolicyService. +* @tc.number: UpdateDescWhenNoBTPermission_003 +* @tc.desc : Test AudioPolicyService interfaces. +*/ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, UpdateDescWhenNoBTPermission_003, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest UpdateDescWhenNoBTPermission_003 start"); + GetPermission(); + std::vector> devices; + std::shared_ptr desc; + devices.push_back(desc); + EXPECT_NO_THROW( + AudioPolicyService::GetAudioPolicyService().UpdateDescWhenNoBTPermission(devices); + ); +} + +/** + * @tc.name : Test AudioPolicyService. + * @tc.number: UpdateCapturerInfoWhenNoPermission_001 + * @tc.desc : Test AudioPolicyService interfaces. + */ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, UpdateCapturerInfoWhenNoPermission_001, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest UpdateCapturerInfoWhenNoPermission_001 start"); + auto &server = AudioPolicyService::GetAudioPolicyService(); + + AudioDeviceDescriptor inputDeviceInfo(AudioDeviceDescriptor::DEVICE_INFO); + shared_ptr captureChangeInfo1 = make_shared(); + captureChangeInfo1->clientUID = 5000; + captureChangeInfo1->createrUID = 1001; + captureChangeInfo1->sessionId = 2001; + captureChangeInfo1->inputDeviceInfo = inputDeviceInfo; + + shared_ptr captureChangeInfo2 = make_shared(); + captureChangeInfo2->clientUID = 1001; + captureChangeInfo2->createrUID = 1001; + captureChangeInfo2->sessionId = 2001; + captureChangeInfo2->inputDeviceInfo = inputDeviceInfo; + + std::vector> audioCapturerChangeInfos; + audioCapturerChangeInfos.push_back(move(captureChangeInfo1)); + audioCapturerChangeInfos.push_back(move(captureChangeInfo2)); + bool hasBTPermission = false; + bool hasSystemPermission = false; + + int32_t ret = server.GetCurrentCapturerChangeInfos(audioCapturerChangeInfos, hasBTPermission, + hasSystemPermission); + EXPECT_EQ(ret, SUCCESS); +} + +/** + * @tc.name : Test AudioPolicyService. + * @tc.number: UpdateCapturerInfoWhenNoPermission_002 + * @tc.desc : Test AudioPolicyService interfaces. + */ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, UpdateCapturerInfoWhenNoPermission_002, TestSize.Level1) +{ + AUDIO_INFO_LOG("AudioPolicyServiceExtendedUnitTest UpdateCapturerInfoWhenNoPermission_002 start"); + auto &server = AudioPolicyService::GetAudioPolicyService(); + + AudioDeviceDescriptor inputDeviceInfo(AudioDeviceDescriptor::AUDIO_DEVICE_DESCRIPTOR); + shared_ptr captureChangeInfo = make_shared(); + captureChangeInfo->clientUID = 5000; + captureChangeInfo->createrUID = 1001; + captureChangeInfo->sessionId = 2001; + captureChangeInfo->inputDeviceInfo = inputDeviceInfo; + + std::vector> audioCapturerChangeInfos; + audioCapturerChangeInfos.push_back(move(captureChangeInfo)); + bool hasBTPermission = true; + bool hasSystemPermission = true; + + int32_t ret = server.GetCurrentCapturerChangeInfos(audioCapturerChangeInfos, hasBTPermission, + hasSystemPermission); + EXPECT_EQ(ret, SUCCESS); +} + +/** + * @tc.name : Test AudioPolicyService. + * @tc.number: GetPreferredOutputStreamType_002 + * @tc.desc : Test AudioPolicyService interfaces. + */ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, GetPreferredOutputStreamType_002, TestSize.Level1) +{ + auto &server = AudioPolicyService::GetAudioPolicyService(); + + AudioRendererInfo rendererInfo; + rendererInfo.streamUsage = STREAM_USAGE_MAX ; + std::string bundleName ; + + int32_t ret = server.GetPreferredOutputStreamType(rendererInfo, bundleName); + EXPECT_EQ(ret, AUDIO_FLAG_NORMAL); +} + +/** + * @tc.name : Test AudioPolicyService. + * @tc.number: GetPreferredOutputStreamType_004 + * @tc.desc : Test AudioPolicyService interfaces. + */ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, GetPreferredOutputStreamType_004, TestSize.Level1) +{ + auto &server = AudioPolicyService::GetAudioPolicyService(); + + AudioRendererInfo rendererInfo; + rendererInfo.rendererFlags = AUDIO_FLAG_VOIP_FAST; + std::string bundleName ; + auto& sceneManager = AudioSceneManager::GetInstance(); + sceneManager.SetAudioScenePre(AUDIO_SCENE_PHONE_CALL, 1, 1); + + int32_t ret = server.GetPreferredOutputStreamType(rendererInfo, bundleName); + EXPECT_EQ(ret, AUDIO_FLAG_NORMAL); +} + +/** + * @tc.name : Test AudioPolicyService. + * @tc.number: GetHardwareOutputSamplingRate_001 + * @tc.desc : Test AudioPolicyService interfaces. + */ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, GetHardwareOutputSamplingRate_001, TestSize.Level1) +{ + auto &server = AudioPolicyService::GetAudioPolicyService(); + + std::shared_ptr desc = nullptr; + int32_t ret = server.GetHardwareOutputSamplingRate(desc); + EXPECT_EQ(ret, -1); + + desc = std::make_shared(); + desc->deviceRole_ = DeviceRole::DEVICE_ROLE_NONE; + ret = server.GetHardwareOutputSamplingRate(desc); + EXPECT_EQ(ret, -1); + + desc->deviceRole_ = DeviceRole::OUTPUT_DEVICE; + ret = server.GetHardwareOutputSamplingRate(desc); + EXPECT_NE(ret, 48000); +} + +/** + * @tc.name : Test AudioPolicyService. + * @tc.number: GetProcessDeviceInfo_001 + * @tc.desc : Test AudioPolicyService interfaces. + */ +HWTEST_F(AudioPolicyServiceExtendedUnitTest, GetProcessDeviceInfo_001, TestSize.Level1) +{ + auto &policyService = AudioPolicyService::GetAudioPolicyService(); + auto config = AudioProcessConfig(); + config.rendererInfo.rendererFlags = AUDIO_FLAG_VOIP_DIRECT; + config.rendererInfo.originalFlag = AUDIO_FLAG_VOIP_DIRECT; + config.capturerInfo.originalFlag = AUDIO_FLAG_VOIP_DIRECT; + bool lockFlag = false; + auto deviceInfo = AudioDeviceDescriptor(); + int32_t ret = 0; + + config.audioMode = AUDIO_MODE_PLAYBACK; + config.rendererInfo.streamUsage = STREAM_USAGE_VOICE_COMMUNICATION; + + lockFlag = false; + ret = policyService.GetProcessDeviceInfo(config, lockFlag, deviceInfo); + ASSERT_EQ(ret, SUCCESS); + + lockFlag = true; + ret = policyService.GetProcessDeviceInfo(config, lockFlag, deviceInfo); + ASSERT_EQ(ret, SUCCESS); + config.rendererInfo.streamUsage = STREAM_USAGE_VOICE_MESSAGE; + + lockFlag = false; + ret = policyService.GetProcessDeviceInfo(config, lockFlag, deviceInfo); + ASSERT_EQ(ret, SUCCESS); + + lockFlag = true; + ret = policyService.GetProcessDeviceInfo(config, lockFlag, deviceInfo); + ASSERT_EQ(ret, SUCCESS); + + config.audioMode = AUDIO_MODE_RECORD; + config.capturerInfo.sourceType = SOURCE_TYPE_VOICE_COMMUNICATION; + + lockFlag = false; + ret = policyService.GetProcessDeviceInfo(config, lockFlag, deviceInfo); + ASSERT_EQ(ret, SUCCESS); + + lockFlag = true; + ret = policyService.GetProcessDeviceInfo(config, lockFlag, deviceInfo); + ASSERT_EQ(ret, SUCCESS); + config.capturerInfo.sourceType = SOURCE_TYPE_VOICE_CALL; + + lockFlag = false; + ret = policyService.GetProcessDeviceInfo(config, lockFlag, deviceInfo); + ASSERT_EQ(ret, SUCCESS); + + lockFlag = true; + ret = policyService.GetProcessDeviceInfo(config, lockFlag, deviceInfo); + ASSERT_EQ(ret, SUCCESS); +} +} // namespace AudioStandard +} // namespace OHOS diff --git a/services/audio_policy/test/unittest/audio_volume_manager_unit_test/include/audio_volume_manager_ext_unit_test.h b/services/audio_policy/test/unittest/audio_volume_manager_unit_test/include/audio_volume_manager_ext_unit_test.h new file mode 100644 index 0000000000..c1cfd1ef39 --- /dev/null +++ b/services/audio_policy/test/unittest/audio_volume_manager_unit_test/include/audio_volume_manager_ext_unit_test.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AUDIO_VOLUME_MANAGER_EXT_UNIT_TEST_H +#define AUDIO_VOLUME_MANAGER_EXT_UNIT_TEST_H +#include "gtest/gtest.h" +#include "audio_volume_manager.h" + +namespace OHOS { +namespace AudioStandard { + +class AudioVolumeManagerExtUnitTest : public testing::Test { +public: + // SetUpTestCase: Called before all test cases + static void SetUpTestCase(void); + // TearDownTestCase: Called after all test case + static void TearDownTestCase(void); + // SetUp: Called before each test cases + void SetUp(void); + // TearDown: Called after each test cases + void TearDown(void); +}; +} // namespace AudioStandard +} // namespace OHOS +#endif //AUDIO_VOLUME_MANAGER_EXT_UNIT_TEST_H diff --git a/services/audio_policy/test/unittest/audio_volume_manager_unit_test/src/audio_volume_manager_ext_unit_test.cpp b/services/audio_policy/test/unittest/audio_volume_manager_unit_test/src/audio_volume_manager_ext_unit_test.cpp new file mode 100644 index 0000000000..686d5e52f5 --- /dev/null +++ b/services/audio_policy/test/unittest/audio_volume_manager_unit_test/src/audio_volume_manager_ext_unit_test.cpp @@ -0,0 +1,377 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "sle_audio_device_manager.h" +#include "audio_volume_manager_ext_unit_test.h" + +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { +const int32_t RESTORE_VOLUME_NOTIFICATION_ID = 116000; +const int32_t INCREASE_VOLUME_NOTIFICATION_ID = 116001; +const uint32_t NOTIFICATION_BANNER_FLAG = 1 << 9; +const std::string AUDIO_RESTORE_VOLUME_EVENT = "AUDIO_RESTORE_VOLUME_EVENT"; +const std::string AUDIO_INCREASE_VOLUME_EVENT = "AUDIO_INCREASE_VOLUME_EVENT"; + +void AudioVolumeManagerExtUnitTest::SetUpTestCase(void) {} +void AudioVolumeManagerExtUnitTest::TearDownTestCase(void) {} + +void AudioVolumeManagerExtUnitTest::SetUp(void) +{ + std::shared_ptr audioPolicyServerHandler( + DelayedSingleton::GetInstance()); + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + + audioVolumeManager.Init(audioPolicyServerHandler); +} + +void AudioVolumeManagerExtUnitTest::TearDown(void) +{ + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + + audioVolumeManager.DeInit(); +} + +/** +* @tc.name : Test AudioVolumeManager. +* @tc.number: GetSystemVolumeLevel_001 +* @tc.desc : Test GetSystemVolumeLevel interface. +*/ +HWTEST_F(AudioVolumeManagerExtUnitTest, GetSystemVolumeLevel_001, TestSize.Level1) +{ + auto audioVolumeManager = std::make_shared(); + ASSERT_TRUE(audioVolumeManager != nullptr); + + int32_t zoneId = 0; + AudioStreamType streamType = STREAM_RING; + audioVolumeManager->audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_BLUETOOTH_SCO; + audioVolumeManager->SetRingerModeMute(false); + int32_t ret = audioVolumeManager->GetSystemVolumeLevel(streamType, zoneId); + EXPECT_EQ(ret, 0); +} + +/** +* @tc.name : Test AudioVolumeManager. +* @tc.number: HandleA2dpAbsVolume_001 +* @tc.desc : Test HandleA2dpAbsVolume interface. +*/ +HWTEST_F(AudioVolumeManagerExtUnitTest, HandleA2dpAbsVolume_001, TestSize.Level1) +{ + auto audioVolumeManager = std::make_shared(); + ASSERT_TRUE(audioVolumeManager != nullptr); + + int32_t volumeLevel = 0; + AudioStreamType streamType = STREAM_RING; + DeviceType deviceType = DEVICE_TYPE_BLUETOOTH_A2DP; + int32_t ret = audioVolumeManager->HandleA2dpAbsVolume(streamType, volumeLevel, deviceType); + EXPECT_NE(ret, 0); +} + +/** +* @tc.name : Test AudioVolumeManager. +* @tc.number: HandleNearlinkDeviceAbsVolume_001 +* @tc.desc : Test HandleNearlinkDeviceAbsVolume interface. +*/ +HWTEST_F(AudioVolumeManagerExtUnitTest, HandleNearlinkDeviceAbsVolume_001, TestSize.Level1) +{ + auto audioVolumeManager = std::make_shared(); + ASSERT_TRUE(audioVolumeManager != nullptr); + + DeviceType curOutputDeviceType = DEVICE_TYPE_SPEAKER; + AudioStreamType streamType = STREAM_MUSIC; + int32_t volumeLevel = 1000; + bool internalCall = true; + SleVolumeConfigInfo configInfo; + std::pair pairConfigInfo = std::make_pair(configInfo, configInfo); + SleAudioDeviceManager::GetInstance().deviceVolumeConfigInfo_["test"] = pairConfigInfo; + auto ret = audioVolumeManager->HandleNearlinkDeviceAbsVolume(streamType, volumeLevel, curOutputDeviceType); + EXPECT_NE(ret, ERROR); +} + +/** +* @tc.name : Test AudioVolumeManager. +* @tc.number: HandleNearlinkDeviceAbsVolume_002 +* @tc.desc : Test HandleNearlinkDeviceAbsVolume interface. +*/ +HWTEST_F(AudioVolumeManagerExtUnitTest, HandleNearlinkDeviceAbsVolume_002, TestSize.Level1) +{ + auto audioVolumeManager = std::make_shared(); + ASSERT_TRUE(audioVolumeManager != nullptr); + + DeviceType curOutputDeviceType = DEVICE_TYPE_SPEAKER; + std::string macAddress = "test"; + AudioStreamType streamType = STREAM_RING; + int32_t volumeLevel = 1000; + SleVolumeConfigInfo configInfo; + std::pair pairConfigInfo = std::make_pair(configInfo, configInfo); + SleAudioDeviceManager::GetInstance().deviceVolumeConfigInfo_["test"] = pairConfigInfo; + auto ret = audioVolumeManager->HandleNearlinkDeviceAbsVolume(streamType, volumeLevel, curOutputDeviceType); + EXPECT_NE(ret, ERROR); +} + +/** +* @tc.name : Test AudioVolumeManager. +* @tc.number: SetSystemVolumeLevel_001 +* @tc.desc : Test SetSystemVolumeLevel. +*/ +HWTEST_F(AudioVolumeManagerExtUnitTest, SetSystemVolumeLevel_001, TestSize.Level1) +{ + auto audioVolumeManager = std::make_shared(); + EXPECT_NE(audioVolumeManager, nullptr); + + audioVolumeManager->audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP; + AudioStreamType streamType = STREAM_RING; + int32_t volumeLevel = 0; + EXPECT_EQ(VolumeUtils::GetVolumeTypeFromStreamType(streamType), STREAM_RING); + + auto ret = audioVolumeManager->SetSystemVolumeLevel(streamType, volumeLevel); + EXPECT_EQ(ret, SUCCESS); +} + +/** + * @tc.name : Test AudioVolumeManager. + * @tc.number: CheckBlueToothActiveMusicTime_001 + * @tc.desc : CheckBlueToothActiveMusicTime + */ +HWTEST_F(AudioVolumeManagerExtUnitTest, CheckBlueToothActiveMusicTime_001, TestSize.Level1) +{ + auto& volumeManager = AudioVolumeManager::GetInstance(); + volumeManager.activeSafeTimeBt_ = 68400; + volumeManager.CheckBlueToothActiveMusicTime(0); + EXPECT_TRUE(volumeManager.restoreNIsShowing_); +} + +/** + * @tc.name : Test AudioVolumeManager. + * @tc.number: CheckBlueToothActiveMusicTime_002 + * @tc.desc : CheckBlueToothActiveMusicTime + */ +HWTEST_F(AudioVolumeManagerExtUnitTest, CheckBlueToothActiveMusicTime_002, TestSize.Level1) +{ + auto& volumeManager = AudioVolumeManager::GetInstance(); + volumeManager.activeSafeTimeBt_ = 0; + volumeManager.activeSafeTime_ = 68400; + volumeManager.CheckBlueToothActiveMusicTime(0); + EXPECT_TRUE(volumeManager.restoreNIsShowing_); +} + +/** + * @tc.name : Test AudioVolumeManager. + * @tc.number: CheckBlueToothActiveMusicTime_003 + * @tc.desc : CheckBlueToothActiveMusicTime + */ +HWTEST_F(AudioVolumeManagerExtUnitTest, CheckBlueToothActiveMusicTime_003, TestSize.Level1) +{ + auto& volumeManager = AudioVolumeManager::GetInstance(); + int32_t currentTime = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now()); + volumeManager.startSafeTimeBt_ = currentTime - 60; + volumeManager.CheckBlueToothActiveMusicTime(0); + EXPECT_GT(volumeManager.startSafeTimeBt_, currentTime - 60); +} + +/** + * @tc.name : Test AudioVolumeManager. + * @tc.number: CheckWiredActiveMusicTime_001 + * @tc.desc : CheckWiredActiveMusicTime + */ +HWTEST_F(AudioVolumeManagerExtUnitTest, CheckWiredActiveMusicTime_001, TestSize.Level1) +{ + auto& volumeManager = AudioVolumeManager::GetInstance(); + volumeManager.activeSafeTime_ = 68400; + volumeManager.CheckWiredActiveMusicTime(0); + EXPECT_TRUE(volumeManager.restoreNIsShowing_); +} + +/** + * @tc.name : Test AudioVolumeManager. + * @tc.number: CheckWiredActiveMusicTime_002 + * @tc.desc : CheckWiredActiveMusicTime + */ +HWTEST_F(AudioVolumeManagerExtUnitTest, CheckWiredActiveMusicTime_002, TestSize.Level1) +{ + auto& volumeManager = AudioVolumeManager::GetInstance(); + volumeManager.activeSafeTimeBt_ = 68400; + volumeManager.activeSafeTime_ = 0; + volumeManager.CheckWiredActiveMusicTime(0); + EXPECT_TRUE(volumeManager.restoreNIsShowing_); +} + +/** + * @tc.name : Test AudioVolumeManager. + * @tc.number: CheckWiredActiveMusicTime_003 + * @tc.desc : CheckWiredActiveMusicTime + */ +HWTEST_F(AudioVolumeManagerExtUnitTest, CheckWiredActiveMusicTime_003, TestSize.Level1) +{ + auto& volumeManager = AudioVolumeManager::GetInstance(); + int32_t currentTime = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now()); + volumeManager.startSafeTime_ = currentTime - 60; + volumeManager.CheckWiredActiveMusicTime(0); + EXPECT_GT(volumeManager.startSafeTime_, currentTime - 60); +} + +/** +* @tc.name : Test AudioVolumeManager. +* @tc.number: HandleAbsBluetoothVolume_004 +* @tc.desc : Test HandleAbsBluetoothVolume interface. +*/ +HWTEST_F(AudioVolumeManagerExtUnitTest, HandleAbsBluetoothVolume_004, TestSize.Level1) +{ + std::string macAddress = "11:22:33:44:55:66"; + int32_t volumeLevel = 0; + int32_t ret; + AudioStreamType streamType = STREAM_MUSIC; + AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance()); + + audioVolumeManager.isBtFirstBoot_ = false; + ret = audioVolumeManager.HandleAbsBluetoothVolume(macAddress, volumeLevel, true, streamType); + EXPECT_EQ(ret, 0); + + audioVolumeManager.isBtFirstBoot_ = false; + audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceCategory_ = BT_HEADPHONE; + ret = audioVolumeManager.HandleAbsBluetoothVolume(macAddress, volumeLevel, false, streamType); + EXPECT_EQ(ret, 0); +} + +/** +* @tc.name : Test AudioVolumeManager. +* @tc.number: DealWithSafeVolume_001 +* @tc.desc : Test DealWithSafeVolume interface. +*/ +HWTEST_F(AudioVolumeManagerExtUnitTest, DealWithSafeVolume_001, TestSize.Level1) +{ + auto audioVolumeManager = std::make_shared(); + EXPECT_NE(audioVolumeManager, nullptr); + int32_t volumeLevel = 0; + audioVolumeManager->audioActiveDevice_.currentActiveDevice_.deviceCategory_ = BT_CAR; + int32_t ret = audioVolumeManager->DealWithSafeVolume(volumeLevel, true); + EXPECT_EQ(ret, 0); +} + +/** +* @tc.name : Test AudioVolumeManager. +* @tc.number: DealWithSafeVolume_002 +* @tc.desc : Test DealWithSafeVolume interface. +*/ +HWTEST_F(AudioVolumeManagerExtUnitTest, DealWithSafeVolume_002, TestSize.Level1) +{ + auto audioVolumeManager = std::make_shared(); + EXPECT_NE(audioVolumeManager, nullptr); + int32_t volumeLevel = 0; + audioVolumeManager->audioActiveDevice_.currentActiveDevice_.deviceCategory_ = BT_SOUNDBOX; + int32_t ret = audioVolumeManager->DealWithSafeVolume(volumeLevel, true); + EXPECT_EQ(ret, 0); +} + +/** +* @tc.name : Test AudioVolumeManager. +* @tc.number: DealWithSafeVolume_003 +* @tc.desc : Test DealWithSafeVolume interface. +*/ +HWTEST_F(AudioVolumeManagerExtUnitTest, DealWithSafeVolume_003, TestSize.Level1) +{ + auto audioVolumeManager = std::make_shared(); + EXPECT_NE(audioVolumeManager, nullptr); + int32_t volumeLevel = 0; + audioVolumeManager->audioActiveDevice_.currentActiveDevice_.deviceCategory_ = BT_HEADPHONE; + audioVolumeManager->safeStatusBt_ = SAFE_INACTIVE; + int32_t ret = audioVolumeManager->DealWithSafeVolume(volumeLevel, true); + EXPECT_EQ(ret, 0); +} + +/** +* @tc.name : Test AudioVolumeManager. +* @tc.number: DealWithSafeVolume_004 +* @tc.desc : Test DealWithSafeVolume interface. +*/ +HWTEST_F(AudioVolumeManagerExtUnitTest, DealWithSafeVolume_004, TestSize.Level1) +{ + auto audioVolumeManager = std::make_shared(); + EXPECT_NE(audioVolumeManager, nullptr); + int32_t volumeLevel = 0; + audioVolumeManager->audioActiveDevice_.currentActiveDevice_.deviceCategory_ = BT_HEADPHONE; + audioVolumeManager->safeStatus_ = SAFE_INACTIVE; + int32_t ret = audioVolumeManager->DealWithSafeVolume(volumeLevel, false); + EXPECT_EQ(ret, 0); +} + +/** +* @tc.name : Test AudioVolumeManager. +* @tc.number: DealWithSafeVolume_005 +* @tc.desc : Test DealWithSafeVolume interface. +*/ +HWTEST_F(AudioVolumeManagerExtUnitTest, DealWithSafeVolume_005, TestSize.Level1) +{ + auto audioVolumeManager = std::make_shared(); + EXPECT_NE(audioVolumeManager, nullptr); + int32_t volumeLevel = 0; + audioVolumeManager->audioActiveDevice_.currentActiveDevice_.deviceCategory_ = BT_HEADPHONE; + audioVolumeManager->safeStatus_ = SAFE_ACTIVE; + int32_t ret = audioVolumeManager->DealWithSafeVolume(volumeLevel, false); + EXPECT_EQ(ret, 0); +} + +/** +* @tc.name : Test AudioVolumeManager. +* @tc.number: DealWithSafeVolume_006 +* @tc.desc : Test DealWithSafeVolume interface. +*/ +HWTEST_F(AudioVolumeManagerExtUnitTest, DealWithSafeVolume_006, TestSize.Level1) +{ + auto audioVolumeManager = std::make_shared(); + EXPECT_NE(audioVolumeManager, nullptr); + int32_t volumeLevel = 0; + audioVolumeManager->audioActiveDevice_.currentActiveDevice_.deviceCategory_ = BT_HEADPHONE; + audioVolumeManager->safeStatusBt_ = SAFE_ACTIVE; + int32_t ret = audioVolumeManager->DealWithSafeVolume(volumeLevel, true); + EXPECT_EQ(ret, 0); +} + +/** + * @tc.name : Test AudioVolumeManager. + * @tc.number: GetForceControlVolumeType_001 + * @tc.desc : Test GetForceControlVolumeType. + */ +HWTEST_F(AudioVolumeManagerExtUnitTest, GetForceControlVolumeType_001, TestSize.Level4) +{ + auto &audioVolumeManager = AudioVolumeManager::GetInstance(); + ASSERT_EQ(audioVolumeManager.GetForceControlVolumeType(), STREAM_DEFAULT); +} + +/** + * @tc.name : Test AudioVolumeManager. + * @tc.number: IsNeedForceControlVolumeType_001 + * @tc.desc : Test IsNeedForceControlVolumeType. + */ +HWTEST_F(AudioVolumeManagerExtUnitTest, IsNeedForceControlVolumeType_001, TestSize.Level4) +{ + auto &audioVolumeManager = AudioVolumeManager::GetInstance(); + ASSERT_EQ(audioVolumeManager.IsNeedForceControlVolumeType(), false); +} + +/** + * @tc.name : Test AudioVolumeManager. + * @tc.number: GetVolumeGroupInfosNotWait_001 + * @tc.desc : Test GetVolumeGroupInfosNotWait. + */ +HWTEST_F(AudioVolumeManagerExtUnitTest, GetVolumeGroupInfosNotWait_001, TestSize.Level4) +{ + auto &audioVolumeManager = AudioVolumeManager::GetInstance(); + std::vector> infos; + ASSERT_EQ(audioVolumeManager.GetVolumeGroupInfosNotWait(infos), false); +} +} // namespace AudioStandard +} // namespace OHOS \ No newline at end of file diff --git a/services/audio_policy/test/unittest/privacy_priority_router_unit_test/src/privacy_priority_router_unit_test.cpp b/services/audio_policy/test/unittest/privacy_priority_router_unit_test/src/privacy_priority_router_unit_test.cpp index 36e11f5d25..fb77f53215 100644 --- a/services/audio_policy/test/unittest/privacy_priority_router_unit_test/src/privacy_priority_router_unit_test.cpp +++ b/services/audio_policy/test/unittest/privacy_priority_router_unit_test/src/privacy_priority_router_unit_test.cpp @@ -136,6 +136,65 @@ HWTEST(PrivacyPriorityRouterUnitTest, PrivacyPriorityRouter_002, TestSize.Level1 EXPECT_EQ(1, router.GetRingRenderDevices(STREAM_USAGE_RINGTONE, 1).size()); EXPECT_EQ(1, router.GetRingRenderDevices(STREAM_USAGE_ALARM, 1).size()); } + +/** + * @tc.name : Test PrivacyPriorityRouter. + * @tc.number: GetMediaRenderDevice_001 + * @tc.desc : Test GetMediaRenderDevice interface. + */ +HWTEST(PrivacyPriorityRouterUnitTest, GetMediaRenderDevice_001, TestSize.Level4) +{ + PrivacyPriorityRouter router; + StreamUsage streamUsage = STREAM_USAGE_VOICE_MODEM_COMMUNICATION; + int32_t clientUID = 12345; + auto ret = router.GetMediaRenderDevice(streamUsage, clientUID); + EXPECT_NE(ret, nullptr); +} + +/** + * @tc.name : Test PrivacyPriorityRouter. + * @tc.number: GetCallCaptureDevice_001 + * @tc.desc : Test GetCallCaptureDevice interface. + */ +HWTEST(PrivacyPriorityRouterUnitTest, GetCallCaptureDevice_001, TestSize.Level4) +{ + PrivacyPriorityRouter router; + SourceType sourceType = SOURCE_TYPE_VOICE_RECOGNITION; + int32_t clientUID = 1; + uint32_t sessionID = 1; + auto ret = router.GetCallCaptureDevice(sourceType, clientUID, sessionID); + EXPECT_NE(ret, nullptr); +} + +/** + * @tc.name : Test PrivacyPriorityRouter. + * @tc.number: GetToneRenderDevice_001 + * @tc.desc : Test GetToneRenderDevice interface. + */ +HWTEST(PrivacyPriorityRouterUnitTest, GetToneRenderDevice_001, TestSize.Level4) +{ + PrivacyPriorityRouter router; + StreamUsage streamUsage = STREAM_USAGE_VOICE_MODEM_COMMUNICATION; + int32_t clientUID = 12345; + auto ret = router.GetToneRenderDevice(streamUsage, clientUID); + EXPECT_NE(ret, nullptr); +} + +/** + * @tc.name : Test PrivacyPriorityRouter. + * @tc.number: RemoveArmUsb_001 + * @tc.desc : Test RemoveArmUsb interface. + */ +HWTEST(PrivacyPriorityRouterUnitTest, RemoveArmUsb_001, TestSize.Level4) +{ + PrivacyPriorityRouter router; + vector> descs; + shared_ptr desc = std::make_shared(); + desc->deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET; + descs.emplace_back(desc); + router.RemoveArmUsb(descs); + EXPECT_EQ(descs.size(), 0); +} } // namespace AudioStandard } // namespace OHOS \ No newline at end of file diff --git a/services/audio_policy/test/unittest/user_select_router_unit_test/include/user_select_router_ext_unit_test.h b/services/audio_policy/test/unittest/user_select_router_unit_test/include/user_select_router_ext_unit_test.h new file mode 100644 index 0000000000..097c2abd99 --- /dev/null +++ b/services/audio_policy/test/unittest/user_select_router_unit_test/include/user_select_router_ext_unit_test.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef USER_SELECT_ROUTER_EXT_UNIT_TEST_H +#define USER_SELECT_ROUTER_EXT_UNIT_TEST_H + +#include "gtest/gtest.h" +#include "audio_system_manager.h" +#include "user_select_router.h" + +namespace OHOS { +namespace AudioStandard { + +class UserSelectRouterExtUnitTest : public testing::Test { +public: + // SetUpTestCase: Called before all test cases + static void SetUpTestCase(void); + // TearDownTestCase: Called after all test case + static void TearDownTestCase(void); + // SetUp: Called before each test cases + void SetUp(void); + // TearDown: Called after each test cases + void TearDown(void); +}; +} // namespace AudioStandard +} // namespace OHOS +#endif // USER_SELECT_ROUTER_EXT_UNIT_TEST_H diff --git a/services/audio_policy/test/unittest/user_select_router_unit_test/src/user_select_router_ext_unit_test.cpp b/services/audio_policy/test/unittest/user_select_router_unit_test/src/user_select_router_ext_unit_test.cpp new file mode 100644 index 0000000000..e67141f13b --- /dev/null +++ b/services/audio_policy/test/unittest/user_select_router_unit_test/src/user_select_router_ext_unit_test.cpp @@ -0,0 +1,227 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "user_select_router_ext_unit_test.h" +#include "audio_errors.h" +#include "audio_policy_log.h" +#include "audio_policy_server.h" +#include "audio_policy_service.h" + +#include +#include +#include +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { + +void UserSelectRouterExtUnitTest::SetUpTestCase(void) {} +void UserSelectRouterExtUnitTest::TearDownTestCase(void) {} +void UserSelectRouterExtUnitTest::SetUp(void) {} +void UserSelectRouterExtUnitTest::TearDown(void) {} + +/** + * @tc.name : Test GetMediaRenderDevice. + * @tc.number: GetMediaRenderDevice_004 + * @tc.desc : GetMediaRenderDevice. + */ +HWTEST(UserSelectRouterExtUnitTest, GetMediaRenderDevice_004, TestSize.Level3) +{ + UserSelectRouter userSelectRouter; + int32_t clientUID = 1; + auto& audioStateManager = AudioStateManager::GetAudioStateManager(); + audioStateManager.preferredMediaRenderDevice_->deviceId_ = 1; + audioStateManager.preferredMediaRenderDevice_->deviceUsage_ = MEDIA; + auto result = userSelectRouter.GetMediaRenderDevice(STREAM_USAGE_MEDIA, clientUID); + EXPECT_NE(result, nullptr); +} + +/** + * @tc.name : Test GetMediaRenderDevice. + * @tc.number: GetCallRenderDevice_004 + * @tc.desc : GetCallRenderDevice + */ +HWTEST(UserSelectRouterExtUnitTest, GetCallRenderDevice_004, TestSize.Level3) +{ + UserSelectRouter userSelectRouter; + int32_t clientUID = 1; + auto& audioStateManager = AudioStateManager::GetAudioStateManager(); + audioStateManager.preferredMediaRenderDevice_->deviceId_ = 1; + audioStateManager.preferredMediaRenderDevice_->deviceUsage_ = VOICE; + auto result = userSelectRouter.GetCallRenderDevice(STREAM_USAGE_VOICE_MESSAGE, clientUID); + EXPECT_NE(result, nullptr); +} + +/** + * @tc.name : Test GetCallCaptureDevice. + * @tc.number: GetCallCaptureDevice_003 + * @tc.desc : GetCallCaptureDevice. + */ +HWTEST(UserSelectRouterExtUnitTest, GetCallCaptureDevice_003, TestSize.Level3) +{ + UserSelectRouter userSelectRouter; + SourceType sourceType = SourceType::SOURCE_TYPE_VOICE_RECOGNITION; + StreamUsage streamUsage = StreamUsage::STREAM_USAGE_VOICE_MESSAGE; + int32_t clientUID = 1; + uint32_t sessionID = 678; + auto preferredDevice = std::make_shared(); + preferredDevice->deviceId_ = 1; + preferredDevice->deviceUsage_ = VOICE; + AudioStateManager::GetAudioStateManager().SetPreferredCallRenderDevice(preferredDevice); + auto result = userSelectRouter.GetCallCaptureDevice(sourceType, clientUID, sessionID); + EXPECT_NE(result, nullptr); +} + +/** + * @tc.name : Test GetCallCaptureDevice. + * @tc.number: GetCallCaptureDevice_004 + * @tc.desc : GetCallCaptureDevice. + */ +HWTEST(UserSelectRouterExtUnitTest, GetCallCaptureDevice_004, TestSize.Level4) +{ + UserSelectRouter userSelectRouter; + SourceType sourceType = SourceType::SOURCE_TYPE_VOICE_RECOGNITION; + StreamUsage streamUsage = StreamUsage::STREAM_USAGE_VOICE_MESSAGE; + int32_t clientUID = 1; + uint32_t sessionID = 678; + auto preferredDevice = std::make_shared(); + preferredDevice->deviceId_ = 0; + preferredDevice->deviceUsage_ = VOICE; + AudioStateManager::GetAudioStateManager().SetPreferredCallRenderDevice(preferredDevice); + + auto result = userSelectRouter.GetCallCaptureDevice(sourceType, clientUID, sessionID); + EXPECT_NE(result, nullptr); +} + +/** + * @tc.name : Test GetRingRenderDevices. + * @tc.number: GetRingRenderDevices_004 + * @tc.desc : GetRingRenderDevices. + */ +HWTEST(UserSelectRouterExtUnitTest, GetRingRenderDevices_004, TestSize.Level3) +{ + UserSelectRouter userSelectRouter; + SourceType sourceType = SourceType::SOURCE_TYPE_VOICE_RECOGNITION; + StreamUsage streamUsage = StreamUsage::STREAM_USAGE_VOICE_MESSAGE; + int32_t clientUID = 1; + uint32_t sessionID = 678; + auto preferredDevice = std::make_shared(); + preferredDevice->deviceId_ = 0; + preferredDevice->deviceUsage_ = VOICE; + preferredDevice->deviceType_ = DEVICE_TYPE_WIRED_HEADSET; + vector> descs = + userSelectRouter.GetRingRenderDevices(STREAM_USAGE_RINGTONE, clientUID); + EXPECT_EQ(descs.size(), 1); +} + +/** + * @tc.name : Test GetRingRenderDevices. + * @tc.number: GetRingRenderDevices_005 + * @tc.desc : GetRingRenderDevices. + */ +HWTEST(UserSelectRouterExtUnitTest, GetRingRenderDevices_005, TestSize.Level3) +{ + UserSelectRouter userSelectRouter; + SourceType sourceType = SourceType::SOURCE_TYPE_VOICE_RECOGNITION; + StreamUsage streamUsage = StreamUsage::STREAM_USAGE_VOICE_MESSAGE; + int32_t clientUID = 1; + uint32_t sessionID = 678; + auto preferredDevice = std::make_shared(); + preferredDevice->deviceId_ = 0; + preferredDevice->deviceUsage_ = VOICE; + preferredDevice->deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP; + vector> descs = + userSelectRouter.GetRingRenderDevices(STREAM_USAGE_VOICE_RINGTONE, clientUID); + EXPECT_EQ(descs.size(), 1); +} + +/** + * @tc.name : Test GetRingRenderDevices. + * @tc.number: GetRingRenderDevices_006 + * @tc.desc : GetRingRenderDevices. + */ +HWTEST(UserSelectRouterExtUnitTest, GetRingRenderDevices_006, TestSize.Level3) +{ + UserSelectRouter userSelectRouter; + SourceType sourceType = SourceType::SOURCE_TYPE_VOICE_RECOGNITION; + StreamUsage streamUsage = StreamUsage::STREAM_USAGE_VOICE_MESSAGE; + int32_t clientUID = 1; + uint32_t sessionID = 678; + auto preferredDevice = std::make_shared(); + preferredDevice->deviceId_ = 0; + preferredDevice->deviceUsage_ = VOICE; + preferredDevice->deviceType_ = DEVICE_TYPE_NONE; + vector> descs = + userSelectRouter.GetRingRenderDevices(STREAM_USAGE_ALARM, clientUID); + EXPECT_EQ(descs.size(), 1); +} +/** + * @tc.name : Test GetRingRenderDevices. + * @tc.number: GetRingRenderDevices_007 + * @tc.desc : GetRingRenderDevices. + */ +HWTEST(UserSelectRouterExtUnitTest, GetRingRenderDevices_007, TestSize.Level3) +{ + UserSelectRouter userSelectRouter; + SourceType sourceType = SourceType::SOURCE_TYPE_VOICE_RECOGNITION; + StreamUsage streamUsage = StreamUsage::STREAM_USAGE_VOICE_MESSAGE; + int32_t clientUID = 1; + uint32_t sessionID = 678; + auto preferredDevice = std::make_shared(); + preferredDevice->deviceId_ = 0; + preferredDevice->deviceUsage_ = VOICE; + preferredDevice->deviceType_ = DEVICE_TYPE_WIRED_HEADSET; + vector> descs = + userSelectRouter.GetRingRenderDevices(STREAM_USAGE_ALARM, clientUID); + EXPECT_EQ(descs.size(), 1); +} + +/** + * @tc.name : Test GetRecordCaptureDevice. + * @tc.number: GetRecordCaptureDevice_003 + * @tc.desc : GetRecordCaptureDevice. + */ +HWTEST(UserSelectRouterExtUnitTest, GetRecordCaptureDevice_003, TestSize.Level4) +{ + UserSelectRouter userSelectRouter; + SourceType sourceType = SourceType::SOURCE_TYPE_VOICE_RECOGNITION; + int32_t clientUID = 1; + uint32_t sessionID = 678; + auto& audioStateManager = AudioStateManager::GetAudioStateManager(); + audioStateManager.preferredMediaRenderDevice_->deviceId_ = 1; + audioStateManager.preferredMediaRenderDevice_->deviceUsage_ = MEDIA; + auto result = userSelectRouter.GetRecordCaptureDevice(sourceType, clientUID, sessionID); + EXPECT_NE(result, nullptr); +} + +/** + * @tc.name : Test GetRecordCaptureDevice. + * @tc.number: GetRecordCaptureDevice_004 + * @tc.desc : GetRecordCaptureDevice. + */ +HWTEST(UserSelectRouterExtUnitTest, GetRecordCaptureDevice_004, TestSize.Level3) +{ + UserSelectRouter userSelectRouter; + SourceType sourceType = SourceType::SOURCE_TYPE_VOICE_TRANSCRIPTION; + int32_t clientUID = 1; + uint32_t sessionID = 678; + auto& audioStateManager = AudioStateManager::GetAudioStateManager(); + audioStateManager.preferredMediaRenderDevice_->deviceId_ = 1; + audioStateManager.preferredMediaRenderDevice_->deviceUsage_ = MEDIA; + auto result = userSelectRouter.GetRecordCaptureDevice(sourceType, clientUID, sessionID); + EXPECT_NE(result, nullptr); +} +} // namespace AudioStandard +} // namespace OHOS diff --git a/services/audio_policy/test/unittest/volume_data_maintainer_unit_test/src/volume_data_maintainer_unit_test.cpp b/services/audio_policy/test/unittest/volume_data_maintainer_unit_test/src/volume_data_maintainer_unit_test.cpp index 2624f623db..7582a6b9d1 100644 --- a/services/audio_policy/test/unittest/volume_data_maintainer_unit_test/src/volume_data_maintainer_unit_test.cpp +++ b/services/audio_policy/test/unittest/volume_data_maintainer_unit_test/src/volume_data_maintainer_unit_test.cpp @@ -999,5 +999,312 @@ HWTEST(VolumeDataMaintainerUnitTest, SetAppStreamMuted_001, TestSize.Level1) EXPECT_EQ(volumeDataMaintainer->IsAppStreamMuted(appUid, streamType), false); EXPECT_EQ(volumeDataMaintainer->IsAppStreamMuted(appUid, anotherStreamType), false); } + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: SetDataShareReady_001. + * @tc.desc : Test SetDataShareReady API. + */ +HWTEST(VolumeDataMaintainerUnitTest, SetDataShareReady_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + std::atomic isDataShareReady = false; + volumeDataMaintainerRet->SetDataShareReady(std::atomic_load(&isDataShareReady)); + AudioSettingProvider& audioSettingProvider = AudioSettingProvider::GetInstance(AUDIO_POLICY_SERVICE_ID); + EXPECT_FALSE(audioSettingProvider.isDataShareReady_); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: SetStreamVolume_001. + * @tc.desc : Test SetStreamVolume API. + */ +HWTEST(VolumeDataMaintainerUnitTest, SetStreamVolume_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + int32_t volumeLevel = 1; + volumeDataMaintainerRet->SetStreamVolume(streamType, volumeLevel); + EXPECT_FALSE(volumeDataMaintainerRet->volumeLevelMap_.empty()); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: SetAppVolume_001. + * @tc.desc : Test SetAppVolume API. + */ +HWTEST(VolumeDataMaintainerUnitTest, SetAppVolume_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + int32_t appUid = 99999; + int32_t volumeLevel = 1; + volumeDataMaintainerRet->SetAppVolume(appUid, volumeLevel); + EXPECT_TRUE(volumeDataMaintainerRet->volumeLevelMap_.empty()); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: SetAppVolumeMuted_001. + * @tc.desc : Test SetAppVolumeMuted API. + */ +HWTEST(VolumeDataMaintainerUnitTest, SetAppVolumeMuted_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + int32_t appUid = 99999; + bool muted = true; + volumeDataMaintainerRet->SetAppVolumeMuted(appUid, muted); + EXPECT_TRUE(volumeDataMaintainerRet->volumeLevelMap_.empty()); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: GetStreamVolume_001. + * @tc.desc : Test GetStreamVolume API. + */ +HWTEST(VolumeDataMaintainerUnitTest, GetStreamVolume_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + int32_t ret = volumeDataMaintainerRet->GetStreamVolume(streamType); + EXPECT_EQ(ret, 0); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: GetDeviceVolume_001. + * @tc.desc : Test GetDeviceVolume API. + */ +HWTEST(VolumeDataMaintainerUnitTest, GetDeviceVolume_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + DeviceType deviceType = DeviceType::DEVICE_TYPE_EARPIECE; + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + int32_t ret = volumeDataMaintainerRet->GetDeviceVolume(deviceType, streamType); + EXPECT_EQ(ret, 0); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: GetAppVolume_001. + * @tc.desc : Test GetAppVolume API. + */ +HWTEST(VolumeDataMaintainerUnitTest, GetAppVolume_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + int32_t appUid = 99999; + int32_t volumeLevel = 1; + volumeDataMaintainerRet->SetAppVolume(appUid, volumeLevel); + int32_t ret = volumeDataMaintainerRet->GetAppVolume(appUid); + EXPECT_NE(ret, 0); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: IsSetAppVolume_001. + * @tc.desc : Test IsSetAppVolume API. + */ +HWTEST(VolumeDataMaintainerUnitTest, IsSetAppVolume_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + int32_t appUid = 99999; + int32_t volumeLevel = 1; + volumeDataMaintainerRet->SetAppVolume(appUid, volumeLevel); + bool ret = volumeDataMaintainerRet->IsSetAppVolume(appUid); + EXPECT_TRUE(ret); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: GetVolumeMap_001. + * @tc.desc : Test GetVolumeMap API. + */ +HWTEST(VolumeDataMaintainerUnitTest, GetVolumeMap_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + int32_t volumeLevel = 10; + volumeDataMaintainerRet->volumeLevelMap_[streamType] = volumeLevel; + auto ret = volumeDataMaintainerRet->GetVolumeMap(); + EXPECT_FALSE(ret.empty()); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: GetMuteStatus_001. + * @tc.desc : Test GetMuteStatus API. + */ +HWTEST(VolumeDataMaintainerUnitTest, GetMuteStatus_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + DeviceType deviceType = DeviceType::DEVICE_TYPE_EARPIECE; + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + std::string networkId = "111"; + bool ret = volumeDataMaintainerRet->GetMuteStatus(deviceType, streamType, networkId); + EXPECT_FALSE(ret); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: SetStreamMuteStatus_001. + * @tc.desc : Test SetStreamMuteStatus API. + */ +HWTEST(VolumeDataMaintainerUnitTest, SetStreamMuteStatus_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + bool muteStatus = false; + bool ret = volumeDataMaintainerRet->SetStreamMuteStatus(streamType, muteStatus); + EXPECT_TRUE(ret); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: GetStreamMute_001. + * @tc.desc : Test GetStreamMute API. + */ +HWTEST(VolumeDataMaintainerUnitTest, GetStreamMute_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + bool muteStatus = false; + volumeDataMaintainerRet->SetStreamMuteStatus(streamType, muteStatus); + bool ret = volumeDataMaintainerRet->GetStreamMute(streamType); + EXPECT_FALSE(ret); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: CheckOsAccountReady_001. + * @tc.desc : Test CheckOsAccountReady API. + */ +HWTEST(VolumeDataMaintainerUnitTest, CheckOsAccountReady_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + bool ret = volumeDataMaintainerRet->CheckOsAccountReady(); + EXPECT_TRUE(ret); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: GetVolumeKeyForDatabaseVolumeName_001. + * @tc.desc : Test GetVolumeKeyForDatabaseVolumeName API. + */ +HWTEST(VolumeDataMaintainerUnitTest, GetVolumeKeyForDatabaseVolumeName_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + std::string databaseVolumeName = "VolumeDataMaintainerUnitTest"; + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + std::string expect = "VolumeDataMaintainerUnitTest_music_volume"; + std::string ret = volumeDataMaintainerRet->GetVolumeKeyForDatabaseVolumeName(databaseVolumeName, streamType); + EXPECT_EQ(ret, expect); + + streamType = AudioStreamType::STREAM_DEFAULT; + expect = ""; + ret = volumeDataMaintainerRet->GetVolumeKeyForDatabaseVolumeName(databaseVolumeName, streamType); + EXPECT_EQ(ret, expect); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: GetMuteKeyForDatabaseVolumeName_001. + * @tc.desc : Test GetMuteKeyForDatabaseVolumeName API. + */ +HWTEST(VolumeDataMaintainerUnitTest, GetMuteKeyForDatabaseVolumeName_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + std::string databaseVolumeName = "VolumeDataMaintainerUnitTest"; + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + std::string expect = "VolumeDataMaintainerUnitTest_music_mute_status"; + std::string ret = volumeDataMaintainerRet->GetMuteKeyForDatabaseVolumeName(databaseVolumeName, streamType); + EXPECT_EQ(ret, expect); + + streamType = AudioStreamType::STREAM_DEFAULT; + expect = ""; + ret = volumeDataMaintainerRet->GetMuteKeyForDatabaseVolumeName(databaseVolumeName, streamType); + EXPECT_EQ(ret, expect); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: SaveVolumeInternal_001. + * @tc.desc : Test SaveVolumeInternal API. + */ +HWTEST(VolumeDataMaintainerUnitTest, SaveVolumeInternal_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + DeviceType type = DeviceType::DEVICE_TYPE_EARPIECE; + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + int32_t volumeLevel = 10; + std::string networkId = "111"; + bool ret = volumeDataMaintainerRet->SaveVolumeInternal(type, streamType, volumeLevel, networkId); + EXPECT_FALSE(ret); + + streamType = AudioStreamType::STREAM_DEFAULT; + ret = volumeDataMaintainerRet->SaveVolumeInternal(type, streamType, volumeLevel, networkId); + EXPECT_FALSE(ret); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: GetVolumeInternal_001. + * @tc.desc : Test GetVolumeInternal API. + */ +HWTEST(VolumeDataMaintainerUnitTest, GetVolumeInternal_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + DeviceType type = DeviceType::DEVICE_TYPE_EARPIECE; + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + std::string networkId = "111"; + bool ret = volumeDataMaintainerRet->GetVolumeInternal(type, streamType, networkId); + EXPECT_FALSE(ret); + + streamType = AudioStreamType::STREAM_DEFAULT; + ret = volumeDataMaintainerRet->GetVolumeInternal(type, streamType, networkId); + EXPECT_FALSE(ret); + + streamType = AudioStreamType::STREAM_VOICE_CALL_ASSISTANT; + ret = volumeDataMaintainerRet->GetVolumeInternal(type, streamType, networkId); + EXPECT_TRUE(ret); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: SetStreamVolumeInternal_001. + * @tc.desc : Test SetStreamVolumeInternal API. + */ +HWTEST(VolumeDataMaintainerUnitTest, SetStreamVolumeInternal_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + int32_t volumeLevel = 10; + volumeDataMaintainerRet->SetStreamVolumeInternal(streamType, volumeLevel); + EXPECT_FALSE(volumeDataMaintainerRet->volumeLevelMap_.empty()); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: GetStreamMuteInternal_001. + * @tc.desc : Test GetStreamMuteInternal API. + */ +HWTEST(VolumeDataMaintainerUnitTest, GetStreamMuteInternal_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + bool ret = volumeDataMaintainerRet->GetStreamMuteInternal(streamType); + EXPECT_FALSE(ret); +} + +/** + * @tc.name : Test VolumeDataMaintainer. + * @tc.number: GetStreamVolumeInternal_001. + * @tc.desc : Test GetStreamVolumeInternal API. + */ +HWTEST(VolumeDataMaintainerUnitTest, GetStreamVolumeInternal_001, TestSize.Level4) +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + int32_t ret = volumeDataMaintainerRet->GetStreamVolumeInternal(streamType); + EXPECT_EQ(ret, 0); +} } // AudioStandardnamespace } // OHOSnamespace -- Gitee