From 68579c814e970fd144569703d7f46cf0fc02e7a7 Mon Sep 17 00:00:00 2001 From: yangliping Date: Fri, 18 Nov 2022 12:39:23 +0800 Subject: [PATCH 1/8] audiostream and audiopolicy unittest case add Signed-off-by: yangliping --- test/BUILD.gn | 2 + test/policy_test/BUILD.gn | 54 +++ .../include/audio_policy_unit_test.h | 59 +++ .../src/audio_policy_unit_test.cpp | 434 ++++++++++++++++++ test/stream_test/BUILD.gn | 37 ++ .../include/audio_stream_unit_test.h | 75 +++ .../src/audio_stream_unit_test.cpp | 250 ++++++++++ 7 files changed, 911 insertions(+) create mode 100644 test/policy_test/BUILD.gn create mode 100644 test/policy_test/include/audio_policy_unit_test.h create mode 100644 test/policy_test/src/audio_policy_unit_test.cpp create mode 100644 test/stream_test/BUILD.gn create mode 100644 test/stream_test/include/audio_stream_unit_test.h create mode 100644 test/stream_test/src/audio_stream_unit_test.cpp diff --git a/test/BUILD.gn b/test/BUILD.gn index e90eac777b..b42b634017 100644 --- a/test/BUILD.gn +++ b/test/BUILD.gn @@ -20,8 +20,10 @@ group("audio_unit_test") { "unittest/manager_test:audio_manager_unit_test", "unittest/opensles_capture_test:audio_opensles_capture_unit_test", "unittest/opensles_test:audio_opensles_unit_test", + "unittest/policy_test:audio_policy_unit_test", "unittest/renderer_test:audio_renderer_unit_test", "unittest/stream_manager_test:audio_stream_manager_unit_test", + "unittest/stream_test:audio_stream_unit_test", "unittest/volume_change_test:audio_volume_change_unit_test", "//foundation/multimedia/audio_framework/services/audio_service/test/unittest:audio_balance_test", ] diff --git a/test/policy_test/BUILD.gn b/test/policy_test/BUILD.gn new file mode 100644 index 0000000000..c28a9ac499 --- /dev/null +++ b/test/policy_test/BUILD.gn @@ -0,0 +1,54 @@ +# Copyright (c) 2021-2022 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. + +import("//build/test.gni") +import("//drivers/hdf_core/adapter/uhdf2/uhdf.gni") + +module_output_path = "multimedia_audio_framework/audio_policy" + +ohos_unittest("audio_policy_unit_test") { + module_out_path = module_output_path + include_dirs = [ + "./include", + "//foundation/multimedia/audio_framework/interfaces/inner_api/native/audiocommon/include", + "//foundation/multimedia/audio_framework/services/audio_policy/client/include", + "//foundation/multimedia/audio_framework/interfaces/inner_api/native/audiomanager/include", + "//foundation/multimedia/audio_framework/frameworks/native/audiostream/include", + "//foundation/multimedia/audio_framework/interfaces/inner_api/native/audiocapturer/include", + "//foundation/multimedia/audio_framework/interfaces/inner_api/native/audiorenderer/include", + "//foundation/systemabilitymgr/samgr/interfaces/innerkits/samgr_proxy/include", + ] + + cflags = [ + "-Wall", + "-Werror", + ] + external_deps = [ + "ability_base:want", + "access_token:libaccesstoken_sdk", + "access_token:libtoken_setproc", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] + sources = [ "src/audio_policy_unit_test.cpp" ] + deps = [ + "//foundation/multimedia/audio_framework/services/audio_policy:audio_policy_client", + "//foundation/multimedia/audio_framework/services/audio_policy:audio_policy_service", + "//foundation/multimedia/audio_framework/services/audio_service:audio_client", + ] +} diff --git a/test/policy_test/include/audio_policy_unit_test.h b/test/policy_test/include/audio_policy_unit_test.h new file mode 100644 index 0000000000..2a3a89529e --- /dev/null +++ b/test/policy_test/include/audio_policy_unit_test.h @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2021-2022 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_CAPTURER_UNIT_TEST_H +#define AUDIO_CAPTURER_UNIT_TEST_H + +#include "gtest/gtest.h" +#include "audio_info.h" +#include "audio_policy_manager.h" +#include "audio_policy_proxy.h" +#include "audio_stream_manager.h" +#include "audio_stream.h" + +namespace OHOS { +namespace AudioStandard { +class AudioManagerDeviceChangeCallbackTest : public AudioManagerDeviceChangeCallback { + virtual void OnDeviceChange(const DeviceChangeAction &deviceChangeAction) {} +}; + +class AudioRendererStateChangeCallbackTest : public AudioRendererStateChangeCallback{ + virtual void OnRendererStateChange( + const std::vector> &audioRendererChangeInfos) {} +}; + +class AudioCapturerStateChangeCallbackTest : public AudioCapturerStateChangeCallback { + virtual void OnCapturerStateChange( + const std::vector> &audioCapturerChangeInfos) {} +}; +class AudioPolicyUnitTest : 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); + static void InitAudioPolicyProxy(std::shared_ptr &audioPolicyProxy); + static void InitAudioStream(std::shared_ptr &audioStream); + static uint32_t GetSessionId(std::shared_ptr &audioStream); + static void GetIRemoteObject(sptr &object); +}; +} // namespace AudioStandard +} // namespace OHOS + +#endif // AUDIO_CAPTURER_UNIT_TEST_H diff --git a/test/policy_test/src/audio_policy_unit_test.cpp b/test/policy_test/src/audio_policy_unit_test.cpp new file mode 100644 index 0000000000..dddba4881d --- /dev/null +++ b/test/policy_test/src/audio_policy_unit_test.cpp @@ -0,0 +1,434 @@ +/* + * Copyright (c) 2021-2022 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 +#include "audio_errors.h" +#include "audio_info.h" +#include "audio_policy_unit_test.h" +#include "iservice_registry.h" +#include "system_ability_definition.h" +#include "audio_system_manager.h" + +using namespace std; +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { +void AudioPolicyUnitTest::SetUpTestCase(void) {} +void AudioPolicyUnitTest::TearDownTestCase(void) {} +void AudioPolicyUnitTest::SetUp(void) {} +void AudioPolicyUnitTest::TearDown(void) {} +void AudioPolicyUnitTest::InitAudioPolicyProxy(std::shared_ptr &audioPolicyProxy) { + auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + if (samgr == nullptr) { + AUDIO_ERR_LOG("AudioSystemManager::init failed"); + return; + } + + sptr object = samgr->GetSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID); + if (object == nullptr) { + AUDIO_DEBUG_LOG("AudioSystemManager::object is NULL."); + return; + } + audioPolicyProxy = std::make_shared(object); +} + +void AudioPolicyUnitTest::GetIRemoteObject(sptr &object) { + auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + if (samgr == nullptr) { + AUDIO_ERR_LOG("AudioSystemManager::init failed"); + return; + } + + object = samgr->GetSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID); + if (object == nullptr) { + AUDIO_DEBUG_LOG("AudioSystemManager::object is NULL."); + return; + } +} + +void AudioPolicyUnitTest::InitAudioStream(std::shared_ptr &audioStream) { + AppInfo appInfo_ = {}; + if (!(appInfo_.appPid)) { + appInfo_.appPid = getpid(); + } + + if (appInfo_.appUid < 0) { + appInfo_.appUid = static_cast(getuid()); + } + + audioStream = std::make_shared(STREAM_NOTIFICATION, AUDIO_MODE_PLAYBACK, appInfo_.appUid); + if (audioStream) { + AUDIO_DEBUG_LOG("AudioRendererPrivate::Audio stream created"); + } +} + +uint32_t AudioPolicyUnitTest::GetSessionId(std::shared_ptr &audioStream){ + uint32_t sessionID_ = static_cast(-1); + if (audioStream->GetAudioSessionID(sessionID_) != 0) { + AUDIO_ERR_LOG("AudioRendererPrivate::GetAudioSessionID Failed"); + } + return sessionID_; +} + +/** +* @tc.name : Test Audio_Policy_SetMicrophoneMuteAudioConfig_001 via illegal state +* @tc.number: Audio_Policy_SetMicrophoneMuteAudioConfig_001 +* @tc.desc : Test SetMicrophoneMuteAudioConfig interface. Returns success. +*/ +HWTEST(AudioPolicyUnitTest, Audio_Policy_SetMicrophoneMuteAudioConfig_001, TestSize.Level1) +{ + std::shared_ptr audioPolicyProxy; + AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy); + ASSERT_NE(nullptr, audioPolicyProxy); + + bool isMute = true; + int32_t ret = audioPolicyProxy->SetMicrophoneMuteAudioConfig(isMute); + EXPECT_EQ(OPEN_PORT_FAILURE, ret); +} + +/** +* @tc.name : Test Audio_Policy_GetSupportedTones_001 via legal state +* @tc.number: Audio_Policy_GetSupportedTones_001 +* @tc.desc : Test GetSupportedTones interface. Returns success. +*/ +HWTEST(AudioPolicyUnitTest, Audio_Policy_GetSupportedTones_001, TestSize.Level1) +{ + std::shared_ptr audioPolicyProxy; + AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy); + ASSERT_NE(nullptr, audioPolicyProxy); + + audioPolicyProxy->GetSupportedTones(); +} + +/** +* @tc.name : Test Audio_Policy_GetToneConfig_001 via legal state +* @tc.number: Audio_Policy_GetToneConfig_001 +* @tc.desc : Test GetToneConfig interface. Returns success. +*/ +HWTEST(AudioPolicyUnitTest, Audio_Policy_GetToneConfig_001, TestSize.Level1) +{ + std::shared_ptr audioPolicyProxy; + AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy); + ASSERT_NE(nullptr, audioPolicyProxy); + + int32_t ltonetype = 0; + std::shared_ptr toneInfo = audioPolicyProxy->GetToneConfig(ltonetype); + ASSERT_NE(nullptr, toneInfo); +} + +/** +* @tc.name : Test Audio_Policy_IsStreamActive_001 via legal state +* @tc.number: Audio_Policy_IsStreamActive_001 +* @tc.desc : Test IsStreamActive interface. Returns success. +*/ +HWTEST(AudioPolicyUnitTest, Audio_Policy_IsStreamActive_001, TestSize.Level1) +{ + std::shared_ptr audioPolicyProxy; + AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy); + ASSERT_NE(nullptr, audioPolicyProxy); + + AudioStreamType streamType = AudioStreamType::STREAM_MUSIC; + bool isStreamActive = audioPolicyProxy->IsStreamActive(streamType); + EXPECT_EQ(false, isStreamActive); +} + +/** +* @tc.name : Test Audio_Policy_SelectInputDevice_001 via illegal state +* @tc.number: Audio_Policy_SelectInputDevice_001 +* @tc.desc : Test SelectInputDevice interface. Returns success. +*/ +HWTEST(AudioPolicyUnitTest, Audio_Policy_SelectInputDevice_001, TestSize.Level1) +{ + std::shared_ptr audioPolicyProxy; + AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy); + ASSERT_NE(nullptr, audioPolicyProxy); + + AudioSystemManager *audioSystemMgr = AudioSystemManager::GetInstance(); + DeviceFlag deviceFlag = DeviceFlag::INPUT_DEVICES_FLAG; + std::vector> audioDeviceDescriptorsVector; + audioDeviceDescriptorsVector = audioSystemMgr->GetDevices(deviceFlag); + + sptr audioCapturerFilter = new(std::nothrow) AudioCapturerFilter(); + audioCapturerFilter->uid = DeviceFlag::INPUT_DEVICES_FLAG; + + int32_t ret = audioPolicyProxy->SelectInputDevice(audioCapturerFilter,audioDeviceDescriptorsVector); + EXPECT_EQ(OPEN_PORT_FAILURE, ret); +} + +/** +* @tc.name : Test Audio_Policy_DeviceChangeCallback_001 via illegal state +* @tc.number: Audio_Policy_DeviceChangeCallback_001 +* @tc.desc : Test SetDeviceChangeCallback and UnsetDeviceChangeCallback interface. Returns success. +*/ +HWTEST(AudioPolicyUnitTest, Audio_Policy_DeviceChangeCallback_001, TestSize.Level1) +{ + std::shared_ptr audioPolicyProxy; + AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy); + ASSERT_NE(nullptr, audioPolicyProxy); + + int32_t clientId = getpid(); + DeviceFlag flag = DeviceFlag::OUTPUT_DEVICES_FLAG; + sptr object; + AudioPolicyUnitTest::GetIRemoteObject(object); + + int32_t ret = audioPolicyProxy->SetDeviceChangeCallback(clientId, flag, object); + EXPECT_EQ(OPEN_PORT_FAILURE, ret); + + ret = audioPolicyProxy->UnsetDeviceChangeCallback(clientId); + EXPECT_EQ(OPEN_PORT_FAILURE, ret); +} + +/** +* @tc.name : Test Audio_Policy_GetStreamInFocus_001 via legal state +* @tc.number: Audio_Policy_GetStreamInFocus_001 +* @tc.desc : Test GetStreamInFocus interface. Returns success. +*/ +HWTEST(AudioPolicyUnitTest, Audio_Policy_GetStreamInFocus_001, TestSize.Level1) +{ + std::shared_ptr audioPolicyProxy; + AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy); + ASSERT_NE(nullptr, audioPolicyProxy); + + audioPolicyProxy->GetStreamInFocus(); +} + +/** +* @tc.name : Test Audio_Policy_IsAudioRendererLowLatencySupported_001 via legal state +* @tc.number: Audio_Policy_IsAudioRendererLowLatencySupported_001 +* @tc.desc : Test IsAudioRendererLowLatencySupported interface. Returns success. +*/ +HWTEST(AudioPolicyUnitTest, Audio_Policy_IsAudioRendererLowLatencySupported_001, TestSize.Level1) +{ + std::shared_ptr audioPolicyProxy; + AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy); + ASSERT_NE(nullptr, audioPolicyProxy); + + AudioStreamInfo audioStreamInfo; + audioStreamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100; + audioStreamInfo.encoding = AudioEncodingType::ENCODING_PCM; + audioStreamInfo.format = AudioSampleFormat::SAMPLE_S16LE; + audioStreamInfo.channels = AudioChannel::MONO; + bool ret = audioPolicyProxy->IsAudioRendererLowLatencySupported(audioStreamInfo); + EXPECT_EQ(true, ret); +} + +/** +* @tc.name : Test Audio_Policy_RegisterAudioRendererEventListener_001 via illegal state +* @tc.number: Audio_Policy_RegisterAudioRendererEventListener_001 +* @tc.desc : Test RegisterAudioRendererEventListener interface. Returns success. +*/ +HWTEST(AudioPolicyUnitTest, Audio_Policy_RegisterAudioRendererEventListener_001, TestSize.Level1) +{ + std::shared_ptr audioPolicyProxy; + AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy); + ASSERT_NE(nullptr, audioPolicyProxy); + + int32_t clientId = getpid(); + sptr object; + AudioPolicyUnitTest::GetIRemoteObject(object); + int32_t ret = audioPolicyProxy->RegisterAudioRendererEventListener(clientId, object); + EXPECT_EQ(ERROR, ret); + + ret = audioPolicyProxy->UnregisterAudioRendererEventListener(clientId); + EXPECT_EQ(ERROR, ret); +} + +/** +* @tc.name : Test Audio_Policy_RegisterAudioCapturerEventListener_001 via illegal state +* @tc.number: Audio_Policy_RegisterAudioCapturerEventListener_001 +* @tc.desc : Test RegisterAudioCapturerEventListener interface. Returns success. +*/ +HWTEST(AudioPolicyUnitTest, Audio_Policy_RegisterAudioCapturerEventListener_001, TestSize.Level1) +{ + std::shared_ptr audioPolicyProxy; + AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy); + ASSERT_NE(nullptr, audioPolicyProxy); + + sptr object; + AudioPolicyUnitTest::GetIRemoteObject(object); + int32_t clientId = getpid(); + + int32_t ret = audioPolicyProxy->RegisterAudioCapturerEventListener(clientId, object); + EXPECT_EQ(ERROR, ret); + + ret = audioPolicyProxy->UnregisterAudioCapturerEventListener(clientId); + EXPECT_EQ(ERROR, ret); +} + +/** +* @tc.name : Test Audio_Policy_Manager_IsStreamActive_001 via illegal state +* @tc.number: Audio_Policy_Manager_IsStreamActive_001 +* @tc.desc : Test RegisterAudioCapturerEventListener interface. Returns success. +*/ +HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_IsStreamActive_001, TestSize.Level1) +{ + bool isStreamActive = AudioPolicyManager::GetInstance().IsStreamActive(AudioStreamType::STREAM_MUSIC); + EXPECT_EQ(false, isStreamActive); +} + +/** +* @tc.name : Test Audio_Policy_Manager_SelectInputDevice_001 via illegal state +* @tc.number: Audio_Policy_Manager_SelectInputDevice_001 +* @tc.desc : Test RegisterAudioCapturerEventListener interface. Returns success. +*/ +HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_SelectInputDevice_001, TestSize.Level1) +{ + AudioSystemManager *audioSystemMgr = AudioSystemManager::GetInstance(); + DeviceFlag deviceFlag = DeviceFlag::INPUT_DEVICES_FLAG; + std::vector> audioDeviceDescriptorsVector; + audioDeviceDescriptorsVector = audioSystemMgr->GetDevices(deviceFlag); + + sptr audioCapturerFilter = new(std::nothrow) AudioCapturerFilter(); + audioCapturerFilter->uid = DeviceFlag::INPUT_DEVICES_FLAG; + + bool isStreamActive = AudioPolicyManager::GetInstance().SelectInputDevice(audioCapturerFilter, audioDeviceDescriptorsVector); + EXPECT_EQ(false, isStreamActive); +} + +/** +* @tc.name : Test Audio_Policy_Manager_SetMicrophoneMuteAudioConfig_001 via legal state +* @tc.number: Audio_Policy_Manager_SetMicrophoneMuteAudioConfig_001 +* @tc.desc : Test SetMicrophoneMuteAudioConfig interface. Returns success. +*/ +HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_SetMicrophoneMuteAudioConfig_001, TestSize.Level1) +{ + bool isMute = true; + bool ret = AudioPolicyManager::GetInstance().SetMicrophoneMuteAudioConfig(isMute); + EXPECT_EQ(SUCCESS, ret); +} + +/** +* @tc.name : Test Audio_Policy_Manager_GetSupportedTones_001 via legal state +* @tc.number: Audio_Policy_Manager_GetSupportedTones_001 +* @tc.desc : Test GetSupportedTones interface. Returns success. +*/ +HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_GetSupportedTones_001, TestSize.Level1) +{ + AudioPolicyManager::GetInstance().GetSupportedTones(); +} + +/** +* @tc.name : Test Audio_Policy_Manager_GetToneConfig_001 via legal state +* @tc.number: Audio_Policy_Manager_GetToneConfig_001 +* @tc.desc : Test GetToneConfig interface. Returns success. +*/ +HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_GetToneConfig_001, TestSize.Level1) +{ + int32_t ltonetype = 0; + std::shared_ptr toneInfo = AudioPolicyManager::GetInstance().GetToneConfig(ltonetype); + ASSERT_NE(nullptr, toneInfo); +} + +/** +* @tc.name : Test Audio_Policy_Manager_SetDeviceChangeCallback_001 via legal state +* @tc.number: Audio_Policy_Manager_SetDeviceChangeCallback_001 +* @tc.desc : Test SetDeviceChangeCallback interface. Returns success. +*/ +HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_SetDeviceChangeCallback_001, TestSize.Level1) +{ + int32_t clientId = getpid(); + DeviceFlag flag = DeviceFlag::OUTPUT_DEVICES_FLAG; + std::shared_ptr callback = std::make_shared(); + + int32_t ret = AudioPolicyManager::GetInstance().SetDeviceChangeCallback(clientId, flag, callback); + EXPECT_EQ(SUCCESS, ret); + + ret = AudioPolicyManager::GetInstance().UnsetDeviceChangeCallback(clientId); + EXPECT_EQ(SUCCESS, ret); +} + +/** +* @tc.name : Test Audio_Policy_Manager_GetStreamInFocus_001 via legal state +* @tc.number: Audio_Policy_Manager_GetStreamInFocus_001 +* @tc.desc : Test GetStreamInFocus interface. Returns success. +*/ +HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_GetStreamInFocus_001, TestSize.Level1) +{ + AudioPolicyManager::GetInstance().GetStreamInFocus(); + //ASSERT_NE(nullptr, streamType); +} + +/** +* @tc.name : Test Audio_Policy_Manager_GetSessionInfoInFocus_001 via legal state +* @tc.number: Audio_Policy_Manager_GetSessionInfoInFocus_001 +* @tc.desc : Test GetSessionInfoInFocus interface. Returns success. +*/ +HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_GetSessionInfoInFocus_001, TestSize.Level1) +{ + AudioInterrupt audioInterrupt; + audioInterrupt.contentType = CONTENT_TYPE_RINGTONE; + audioInterrupt.streamUsage = STREAM_USAGE_NOTIFICATION_RINGTONE; + audioInterrupt.streamType = STREAM_ACCESSIBILITY; + + std::shared_ptr audioStream; + AudioPolicyUnitTest::InitAudioStream(audioStream); + ASSERT_NE(nullptr, audioStream); + + uint32_t sessionID_ = AudioPolicyUnitTest::GetSessionId(audioStream); + audioInterrupt.sessionID = sessionID_; + int32_t ret = AudioPolicyManager::GetInstance().GetSessionInfoInFocus(audioInterrupt); + EXPECT_EQ(SUCCESS, ret); +} + +/** +* @tc.name : Test Audio_Policy_Manager_RegisterAudioRendererEventListener_001 via legal state +* @tc.number: Audio_Policy_Manager_RegisterAudioRendererEventListener_001 +* @tc.desc : Test registerAudioRendererEventListener interface. Returns success. +*/ +HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_RegisterAudioRendererEventListener_001, TestSize.Level1) +{ + int32_t clientId = getpid(); + std::shared_ptr callback = std::make_shared(); + int32_t ret = AudioPolicyManager::GetInstance().RegisterAudioRendererEventListener(clientId, callback); + EXPECT_EQ(SUCCESS, ret); + + ret = AudioPolicyManager::GetInstance().UnregisterAudioRendererEventListener(clientId); + EXPECT_EQ(SUCCESS, ret); +} + +/** +* @tc.name : Test Audio_Policy_Manager_RegisterAudioCapturerEventListener_001 via legal state +* @tc.number: Audio_Policy_Manager_RegisterAudioCapturerEventListener_001 +* @tc.desc : Test RegisterAudioCapturerEventListener interface. Returns success. +*/ +HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_RegisterAudioCapturerEventListener_001, TestSize.Level1) +{ + int32_t clientId = getpid(); + std::shared_ptr callback = std::make_shared(); + int32_t ret = AudioPolicyManager::GetInstance().RegisterAudioCapturerEventListener(clientId, callback); + EXPECT_EQ(SUCCESS, ret); + + ret = AudioPolicyManager::GetInstance().UnregisterAudioCapturerEventListener(clientId); + EXPECT_EQ(SUCCESS, ret); +} + +/** +* @tc.name : Test Audio_Policy_Manager_IsAudioRendererLowLatencySupported_001 via legal state +* @tc.number: Audio_Policy_Manager_IsAudioRendererLowLatencySupported_001 +* @tc.desc : Test IsAudioRendererLowLatencySupported interface. Returns success. +*/ +HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_IsAudioRendererLowLatencySupported_001, TestSize.Level1) +{ + AudioStreamInfo audioStreamInfo; + audioStreamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100; + audioStreamInfo.encoding = AudioEncodingType::ENCODING_PCM; + audioStreamInfo.format = AudioSampleFormat::SAMPLE_S16LE; + audioStreamInfo.channels = AudioChannel::MONO; + bool ret = AudioPolicyManager::GetInstance().IsAudioRendererLowLatencySupported(audioStreamInfo); + EXPECT_EQ(true, ret); +} +} // namespace AudioStandard +} // namespace OHOS \ No newline at end of file diff --git a/test/stream_test/BUILD.gn b/test/stream_test/BUILD.gn new file mode 100644 index 0000000000..0e3e037937 --- /dev/null +++ b/test/stream_test/BUILD.gn @@ -0,0 +1,37 @@ +# Copyright (c) 2021-2022 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. + +import("//build/ohos.gni") +import("//build/ohos/ace/ace.gni") +import("//build/test.gni") +import("//drivers/hdf_core/adapter/uhdf2/uhdf.gni") +import("//foundation/multimedia/audio_framework/multimedia_aafwk.gni") + +module_output_path = "multimedia_audio_framework/audio_stream" + +ohos_unittest("audio_stream_unit_test") { + module_out_path = module_output_path + include_dirs = [ + "./include", + "//foundation/multimedia/audio_framework/interfaces/inner_api/native/audiocommon/include", + "//foundation/multimedia/audio_framework/frameworks/native/audiostream/include", + ] + + cflags = [ + "-Wall", + "-Werror", + ] + external_deps = [ "hiviewdfx_hilog_native:libhilog" ] + sources = [ "src/audio_stream_unit_test.cpp" ] + deps = [ "//foundation/multimedia/audio_framework/services/audio_service:audio_client" ] +} diff --git a/test/stream_test/include/audio_stream_unit_test.h b/test/stream_test/include/audio_stream_unit_test.h new file mode 100644 index 0000000000..eb9af2094c --- /dev/null +++ b/test/stream_test/include/audio_stream_unit_test.h @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2021-2022 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_CAPTURER_UNIT_TEST_H +#define AUDIO_CAPTURER_UNIT_TEST_H + +#include "gtest/gtest.h" +#include "audio_stream.h" +#include "audio_info.h" + +namespace OHOS { +namespace AudioStandard { +class RenderCallbackTest : public AudioRendererCallbacks { +public: + void OnSinkDeviceUpdatedCb() const + { + AUDIO_INFO_LOG("render callback OnSinkDeviceUpdatedCb"); + } + virtual void OnStreamStateChangeCb() const + { + AUDIO_INFO_LOG("render callback OnStreamStateChangeCb"); + } + + virtual void OnStreamBufferUnderFlowCb() const {} + virtual void OnStreamBufferOverFlowCb() const {} + virtual void OnErrorCb(AudioServiceErrorCodes error) const {} + virtual void OnEventCb(AudioServiceEventTypes error) const {} +}; + +class CapturterCallbackTest : public AudioCapturerCallbacks { +public: + void OnSourceDeviceUpdatedCb() const + { + AUDIO_INFO_LOG("captuer callback OnSourceDeviceUpdatedCb"); + } + // Need to check required state changes to update applications + virtual void OnStreamStateChangeCb() const + { + AUDIO_INFO_LOG("captuer callback OnStreamStateChangeCb"); + } + + virtual void OnStreamBufferUnderFlowCb() const {} + virtual void OnStreamBufferOverFlowCb() const {} + virtual void OnErrorCb(AudioServiceErrorCodes error) const {} + virtual void OnEventCb(AudioServiceEventTypes error) const {} +}; + +class AudioStreamUnitTest : 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); + static void InitAudioStream(std::shared_ptr &audioStream); +}; +} // namespace AudioStandard +} // namespace OHOS + +#endif // AUDIO_CAPTURER_UNIT_TEST_H diff --git a/test/stream_test/src/audio_stream_unit_test.cpp b/test/stream_test/src/audio_stream_unit_test.cpp new file mode 100644 index 0000000000..9b32e4ea59 --- /dev/null +++ b/test/stream_test/src/audio_stream_unit_test.cpp @@ -0,0 +1,250 @@ +/* + * Copyright (c) 2021-2022 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 +#include "audio_errors.h" +#include "audio_info.h" +#include "audio_stream_unit_test.h" + +using namespace std; +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { +const uint32_t DEFAULT_SAMPLING_RATE = 44100; +const uint8_t DEFAULT_CHANNEL_COUNT = 2; +const uint8_t DEFAULT_SAMPLE_SIZE = 2; +const uint32_t DEFAULT_STREAM_VOLUME = 0; +void AudioStreamUnitTest::SetUpTestCase(void) {} +void AudioStreamUnitTest::TearDownTestCase(void) {} +void AudioStreamUnitTest::SetUp(void) {} +void AudioStreamUnitTest::TearDown(void) {} + +void AudioStreamUnitTest::InitAudioStream(std::shared_ptr &audioStream){ + AppInfo appInfo_ = {}; + if (!(appInfo_.appPid)) { + appInfo_.appPid = getpid(); + } + + if (appInfo_.appUid < 0) { + appInfo_.appUid = static_cast(getuid()); + } + + audioStream = std::make_shared(STREAM_NOTIFICATION, AUDIO_MODE_PLAYBACK, appInfo_.appUid); + if (audioStream) { + AUDIO_DEBUG_LOG("AudioRendererPrivate::Audio stream created"); + } +} + +/** +* @tc.name : Test Audio_Stream_GetSamplingRate_001 via legal state +* @tc.number: Audio_Stream_GetSamplingRate_001 +* @tc.desc : Test GetSamplingRate interface. Returns success. +*/ +HWTEST(AudioStreamUnitTest, Audio_Stream_GetSamplingRate_001, TestSize.Level1) +{ + std::shared_ptr audioStream_; + AudioStreamUnitTest::InitAudioStream(audioStream_); + uint32_t samplingRate = audioStream_->GetSamplingRate(); + EXPECT_EQ(DEFAULT_SAMPLING_RATE, samplingRate); +} + +/** +* @tc.name : Test Audio_Stream_GetChannelCount_001 via legal state +* @tc.number: Audio_Stream_GetChannelCount_001 +* @tc.desc : Test GetChannelCount interface. Returns success. +*/ +HWTEST(AudioStreamUnitTest, Audio_Stream_GetChannelCount_001, TestSize.Level1) +{ + std::shared_ptr audioStream_; + AudioStreamUnitTest::InitAudioStream(audioStream_); + uint8_t channelCount = audioStream_->GetChannelCount(); + EXPECT_EQ(DEFAULT_CHANNEL_COUNT, channelCount); +} + +/** +* @tc.name : Test Audio_Stream_GetSampleSize_001 via legal state +* @tc.number: Audio_Stream_GetSampleSize_001 +* @tc.desc : Test GetSampleSize interface. Returns success. +*/ +HWTEST(AudioStreamUnitTest, Audio_Stream_GetSampleSize_001, TestSize.Level1) +{ + std::shared_ptr audioStream_; + AudioStreamUnitTest::InitAudioStream(audioStream_); + uint8_t sampleSize = audioStream_->GetSampleSize(); + EXPECT_EQ(DEFAULT_SAMPLE_SIZE, sampleSize); +} + +/** +* @tc.name : Test Audio_Stream_GetStreamVolume_001 via legal state +* @tc.number: Audio_Stream_GetStreamVolume_001 +* @tc.desc : Test GetStreamVolume interface. Returns success. +*/ +HWTEST(AudioStreamUnitTest, Audio_Stream_GetStreamVolume_001, TestSize.Level1) +{ + std::shared_ptr audioStream_; + AudioStreamUnitTest::InitAudioStream(audioStream_); + uint32_t sessionID = 0; + uint8_t streamVolume = audioStream_->GetStreamVolume(sessionID); + EXPECT_EQ(DEFAULT_STREAM_VOLUME, streamVolume); +} + +/** +* @tc.name : Test Audio_Stream_RegisterAudioRendererCallbacks_001 via legal state +* @tc.number: Audio_Stream_RegisterAudioRendererCallbacks_001 +* @tc.desc : Test RegisterAudioRendererCallbacks interface. Returns success. +*/ +HWTEST(AudioStreamUnitTest, Audio_Stream_RegisterAudioRendererCallbacks_001, TestSize.Level1) +{ + std::shared_ptr audioStream_; + AudioStreamUnitTest::InitAudioStream(audioStream_); + RenderCallbackTest renderCallback; + audioStream_->RegisterAudioRendererCallbacks(renderCallback); +} + +/** +* @tc.name : Test Audio_Stream_RegisterAudioCapturerCallbacks_001 via legal state +* @tc.number: Audio_Stream_RegisterAudioCapturerCallbacks_001 +* @tc.desc : Test RegisterAudioCapturerCallbacks interface. Returns success. +*/ +HWTEST(AudioStreamUnitTest, Audio_Stream_RegisterAudioCapturerCallbacks_001, TestSize.Level1) +{ + std::shared_ptr audioStream_; + AudioStreamUnitTest::InitAudioStream(audioStream_); + CapturterCallbackTest capturerCallback; + audioStream_->RegisterAudioCapturerCallbacks(capturerCallback); +} + +/** +* @tc.name : Test Audio_Stream_SetStreamType_001 via illegal state +* @tc.number: Audio_Stream_SetStreamType_001 +* @tc.desc : Test SetStreamType interface. Returns success. +*/ +HWTEST(AudioStreamUnitTest, Audio_Stream_SetStreamType_001, TestSize.Level1) +{ + std::shared_ptr audioStream_; + AudioStreamUnitTest::InitAudioStream(audioStream_); + AudioStreamType audioStreamType = AudioStreamType::STREAM_MEDIA; + int32_t ret = audioStream_->SetStreamType(audioStreamType); + EXPECT_EQ(OPEN_PORT_FAILURE, ret); +} + +/** +* @tc.name : Test Audio_Stream_GetStreamRenderRate_001 via legal state +* @tc.number: Audio_Stream_GetStreamRenderRate_001 +* @tc.desc : Test GetStreamRenderRate interface. Returns success. +*/ +HWTEST(AudioStreamUnitTest, Audio_Stream_GetStreamRenderRate_001, TestSize.Level1) +{ + std::shared_ptr audioStream_; + AudioStreamUnitTest::InitAudioStream(audioStream_); + AudioRendererRate renderRate = audioStream_->GetStreamRenderRate(); + EXPECT_EQ(AudioRendererRate::RENDER_RATE_NORMAL, renderRate); +} + +/** +* @tc.name : Test Audio_Stream_GetSupportedFormats_001 via legal state +* @tc.number: Audio_Stream_GetSupportedFormats_001 +* @tc.desc : Test GetSupportedFormats interface. Returns success. +*/ +HWTEST(AudioStreamUnitTest, Audio_Stream_GetSupportedFormats_001, TestSize.Level1) +{ + std::shared_ptr audioStream_; + AudioStreamUnitTest::InitAudioStream(audioStream_); + vector supportedFormatList = audioStream_->GetSupportedFormats(); + EXPECT_EQ(AUDIO_SUPPORTED_FORMATS.size(), supportedFormatList.size()); +} + +/** +* @tc.name : Test Audio_Stream_GetSupportedEncodingTypes_001 via legal state +* @tc.number: Audio_Stream_GetSupportedEncodingTypes_001 +* @tc.desc : Test GetSupportedEncodingTypes interface. Returns success. +*/ +HWTEST(AudioStreamUnitTest, Audio_Stream_GetSupportedEncodingTypes_001, TestSize.Level1) +{ + std::shared_ptr audioStream_; + AudioStreamUnitTest::InitAudioStream(audioStream_); + vector supportedEncodingTypes = audioStream_->GetSupportedEncodingTypes(); + EXPECT_EQ(AUDIO_SUPPORTED_ENCODING_TYPES.size(), supportedEncodingTypes.size()); +} + +/** +* @tc.name : Test Audio_Stream_GetSupportedSamplingRates_001 via legal state +* @tc.number: Audio_Stream_GetSupportedSamplingRates_001 +* @tc.desc : Test GetSupportedSamplingRates interface. Returns success. +*/ +HWTEST(AudioStreamUnitTest, Audio_Stream_GetSupportedSamplingRates_001, TestSize.Level1) +{ + std::shared_ptr audioStream_; + AudioStreamUnitTest::InitAudioStream(audioStream_); + vector supportedSamplingRates = audioStream_->GetSupportedSamplingRates(); + EXPECT_EQ(AUDIO_SUPPORTED_SAMPLING_RATES.size(), supportedSamplingRates.size()); +} + +/** +* @tc.name : Test Audio_Stream_SetAudioStreamType_001 via illegal state +* @tc.number: Audio_Stream_SetAudioStreamType_001 +* @tc.desc : Test SetAudioStreamType interface. Returns success. +*/ +HWTEST(AudioStreamUnitTest, Audio_Stream_SetAudioStreamType_001, TestSize.Level1) +{ + std::shared_ptr audioStream_; + AudioStreamUnitTest::InitAudioStream(audioStream_); + AudioStreamType audioStreamType = AudioStreamType::STREAM_RING; + int32_t ret = audioStream_->SetAudioStreamType(audioStreamType); + EXPECT_EQ(OPEN_PORT_FAILURE, ret); +} + +/** +* @tc.name : Test Audio_Stream_SetRenderRate_001 via legal state +* @tc.number: Audio_Stream_SetRenderRate_001 +* @tc.desc : Test SetRenderRate interface. Returns success. +*/ +HWTEST(AudioStreamUnitTest, Audio_Stream_SetRenderRate_001, TestSize.Level1) +{ + std::shared_ptr audioStream_; + AudioStreamUnitTest::InitAudioStream(audioStream_); + AudioRendererRate renderRate = AudioRendererRate::RENDER_RATE_NORMAL; + int32_t ret = audioStream_->SetRenderRate(renderRate); + EXPECT_EQ(SUCCESS, ret); +} + +/** +* @tc.name : Test Audio_Stream_GetRenderRate_001 via legal state +* @tc.number: Audio_Stream_GetRenderRate_001 +* @tc.desc : Test GetRenderRate interface. Returns success. +*/ +HWTEST(AudioStreamUnitTest, Audio_Stream_GetRenderRate_001, TestSize.Level1) +{ + std::shared_ptr audioStream_; + AudioStreamUnitTest::InitAudioStream(audioStream_); + AudioRendererRate renderRate = audioStream_->GetRenderRate(); + EXPECT_EQ(renderRate, AudioRendererRate::RENDER_RATE_NORMAL); +} + +/** +* @tc.name : Test Audio_Stream_GetCaptureMode_001 via legal state +* @tc.number: Audio_Stream_GetCaptureMode_001 +* @tc.desc : Test GetCaptureMode interface. Returns success. +*/ +HWTEST(AudioStreamUnitTest, Audio_Stream_GetCaptureMode_001, TestSize.Level1) +{ + std::shared_ptr audioStream_; + AudioStreamUnitTest::InitAudioStream(audioStream_); + AudioCaptureMode captureMode = audioStream_->GetCaptureMode(); + EXPECT_EQ(captureMode, AudioCaptureMode::CAPTURE_MODE_NORMAL); +} +} // namespace AudioStandard +} // namespace OHOS \ No newline at end of file -- Gitee From 2fbcce3594c2a21dafd04099f946336d5de5d39f Mon Sep 17 00:00:00 2001 From: yangliping Date: Fri, 18 Nov 2022 15:13:33 +0800 Subject: [PATCH 2/8] tdd test case Signed-off-by: yangliping --- .../include/audio_policy_unit_test.h | 4 +-- .../src/audio_policy_unit_test.cpp | 31 ++++++++++++------- .../include/audio_stream_unit_test.h | 2 +- .../src/audio_stream_unit_test.cpp | 5 +-- 4 files changed, 25 insertions(+), 17 deletions(-) diff --git a/test/policy_test/include/audio_policy_unit_test.h b/test/policy_test/include/audio_policy_unit_test.h index 2a3a89529e..f10c30fbc7 100644 --- a/test/policy_test/include/audio_policy_unit_test.h +++ b/test/policy_test/include/audio_policy_unit_test.h @@ -29,14 +29,14 @@ class AudioManagerDeviceChangeCallbackTest : public AudioManagerDeviceChangeCall virtual void OnDeviceChange(const DeviceChangeAction &deviceChangeAction) {} }; -class AudioRendererStateChangeCallbackTest : public AudioRendererStateChangeCallback{ +class AudioRendererStateChangeCallbackTest : public AudioRendererStateChangeCallback { virtual void OnRendererStateChange( const std::vector> &audioRendererChangeInfos) {} }; class AudioCapturerStateChangeCallbackTest : public AudioCapturerStateChangeCallback { virtual void OnCapturerStateChange( - const std::vector> &audioCapturerChangeInfos) {} + const std::vector> &audioCapturerChangeInfos) {} }; class AudioPolicyUnitTest : public testing::Test { public: diff --git a/test/policy_test/src/audio_policy_unit_test.cpp b/test/policy_test/src/audio_policy_unit_test.cpp index dddba4881d..d22deacccf 100644 --- a/test/policy_test/src/audio_policy_unit_test.cpp +++ b/test/policy_test/src/audio_policy_unit_test.cpp @@ -17,9 +17,9 @@ #include "audio_errors.h" #include "audio_info.h" #include "audio_policy_unit_test.h" +#include "audio_system_manager.h" #include "iservice_registry.h" #include "system_ability_definition.h" -#include "audio_system_manager.h" using namespace std; using namespace testing::ext; @@ -30,7 +30,8 @@ void AudioPolicyUnitTest::SetUpTestCase(void) {} void AudioPolicyUnitTest::TearDownTestCase(void) {} void AudioPolicyUnitTest::SetUp(void) {} void AudioPolicyUnitTest::TearDown(void) {} -void AudioPolicyUnitTest::InitAudioPolicyProxy(std::shared_ptr &audioPolicyProxy) { +void AudioPolicyUnitTest::InitAudioPolicyProxy(std::shared_ptr &audioPolicyProxy) +{ auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); if (samgr == nullptr) { AUDIO_ERR_LOG("AudioSystemManager::init failed"); @@ -45,7 +46,8 @@ void AudioPolicyUnitTest::InitAudioPolicyProxy(std::shared_ptr audioPolicyProxy = std::make_shared(object); } -void AudioPolicyUnitTest::GetIRemoteObject(sptr &object) { +void AudioPolicyUnitTest::GetIRemoteObject(sptr &object) +{ auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); if (samgr == nullptr) { AUDIO_ERR_LOG("AudioSystemManager::init failed"); @@ -59,7 +61,8 @@ void AudioPolicyUnitTest::GetIRemoteObject(sptr &object) { } } -void AudioPolicyUnitTest::InitAudioStream(std::shared_ptr &audioStream) { +void AudioPolicyUnitTest::InitAudioStream(std::shared_ptr &audioStream) +{ AppInfo appInfo_ = {}; if (!(appInfo_.appPid)) { appInfo_.appPid = getpid(); @@ -75,7 +78,8 @@ void AudioPolicyUnitTest::InitAudioStream(std::shared_ptr &audioStr } } -uint32_t AudioPolicyUnitTest::GetSessionId(std::shared_ptr &audioStream){ +uint32_t AudioPolicyUnitTest::GetSessionId(std::shared_ptr &audioStream) +{ uint32_t sessionID_ = static_cast(-1); if (audioStream->GetAudioSessionID(sessionID_) != 0) { AUDIO_ERR_LOG("AudioRendererPrivate::GetAudioSessionID Failed"); @@ -164,7 +168,7 @@ HWTEST(AudioPolicyUnitTest, Audio_Policy_SelectInputDevice_001, TestSize.Level1) sptr audioCapturerFilter = new(std::nothrow) AudioCapturerFilter(); audioCapturerFilter->uid = DeviceFlag::INPUT_DEVICES_FLAG; - int32_t ret = audioPolicyProxy->SelectInputDevice(audioCapturerFilter,audioDeviceDescriptorsVector); + int32_t ret = audioPolicyProxy->SelectInputDevice(audioCapturerFilter, audioDeviceDescriptorsVector); EXPECT_EQ(OPEN_PORT_FAILURE, ret); } @@ -294,7 +298,8 @@ HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_SelectInputDevice_001, TestSize sptr audioCapturerFilter = new(std::nothrow) AudioCapturerFilter(); audioCapturerFilter->uid = DeviceFlag::INPUT_DEVICES_FLAG; - bool isStreamActive = AudioPolicyManager::GetInstance().SelectInputDevice(audioCapturerFilter, audioDeviceDescriptorsVector); + bool isStreamActive = AudioPolicyManager::GetInstance().SelectInputDevice(audioCapturerFilter, + audioDeviceDescriptorsVector); EXPECT_EQ(false, isStreamActive); } @@ -341,7 +346,8 @@ HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_SetDeviceChangeCallback_001, Te { int32_t clientId = getpid(); DeviceFlag flag = DeviceFlag::OUTPUT_DEVICES_FLAG; - std::shared_ptr callback = std::make_shared(); + std::shared_ptr callback = + std::make_shared(); int32_t ret = AudioPolicyManager::GetInstance().SetDeviceChangeCallback(clientId, flag, callback); EXPECT_EQ(SUCCESS, ret); @@ -358,7 +364,6 @@ HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_SetDeviceChangeCallback_001, Te HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_GetStreamInFocus_001, TestSize.Level1) { AudioPolicyManager::GetInstance().GetStreamInFocus(); - //ASSERT_NE(nullptr, streamType); } /** @@ -391,7 +396,8 @@ HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_GetSessionInfoInFocus_001, Test HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_RegisterAudioRendererEventListener_001, TestSize.Level1) { int32_t clientId = getpid(); - std::shared_ptr callback = std::make_shared(); + std::shared_ptr callback = + std::make_shared(); int32_t ret = AudioPolicyManager::GetInstance().RegisterAudioRendererEventListener(clientId, callback); EXPECT_EQ(SUCCESS, ret); @@ -407,7 +413,8 @@ HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_RegisterAudioRendererEventListe HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_RegisterAudioCapturerEventListener_001, TestSize.Level1) { int32_t clientId = getpid(); - std::shared_ptr callback = std::make_shared(); + std::shared_ptr callback = + std::make_shared(); int32_t ret = AudioPolicyManager::GetInstance().RegisterAudioCapturerEventListener(clientId, callback); EXPECT_EQ(SUCCESS, ret); @@ -431,4 +438,4 @@ HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_IsAudioRendererLowLatencySuppor EXPECT_EQ(true, ret); } } // namespace AudioStandard -} // namespace OHOS \ No newline at end of file +} // namespace OHOS \ No newline at end of file diff --git a/test/stream_test/include/audio_stream_unit_test.h b/test/stream_test/include/audio_stream_unit_test.h index eb9af2094c..14383f584f 100644 --- a/test/stream_test/include/audio_stream_unit_test.h +++ b/test/stream_test/include/audio_stream_unit_test.h @@ -17,8 +17,8 @@ #define AUDIO_CAPTURER_UNIT_TEST_H #include "gtest/gtest.h" -#include "audio_stream.h" #include "audio_info.h" +#include "audio_stream.h" namespace OHOS { namespace AudioStandard { diff --git a/test/stream_test/src/audio_stream_unit_test.cpp b/test/stream_test/src/audio_stream_unit_test.cpp index 9b32e4ea59..c0b11c8b74 100644 --- a/test/stream_test/src/audio_stream_unit_test.cpp +++ b/test/stream_test/src/audio_stream_unit_test.cpp @@ -32,7 +32,8 @@ void AudioStreamUnitTest::TearDownTestCase(void) {} void AudioStreamUnitTest::SetUp(void) {} void AudioStreamUnitTest::TearDown(void) {} -void AudioStreamUnitTest::InitAudioStream(std::shared_ptr &audioStream){ +void AudioStreamUnitTest::InitAudioStream(std::shared_ptr &audioStream) +{ AppInfo appInfo_ = {}; if (!(appInfo_.appPid)) { appInfo_.appPid = getpid(); @@ -247,4 +248,4 @@ HWTEST(AudioStreamUnitTest, Audio_Stream_GetCaptureMode_001, TestSize.Level1) EXPECT_EQ(captureMode, AudioCaptureMode::CAPTURE_MODE_NORMAL); } } // namespace AudioStandard -} // namespace OHOS \ No newline at end of file +} // namespace OHOS \ No newline at end of file -- Gitee From 93c02125971e7ce9b69a7b16e2ad48e5abbb5a9e Mon Sep 17 00:00:00 2001 From: yangliping Date: Fri, 18 Nov 2022 16:31:25 +0800 Subject: [PATCH 3/8] tdd test case Signed-off-by: yangliping --- test/{ => unittest}/policy_test/BUILD.gn | 0 .../policy_test/include/audio_policy_unit_test.h | 0 .../policy_test/src/audio_policy_unit_test.cpp | 7 ++++--- test/{ => unittest}/stream_test/BUILD.gn | 0 .../stream_test/include/audio_stream_unit_test.h | 0 .../stream_test/src/audio_stream_unit_test.cpp | 3 ++- 6 files changed, 6 insertions(+), 4 deletions(-) rename test/{ => unittest}/policy_test/BUILD.gn (100%) rename test/{ => unittest}/policy_test/include/audio_policy_unit_test.h (100%) rename test/{ => unittest}/policy_test/src/audio_policy_unit_test.cpp (99%) rename test/{ => unittest}/stream_test/BUILD.gn (100%) rename test/{ => unittest}/stream_test/include/audio_stream_unit_test.h (100%) rename test/{ => unittest}/stream_test/src/audio_stream_unit_test.cpp (99%) diff --git a/test/policy_test/BUILD.gn b/test/unittest/policy_test/BUILD.gn similarity index 100% rename from test/policy_test/BUILD.gn rename to test/unittest/policy_test/BUILD.gn diff --git a/test/policy_test/include/audio_policy_unit_test.h b/test/unittest/policy_test/include/audio_policy_unit_test.h similarity index 100% rename from test/policy_test/include/audio_policy_unit_test.h rename to test/unittest/policy_test/include/audio_policy_unit_test.h diff --git a/test/policy_test/src/audio_policy_unit_test.cpp b/test/unittest/policy_test/src/audio_policy_unit_test.cpp similarity index 99% rename from test/policy_test/src/audio_policy_unit_test.cpp rename to test/unittest/policy_test/src/audio_policy_unit_test.cpp index d22deacccf..ba5cfa5fe3 100644 --- a/test/policy_test/src/audio_policy_unit_test.cpp +++ b/test/unittest/policy_test/src/audio_policy_unit_test.cpp @@ -26,6 +26,7 @@ using namespace testing::ext; namespace OHOS { namespace AudioStandard { +const int32_t ERROR = -1; void AudioPolicyUnitTest::SetUpTestCase(void) {} void AudioPolicyUnitTest::TearDownTestCase(void) {} void AudioPolicyUnitTest::SetUp(void) {} @@ -169,7 +170,7 @@ HWTEST(AudioPolicyUnitTest, Audio_Policy_SelectInputDevice_001, TestSize.Level1) audioCapturerFilter->uid = DeviceFlag::INPUT_DEVICES_FLAG; int32_t ret = audioPolicyProxy->SelectInputDevice(audioCapturerFilter, audioDeviceDescriptorsVector); - EXPECT_EQ(OPEN_PORT_FAILURE, ret); + EXPECT_EQ(ERROR, ret); } /** @@ -189,10 +190,10 @@ HWTEST(AudioPolicyUnitTest, Audio_Policy_DeviceChangeCallback_001, TestSize.Leve AudioPolicyUnitTest::GetIRemoteObject(object); int32_t ret = audioPolicyProxy->SetDeviceChangeCallback(clientId, flag, object); - EXPECT_EQ(OPEN_PORT_FAILURE, ret); + EXPECT_EQ(ERROR, ret); ret = audioPolicyProxy->UnsetDeviceChangeCallback(clientId); - EXPECT_EQ(OPEN_PORT_FAILURE, ret); + EXPECT_EQ(ERROR, ret); } /** diff --git a/test/stream_test/BUILD.gn b/test/unittest/stream_test/BUILD.gn similarity index 100% rename from test/stream_test/BUILD.gn rename to test/unittest/stream_test/BUILD.gn diff --git a/test/stream_test/include/audio_stream_unit_test.h b/test/unittest/stream_test/include/audio_stream_unit_test.h similarity index 100% rename from test/stream_test/include/audio_stream_unit_test.h rename to test/unittest/stream_test/include/audio_stream_unit_test.h diff --git a/test/stream_test/src/audio_stream_unit_test.cpp b/test/unittest/stream_test/src/audio_stream_unit_test.cpp similarity index 99% rename from test/stream_test/src/audio_stream_unit_test.cpp rename to test/unittest/stream_test/src/audio_stream_unit_test.cpp index c0b11c8b74..d6415af3e4 100644 --- a/test/stream_test/src/audio_stream_unit_test.cpp +++ b/test/unittest/stream_test/src/audio_stream_unit_test.cpp @@ -23,6 +23,7 @@ using namespace testing::ext; namespace OHOS { namespace AudioStandard { +const int32_t ERROR = -1; const uint32_t DEFAULT_SAMPLING_RATE = 44100; const uint8_t DEFAULT_CHANNEL_COUNT = 2; const uint8_t DEFAULT_SAMPLE_SIZE = 2; @@ -139,7 +140,7 @@ HWTEST(AudioStreamUnitTest, Audio_Stream_SetStreamType_001, TestSize.Level1) AudioStreamUnitTest::InitAudioStream(audioStream_); AudioStreamType audioStreamType = AudioStreamType::STREAM_MEDIA; int32_t ret = audioStream_->SetStreamType(audioStreamType); - EXPECT_EQ(OPEN_PORT_FAILURE, ret); + EXPECT_EQ(ERROR, ret); } /** -- Gitee From 3076e3375301cd60d8c1179c57daa4413afb0b18 Mon Sep 17 00:00:00 2001 From: yangliping Date: Fri, 18 Nov 2022 16:43:49 +0800 Subject: [PATCH 4/8] tdd test case add Signed-off-by: yangliping --- .../policy_test/src/audio_policy_unit_test.cpp | 10 +++++----- .../stream_test/src/audio_stream_unit_test.cpp | 6 +++--- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/test/unittest/policy_test/src/audio_policy_unit_test.cpp b/test/unittest/policy_test/src/audio_policy_unit_test.cpp index ba5cfa5fe3..abb32c3e01 100644 --- a/test/unittest/policy_test/src/audio_policy_unit_test.cpp +++ b/test/unittest/policy_test/src/audio_policy_unit_test.cpp @@ -26,7 +26,7 @@ using namespace testing::ext; namespace OHOS { namespace AudioStandard { -const int32_t ERROR = -1; +const int32_t FAILURE = -1; void AudioPolicyUnitTest::SetUpTestCase(void) {} void AudioPolicyUnitTest::TearDownTestCase(void) {} void AudioPolicyUnitTest::SetUp(void) {} @@ -101,7 +101,7 @@ HWTEST(AudioPolicyUnitTest, Audio_Policy_SetMicrophoneMuteAudioConfig_001, TestS bool isMute = true; int32_t ret = audioPolicyProxy->SetMicrophoneMuteAudioConfig(isMute); - EXPECT_EQ(OPEN_PORT_FAILURE, ret); + EXPECT_EQ(FAILURE, ret); } /** @@ -170,7 +170,7 @@ HWTEST(AudioPolicyUnitTest, Audio_Policy_SelectInputDevice_001, TestSize.Level1) audioCapturerFilter->uid = DeviceFlag::INPUT_DEVICES_FLAG; int32_t ret = audioPolicyProxy->SelectInputDevice(audioCapturerFilter, audioDeviceDescriptorsVector); - EXPECT_EQ(ERROR, ret); + EXPECT_EQ(FAILURE, ret); } /** @@ -190,10 +190,10 @@ HWTEST(AudioPolicyUnitTest, Audio_Policy_DeviceChangeCallback_001, TestSize.Leve AudioPolicyUnitTest::GetIRemoteObject(object); int32_t ret = audioPolicyProxy->SetDeviceChangeCallback(clientId, flag, object); - EXPECT_EQ(ERROR, ret); + EXPECT_EQ(FAILURE, ret); ret = audioPolicyProxy->UnsetDeviceChangeCallback(clientId); - EXPECT_EQ(ERROR, ret); + EXPECT_EQ(FAILURE, ret); } /** diff --git a/test/unittest/stream_test/src/audio_stream_unit_test.cpp b/test/unittest/stream_test/src/audio_stream_unit_test.cpp index d6415af3e4..cbb66fb707 100644 --- a/test/unittest/stream_test/src/audio_stream_unit_test.cpp +++ b/test/unittest/stream_test/src/audio_stream_unit_test.cpp @@ -23,7 +23,7 @@ using namespace testing::ext; namespace OHOS { namespace AudioStandard { -const int32_t ERROR = -1; +const int32_t FAILURE = -1; const uint32_t DEFAULT_SAMPLING_RATE = 44100; const uint8_t DEFAULT_CHANNEL_COUNT = 2; const uint8_t DEFAULT_SAMPLE_SIZE = 2; @@ -140,7 +140,7 @@ HWTEST(AudioStreamUnitTest, Audio_Stream_SetStreamType_001, TestSize.Level1) AudioStreamUnitTest::InitAudioStream(audioStream_); AudioStreamType audioStreamType = AudioStreamType::STREAM_MEDIA; int32_t ret = audioStream_->SetStreamType(audioStreamType); - EXPECT_EQ(ERROR, ret); + EXPECT_EQ(FAILURE, ret); } /** @@ -206,7 +206,7 @@ HWTEST(AudioStreamUnitTest, Audio_Stream_SetAudioStreamType_001, TestSize.Level1 AudioStreamUnitTest::InitAudioStream(audioStream_); AudioStreamType audioStreamType = AudioStreamType::STREAM_RING; int32_t ret = audioStream_->SetAudioStreamType(audioStreamType); - EXPECT_EQ(OPEN_PORT_FAILURE, ret); + EXPECT_EQ(FAILURE, ret); } /** -- Gitee From 15bd725a9a6e482db848620f470b389bc5bbfdd4 Mon Sep 17 00:00:00 2001 From: yangliping Date: Mon, 21 Nov 2022 09:41:01 +0800 Subject: [PATCH 5/8] audiostream and audiopolicy tdd test case Signed-off-by: yangliping --- test/unittest/policy_test/BUILD.gn | 2 +- .../policy_test/include/audio_policy_unit_test.h | 2 +- .../policy_test/src/audio_policy_unit_test.cpp | 14 +++++++------- test/unittest/stream_test/BUILD.gn | 2 +- .../stream_test/include/audio_stream_unit_test.h | 2 +- .../stream_test/src/audio_stream_unit_test.cpp | 4 ++-- 6 files changed, 13 insertions(+), 13 deletions(-) diff --git a/test/unittest/policy_test/BUILD.gn b/test/unittest/policy_test/BUILD.gn index c28a9ac499..a1576267db 100644 --- a/test/unittest/policy_test/BUILD.gn +++ b/test/unittest/policy_test/BUILD.gn @@ -1,4 +1,4 @@ -# Copyright (c) 2021-2022 Huawei Device Co., Ltd. +# Copyright (c) 2022 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 diff --git a/test/unittest/policy_test/include/audio_policy_unit_test.h b/test/unittest/policy_test/include/audio_policy_unit_test.h index f10c30fbc7..3ae67901e2 100644 --- a/test/unittest/policy_test/include/audio_policy_unit_test.h +++ b/test/unittest/policy_test/include/audio_policy_unit_test.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021-2022 Huawei Device Co., Ltd. + * Copyright (c) 2022 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 diff --git a/test/unittest/policy_test/src/audio_policy_unit_test.cpp b/test/unittest/policy_test/src/audio_policy_unit_test.cpp index abb32c3e01..ef5dac8ec2 100644 --- a/test/unittest/policy_test/src/audio_policy_unit_test.cpp +++ b/test/unittest/policy_test/src/audio_policy_unit_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021-2022 Huawei Device Co., Ltd. + * Copyright (c) 2022 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 @@ -35,13 +35,13 @@ void AudioPolicyUnitTest::InitAudioPolicyProxy(std::shared_ptr { auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); if (samgr == nullptr) { - AUDIO_ERR_LOG("AudioSystemManager::init failed"); + AUDIO_ERR_LOG("InitAudioPolicyProxy::GetSystemAbilityManager failed"); return; } sptr object = samgr->GetSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID); if (object == nullptr) { - AUDIO_DEBUG_LOG("AudioSystemManager::object is NULL."); + AUDIO_DEBUG_LOG("InitAudioPolicyProxy::object is NULL."); return; } audioPolicyProxy = std::make_shared(object); @@ -51,13 +51,13 @@ void AudioPolicyUnitTest::GetIRemoteObject(sptr &object) { auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); if (samgr == nullptr) { - AUDIO_ERR_LOG("AudioSystemManager::init failed"); + AUDIO_ERR_LOG("GetIRemoteObject::GetSystemAbilityManager failed"); return; } object = samgr->GetSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID); if (object == nullptr) { - AUDIO_DEBUG_LOG("AudioSystemManager::object is NULL."); + AUDIO_DEBUG_LOG("GetIRemoteObject::object is NULL."); return; } } @@ -75,7 +75,7 @@ void AudioPolicyUnitTest::InitAudioStream(std::shared_ptr &audioStr audioStream = std::make_shared(STREAM_NOTIFICATION, AUDIO_MODE_PLAYBACK, appInfo_.appUid); if (audioStream) { - AUDIO_DEBUG_LOG("AudioRendererPrivate::Audio stream created"); + AUDIO_DEBUG_LOG("InitAudioStream::Audio stream created"); } } @@ -83,7 +83,7 @@ uint32_t AudioPolicyUnitTest::GetSessionId(std::shared_ptr &audioSt { uint32_t sessionID_ = static_cast(-1); if (audioStream->GetAudioSessionID(sessionID_) != 0) { - AUDIO_ERR_LOG("AudioRendererPrivate::GetAudioSessionID Failed"); + AUDIO_ERR_LOG("AudioPolicyUnitTest::GetSessionId Failed"); } return sessionID_; } diff --git a/test/unittest/stream_test/BUILD.gn b/test/unittest/stream_test/BUILD.gn index 0e3e037937..4b197247db 100644 --- a/test/unittest/stream_test/BUILD.gn +++ b/test/unittest/stream_test/BUILD.gn @@ -1,4 +1,4 @@ -# Copyright (c) 2021-2022 Huawei Device Co., Ltd. +# Copyright (c) 2022 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 diff --git a/test/unittest/stream_test/include/audio_stream_unit_test.h b/test/unittest/stream_test/include/audio_stream_unit_test.h index 14383f584f..2ac40c0c41 100644 --- a/test/unittest/stream_test/include/audio_stream_unit_test.h +++ b/test/unittest/stream_test/include/audio_stream_unit_test.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021-2022 Huawei Device Co., Ltd. + * Copyright (c) 2022 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 diff --git a/test/unittest/stream_test/src/audio_stream_unit_test.cpp b/test/unittest/stream_test/src/audio_stream_unit_test.cpp index cbb66fb707..d53cc48fb5 100644 --- a/test/unittest/stream_test/src/audio_stream_unit_test.cpp +++ b/test/unittest/stream_test/src/audio_stream_unit_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021-2022 Huawei Device Co., Ltd. + * Copyright (c) 2022 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 @@ -46,7 +46,7 @@ void AudioStreamUnitTest::InitAudioStream(std::shared_ptr &audioStr audioStream = std::make_shared(STREAM_NOTIFICATION, AUDIO_MODE_PLAYBACK, appInfo_.appUid); if (audioStream) { - AUDIO_DEBUG_LOG("AudioRendererPrivate::Audio stream created"); + AUDIO_DEBUG_LOG("InitAudioStream::Audio stream created"); } } -- Gitee From 115b639509bbb9911645b6f582cca1ed542a9c22 Mon Sep 17 00:00:00 2001 From: yangliping Date: Mon, 21 Nov 2022 11:31:16 +0800 Subject: [PATCH 6/8] delete a test case Signed-off-by: yangliping --- .../src/audio_policy_unit_test.cpp | 20 ------------------- 1 file changed, 20 deletions(-) diff --git a/test/unittest/policy_test/src/audio_policy_unit_test.cpp b/test/unittest/policy_test/src/audio_policy_unit_test.cpp index ef5dac8ec2..8c0a2caeb4 100644 --- a/test/unittest/policy_test/src/audio_policy_unit_test.cpp +++ b/test/unittest/policy_test/src/audio_policy_unit_test.cpp @@ -284,26 +284,6 @@ HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_IsStreamActive_001, TestSize.Le EXPECT_EQ(false, isStreamActive); } -/** -* @tc.name : Test Audio_Policy_Manager_SelectInputDevice_001 via illegal state -* @tc.number: Audio_Policy_Manager_SelectInputDevice_001 -* @tc.desc : Test RegisterAudioCapturerEventListener interface. Returns success. -*/ -HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_SelectInputDevice_001, TestSize.Level1) -{ - AudioSystemManager *audioSystemMgr = AudioSystemManager::GetInstance(); - DeviceFlag deviceFlag = DeviceFlag::INPUT_DEVICES_FLAG; - std::vector> audioDeviceDescriptorsVector; - audioDeviceDescriptorsVector = audioSystemMgr->GetDevices(deviceFlag); - - sptr audioCapturerFilter = new(std::nothrow) AudioCapturerFilter(); - audioCapturerFilter->uid = DeviceFlag::INPUT_DEVICES_FLAG; - - bool isStreamActive = AudioPolicyManager::GetInstance().SelectInputDevice(audioCapturerFilter, - audioDeviceDescriptorsVector); - EXPECT_EQ(false, isStreamActive); -} - /** * @tc.name : Test Audio_Policy_Manager_SetMicrophoneMuteAudioConfig_001 via legal state * @tc.number: Audio_Policy_Manager_SetMicrophoneMuteAudioConfig_001 -- Gitee From 5a749a4dcc7876f8ca3d332a63d6df667d40587e Mon Sep 17 00:00:00 2001 From: yangliping Date: Mon, 21 Nov 2022 14:59:37 +0800 Subject: [PATCH 7/8] tdd change Signed-off-by: yangliping --- test/unittest/policy_test/include/audio_policy_unit_test.h | 6 +++--- test/unittest/policy_test/src/audio_policy_unit_test.cpp | 4 ++-- test/unittest/stream_test/include/audio_stream_unit_test.h | 6 +++--- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/test/unittest/policy_test/include/audio_policy_unit_test.h b/test/unittest/policy_test/include/audio_policy_unit_test.h index 3ae67901e2..1f50c8aae2 100644 --- a/test/unittest/policy_test/include/audio_policy_unit_test.h +++ b/test/unittest/policy_test/include/audio_policy_unit_test.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef AUDIO_CAPTURER_UNIT_TEST_H -#define AUDIO_CAPTURER_UNIT_TEST_H +#ifndef AUDIO_POLICY_UNIT_TEST_H +#define AUDIO_POLICY_UNIT_TEST_H #include "gtest/gtest.h" #include "audio_info.h" @@ -56,4 +56,4 @@ public: } // namespace AudioStandard } // namespace OHOS -#endif // AUDIO_CAPTURER_UNIT_TEST_H +#endif // AUDIO_POLICY_UNIT_TEST_H diff --git a/test/unittest/policy_test/src/audio_policy_unit_test.cpp b/test/unittest/policy_test/src/audio_policy_unit_test.cpp index 8c0a2caeb4..79f3ac8959 100644 --- a/test/unittest/policy_test/src/audio_policy_unit_test.cpp +++ b/test/unittest/policy_test/src/audio_policy_unit_test.cpp @@ -41,7 +41,7 @@ void AudioPolicyUnitTest::InitAudioPolicyProxy(std::shared_ptr sptr object = samgr->GetSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID); if (object == nullptr) { - AUDIO_DEBUG_LOG("InitAudioPolicyProxy::object is NULL."); + AUDIO_ERR_LOG("InitAudioPolicyProxy::object is NULL."); return; } audioPolicyProxy = std::make_shared(object); @@ -57,7 +57,7 @@ void AudioPolicyUnitTest::GetIRemoteObject(sptr &object) object = samgr->GetSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID); if (object == nullptr) { - AUDIO_DEBUG_LOG("GetIRemoteObject::object is NULL."); + AUDIO_ERR_LOG("GetIRemoteObject::object is NULL."); return; } } diff --git a/test/unittest/stream_test/include/audio_stream_unit_test.h b/test/unittest/stream_test/include/audio_stream_unit_test.h index 2ac40c0c41..7e8c66108d 100644 --- a/test/unittest/stream_test/include/audio_stream_unit_test.h +++ b/test/unittest/stream_test/include/audio_stream_unit_test.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef AUDIO_CAPTURER_UNIT_TEST_H -#define AUDIO_CAPTURER_UNIT_TEST_H +#ifndef AUDIO_STREAM_UNIT_TEST_H +#define AUDIO_STREAM_UNIT_TEST_H #include "gtest/gtest.h" #include "audio_info.h" @@ -72,4 +72,4 @@ public: } // namespace AudioStandard } // namespace OHOS -#endif // AUDIO_CAPTURER_UNIT_TEST_H +#endif // AUDIO_STREAM_UNIT_TEST_H -- Gitee From 76ccb5aad54cd5b0e4c51c978767e31b6f13c2e6 Mon Sep 17 00:00:00 2001 From: yangliping Date: Mon, 21 Nov 2022 19:41:18 +0800 Subject: [PATCH 8/8] audiorenderer tdd add Signed-off-by: yangliping --- .../src/audio_renderer_unit_test.cpp | 135 ++++++++++++++++++ 1 file changed, 135 insertions(+) diff --git a/test/unittest/renderer_test/src/audio_renderer_unit_test.cpp b/test/unittest/renderer_test/src/audio_renderer_unit_test.cpp index 48d68588b7..6dcf48a1e9 100644 --- a/test/unittest/renderer_test/src/audio_renderer_unit_test.cpp +++ b/test/unittest/renderer_test/src/audio_renderer_unit_test.cpp @@ -814,6 +814,141 @@ HWTEST(AudioRendererUnitTest, Audio_Renderer_GetParams_005, TestSize.Level1) audioRenderer->Release(); } +/** +* @tc.name : Test GetParams API via legal input. +* @tc.number: Audio_Renderer_GetParams_006 +* @tc.desc : Test GetParams interface. Returns 0 {SUCCESS}, if the getting is successful. +*/ +HWTEST(AudioRendererUnitTest, Audio_Renderer_GetParams_006, TestSize.Level1) +{ + int32_t ret = -1; + unique_ptr audioRenderer = AudioRenderer::Create(STREAM_MUSIC); + ASSERT_NE(nullptr, audioRenderer); + + AudioRendererParams rendererParams; + rendererParams.sampleFormat = SAMPLE_S24LE; + rendererParams.sampleRate = SAMPLE_RATE_44100; + rendererParams.channelCount = STEREO; + rendererParams.encodingType = ENCODING_PCM; + ret = audioRenderer->SetParams(rendererParams); + EXPECT_EQ(SUCCESS, ret); + + AudioRendererParams getRendererParams; + ret = audioRenderer->GetParams(getRendererParams); + EXPECT_EQ(SUCCESS, ret); + EXPECT_EQ(rendererParams.sampleFormat, getRendererParams.sampleFormat); + EXPECT_EQ(rendererParams.sampleRate, getRendererParams.sampleRate); + EXPECT_EQ(rendererParams.channelCount, getRendererParams.channelCount); + EXPECT_EQ(rendererParams.encodingType, getRendererParams.encodingType); + + audioRenderer->Release(); +} + +/** +* @tc.name : Test GetParams API via legal input. +* @tc.number: Audio_Renderer_GetParams_007 +* @tc.desc : Test GetParams interface. Returns 0 {SUCCESS}, if the getting is successful. +*/ +HWTEST(AudioRendererUnitTest, Audio_Renderer_GetParams_007, TestSize.Level1) +{ + int32_t ret = -1; + unique_ptr audioRenderer = AudioRenderer::Create(STREAM_MUSIC); + ASSERT_NE(nullptr, audioRenderer); + + AudioRendererParams rendererParams; + rendererParams.sampleFormat = SAMPLE_S32LE; + rendererParams.sampleRate = SAMPLE_RATE_44100; + rendererParams.channelCount = STEREO; + rendererParams.encodingType = ENCODING_PCM; + ret = audioRenderer->SetParams(rendererParams); + EXPECT_EQ(SUCCESS, ret); + + AudioRendererParams getRendererParams; + ret = audioRenderer->GetParams(getRendererParams); + EXPECT_EQ(SUCCESS, ret); + EXPECT_EQ(rendererParams.sampleFormat, getRendererParams.sampleFormat); + EXPECT_EQ(rendererParams.sampleRate, getRendererParams.sampleRate); + EXPECT_EQ(rendererParams.channelCount, getRendererParams.channelCount); + EXPECT_EQ(rendererParams.encodingType, getRendererParams.encodingType); + + audioRenderer->Release(); +} + +/** +* @tc.name : Test GetParams API via legal input. +* @tc.number: Audio_Renderer_GetParams_008 +* @tc.desc : Test GetParams interface. Returns 0 {SUCCESS}, if the getting is successful. +*/ +HWTEST(AudioRendererUnitTest, Audio_Renderer_GetParams_008, TestSize.Level1) +{ + int32_t ret = -1; + unique_ptr audioRenderer = AudioRenderer::Create(STREAM_MUSIC); + ASSERT_NE(nullptr, audioRenderer); + + AudioRendererParams getRendererParams; + getRendererParams.sampleFormat = AudioSampleFormat::INVALID_WIDTH; + ret = audioRenderer->GetParams(getRendererParams); + EXPECT_EQ(true, ret < 0); + audioRenderer->Release(); +} + +/** +* @tc.name : Test SetInterruptMode API via legal input +* @tc.number: Audio_Renderer_SetInterruptMode_001 +* @tc.desc : Test SetInterruptMode interface. Returns 0 {SUCCESS}, if the setting is successful. +*/ +HWTEST(AudioRendererUnitTest, Audio_Renderer_SetInterruptMode_001, TestSize.Level1) +{ + int32_t ret = -1; + unique_ptr audioRenderer = AudioRenderer::Create(STREAM_MUSIC); + ASSERT_NE(nullptr, audioRenderer); + + ret = AudioRendererUnitTest::InitializeRenderer(audioRenderer); + EXPECT_EQ(SUCCESS, ret); + + audioRenderer->SetInterruptMode(SHARE_MODE); + + bool isStarted = audioRenderer->Start(); + EXPECT_EQ(true, isStarted); + + bool isStopped = audioRenderer->Stop(); + EXPECT_EQ(true, isStopped); + audioRenderer->Release(); +} + +/** +* @tc.name : Test GetBufQueueState +* @tc.number: Audio_Renderer_GetBufQueueState_001 +* @tc.desc : Test GetBufQueueState interface. Returns BufferQueueState, if obtained successfully. +*/ +HWTEST(AudioRendererUnitTest, Audio_Renderer_GetBufQueueState_001, TestSize.Level1) +{ + int32_t ret = -1; + AudioRendererOptions rendererOptions; + + AudioRendererUnitTest::InitializeRendererOptions(rendererOptions); + unique_ptr audioRenderer = AudioRenderer::Create(rendererOptions); + ASSERT_NE(nullptr, audioRenderer); + + ret = audioRenderer->SetRenderMode(RENDER_MODE_CALLBACK); + EXPECT_EQ(SUCCESS, ret); + AudioRenderMode renderMode = audioRenderer->GetRenderMode(); + EXPECT_EQ(RENDER_MODE_CALLBACK, renderMode); + + shared_ptr cb = make_shared(); + + ret = audioRenderer->SetRendererWriteCallback(cb); + EXPECT_EQ(SUCCESS, ret); + + BufferQueueState bQueueSate {}; + bQueueSate.currentIndex = 1; + bQueueSate.numBuffers = 1; + + ret = audioRenderer->GetBufQueueState(bQueueSate); + EXPECT_EQ(SUCCESS, ret); + audioRenderer->Release(); +} + /** * @tc.name : Test GetParams API stability. * @tc.number: Audio_Renderer_GetParams_Stability_001 -- Gitee