From 0ee6496d2cd7f719a179fb46b969deba6b9f482e Mon Sep 17 00:00:00 2001 From: weiyuantian Date: Wed, 20 Aug 2025 06:36:44 +0000 Subject: [PATCH 01/20] add services/audio_service/test/unittest/audio_0820_DT_test. Signed-off-by: weiyuantian --- .../test/unittest/audio_0820_DT_test | 634 ++++++++++++++++++ 1 file changed, 634 insertions(+) create mode 100644 services/audio_service/test/unittest/audio_0820_DT_test diff --git a/services/audio_service/test/unittest/audio_0820_DT_test b/services/audio_service/test/unittest/audio_0820_DT_test new file mode 100644 index 0000000000..4b0bf450c5 --- /dev/null +++ b/services/audio_service/test/unittest/audio_0820_DT_test @@ -0,0 +1,634 @@ +/services/audio_service/test/unittest/format_converter_unit_test.cpp +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: F32MonoToS16Stereo_002 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, F32MonoToS16Stereo_002, TestSize.Level1) +{ + BufferDesc srcDesc; + BufferDesc dstDesc; + int32_t ret = -1; + uint8_t srcBuffer[4] = {0}; + uint8_t dstBuffer[4] = {0}; + + srcDesc.bufLength = 4; + srcDesc.buffer = nullptr; + dstDesc.bufLength = 4; + dstDesc.buffer = dstBuffer; + + ret = FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); + + srcDesc.bufLength = 4; + srcDesc.buffer = srcBuffer; + dstDesc.bufLength = 4; + dstDesc.buffer = nullptr; + + ret = FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); + + srcDesc.bufLength = 5; + srcDesc.buffer = srcBuffer; + dstDesc.bufLength = 5; + dstDesc.buffer = dstBuffer; + + ret = FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: F32MonoToS16Stereo_CapMax_001 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, F32MonoToS16Stereo_CapMax_001, TestSize.Level1) +{ + BufferDesc srcDesc; + BufferDesc dstDesc; + int32_t ret = -1; + uint8_t srcBuffer[4] = {2}; + uint8_t dstBuffer[4] = {0}; + + srcDesc.bufLength = 4; + srcDesc.buffer = srcBuffer; + dstDesc.bufLength = 4; + dstDesc.buffer = dstBuffer; + + ret = FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, 0); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: F32MonoToS16Stereo_CapMax_002 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, F32MonoToS16Stereo_CapMax_002, TestSize.Level1) +{ + BufferDesc srcDesc; + BufferDesc dstDesc; + int32_t ret = -1; + uint8_t srcBuffer[4] = {-2}; + uint8_t dstBuffer[4] = {0}; + + srcDesc.bufLength = 4; + srcDesc.buffer = srcBuffer; + dstDesc.bufLength = 4; + dstDesc.buffer = dstBuffer; + + ret = FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, 0); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: F32StereoToS16Stereo_002 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, F32StereoToS16Stereo_002, TestSize.Level1) +{ + BufferDesc srcDesc; + BufferDesc dstDesc; + int32_t ret = -1; + uint8_t srcBuffer[8] = {0}; + uint8_t dstBuffer[4] = {0}; + + srcDesc.bufLength = 4; + srcDesc.buffer = nullptr; + dstDesc.bufLength = 2; + dstDesc.buffer = dstBuffer; + + ret = FormatConverter::F32StereoToS16Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); + + srcDesc.bufLength = 4; + srcDesc.buffer = srcBuffer; + dstDesc.bufLength = 2; + dstDesc.buffer = nullptr; + + ret = FormatConverter::F32StereoToS16Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); + + srcDesc.bufLength = 6; + srcDesc.buffer = srcBuffer; + dstDesc.bufLength = 3; + dstDesc.buffer = dstBuffer; + + ret = FormatConverter::F32StereoToS16Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: S16StereoToF32Mono_002 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, S16StereoToF32Mono_002, TestSize.Level1) +{ + BufferDesc srcDesc; + BufferDesc dstDesc; + int32_t ret = -1; + uint8_t srcBuffer[8] = {0}; + uint8_t dstBuffer[4] = {0}; + + srcDesc.bufLength = 4; + srcDesc.buffer = nullptr; + dstDesc.bufLength = 4; + dstDesc.buffer = dstBuffer; + + ret = FormatConverter::S16StereoToF32Mono(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); + + srcDesc.bufLength = 4; + srcDesc.buffer = srcBuffer; + dstDesc.bufLength = 4; + dstDesc.buffer = nullptr; + + ret = FormatConverter::S16StereoToF32Mono(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: S16MonoToS32Stereo_001 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, S16MonoToS32Stereo_001, TestSize.Level1) +{ + BufferDesc srcDesc; + BufferDesc dstDesc; + int32_t ret = -1; + uint8_t srcBuffer[8] = {0}; + uint8_t dstBuffer[4] = {0}; + + srcDesc.bufLength = 2; + srcDesc.buffer = nullptr; + dstDesc.bufLength = 8; + dstDesc.buffer = dstBuffer; + + ret = FormatConverter::S16MonoToS32Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); + + srcDesc.bufLength = 2; + srcDesc.buffer = srcBuffer; + dstDesc.bufLength = 8; + dstDesc.buffer = nullptr; + + ret = FormatConverter::S16MonoToS32Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); + + srcDesc.bufLength = 4; + srcDesc.buffer = srcBuffer; + dstDesc.bufLength = 8; + dstDesc.buffer = dstBuffer; + + ret = FormatConverter::S16MonoToS32Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: S32StereoToS16Stereo_001 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, S32StereoToS16Stereo_001, TestSize.Level1) +{ + BufferDesc srcDesc; + BufferDesc dstDesc; + int32_t ret = -1; + uint8_t srcBuffer[8] = {0}; + uint8_t dstBuffer[4] = {0}; + + srcDesc.bufLength = 8; + srcDesc.buffer = nullptr; + dstDesc.bufLength = 4; + dstDesc.buffer = dstBuffer; + + ret = FormatConverter::S32StereoToS16Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); + + srcDesc.bufLength = 8; + srcDesc.buffer = srcBuffer; + dstDesc.bufLength = 4; + dstDesc.buffer = nullptr; + + ret = FormatConverter::S32StereoToS16Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: S32MonoToS16Stereo_001 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, S32MonoToS16Stereo_001, TestSize.Level1) +{ + BufferDesc srcDesc; + BufferDesc dstDesc; + int32_t ret = -1; + uint8_t srcBuffer[8] = {0}; + uint8_t dstBuffer[4] = {0}; + + srcDesc.bufLength = 4; + srcDesc.buffer = srcBuffer; + dstDesc.bufLength = 4; + dstDesc.buffer = dstBuffer; + + ret = FormatConverter::S32MonoToS16Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, 0); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: S16StereoToS16Mono_001 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, S16StereoToS16Mono_001, TestSize.Level1) +{ + BufferDesc srcDesc; + BufferDesc dstDesc; + int32_t ret = -1; + uint8_t srcBuffer[8] = {0}; + uint8_t dstBuffer[4] = {0}; + + srcDesc.bufLength = 8; + srcDesc.buffer = nullptr; + dstDesc.bufLength = 4; + dstDesc.buffer = dstBuffer; + + ret = FormatConverter::S16StereoToS16Mono(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); + + srcDesc.bufLength = 8; + srcDesc.buffer = srcBuffer; + dstDesc.bufLength = 4; + dstDesc.buffer = nullptr; + + ret = FormatConverter::S16StereoToS16Mono(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); + + srcDesc.bufLength = 8; + srcDesc.buffer = srcBuffer; + dstDesc.bufLength = 4; + dstDesc.buffer = dstBuffer; + + ret = FormatConverter::S16StereoToS16Mono(srcDesc, dstDesc); + EXPECT_EQ(ret, 0); +} + +/services/audio_service/test/unittest/client/capturer_in_client_unit_test.cpp +/** + * @tc.name : Test OnOperationHandled API + * @tc.type : FUNC + * @tc.number: OnOperationHandled_002 + * @tc.desc : Test OnOperationHandled interface. + */ +HWTEST(CapturerInClientUnitTest, OnOperationHandled_002, TestSize.Level1) +{ + std::shared_ptr capturerInClientInner_ = + std::make_shared(STREAM_MUSIC, getpid()); + Operation operation = Operation::RESTORE_SESSION; + int64_t result = 1; + capturerInClientInner_->audioStreamTracker_ = nullptr; + int32_t ret = capturerInClientInner_->OnOperationHandled(operation, result); + EXPECT_EQ(ret, SUCCESS); +} + +/** + * @tc.name : Test GetFrameCount API + * @tc.type : FUNC + * @tc.number: GetFrameCount_002 + * @tc.desc : Test GetFrameCount interface. + */ +HWTEST(CapturerInClientUnitTest, GetFrameCount_002, TestSize.Level1) +{ + std::shared_ptr capturerInClientInner = + std::make_shared(STREAM_MUSIC, getpid()); + uint32_t frameCount = -111; + capturerInClientInner->capturerMode_ = CAPTURE_MODE_CALLBACK; + + int32_t result = capturerInClientInner->GetFrameCount(frameCount); + EXPECT_EQ(result, SUCCESS); +} + +/** + * @tc.name : Test Clear API + * @tc.type : FUNC + * @tc.number: Clear_002 + * @tc.desc : Test Clear interface. + */ +HWTEST(CapturerInClientUnitTest, Clear_002, TestSize.Level1) +{ + std::shared_ptr capturerInClientInner_ = + std::make_shared(STREAM_MUSIC, getpid()); + capturerInClientInner_->capturerMode_ = CAPTURE_MODE_NORMAL; + capturerInClientInner_->cbBuffer_.reset(new uint8_t[VALUE_TEN]); + int32_t ret = capturerInClientInner_->Clear(); + EXPECT_EQ(ret, ERR_INCORRECT_MODE); +} + +/** + * @tc.name : Test StopAudioStream API + * @tc.type : FUNC + * @tc.number: StopAudioStream_004 + * @tc.desc : Test StopAudioStream interface. + */ +HWTEST(CapturerInClientUnitTest, StopAudioStream_004, TestSize.Level1) +{ + std::shared_ptr capturerInClientInner = + std::make_shared(STREAM_MUSIC, getpid()); + capturerInClientInner->state_ = State::PAUSED; + capturerInClientInner->capturerMode_ = CAPTURE_MODE_CALLBACK; + capturerInClientInner->ipcStream_ = std::make_shared().get(); + bool result = capturerInClientInner->StopAudioStream(); + EXPECT_EQ(capturerInClientInner->state_, State::INVALID); + EXPECT_EQ(result, false); +} + +/** + * @tc.name : Test Read API + * @tc.type : FUNC + * @tc.number: Read_002 + * @tc.desc : Test Read interface. + */ +HWTEST(CapturerInClientUnitTest, Read_002, TestSize.Level1) +{ + std::shared_ptr capturerInClientInner_ = + std::make_shared(STREAM_MUSIC, getpid()); + capturerInClientInner_->state_ = State::NEW; + size_t userSize = 16; + uint8_t buffer = 0; + bool isBlockingRead = false; + capturerInClientInner_->readLogTimes_ = VALUE_TEN; + int32_t ret = capturerInClientInner_->Read(buffer, userSize, isBlockingRead); + EXPECT_EQ(ret, ERR_ILLEGAL_STATE); +} + +services/audio_service/test/unittest/audio_service_common_unit_test.cpp +/** +* @tc.name : Test GetTimeOfPos API +* @tc.type : FUNC +* @tc.number: GetTimeOfPos_001 +* @tc.desc : Test GetTimeOfPos interface. +*/ +HWTEST(AudioServiceCommonUnitTest, GetTimeOfPos_001, TestSize.Level1) +{ + g_linearPosTimeModel = std::make_unique(); + + uint64_t posInFrame = 20; + int64_t invalidTime = -1; + g_linearPosTimeModel->stampFrame_ = 0; + g_linearPosTimeModel->sampleRate_ = 0; + int64_t retPos = g_linearPosTimeModel->GetTimeOfPos(posInFrame); + EXPECT_EQ(invalidTime, retPos); +} + +/** +* @tc.name : Test GetTimeOfPos API +* @tc.type : FUNC +* @tc.number: GetTimeOfPos_002 +* @tc.desc : Test GetTimeOfPos interface. +*/ +HWTEST(AudioServiceCommonUnitTest, GetTimeOfPos_002, TestSize.Level1) +{ + g_linearPosTimeModel = std::make_unique(); + + uint64_t posInFrame = 1; + int64_t invalidTime = -1; + g_linearPosTimeModel->stampFrame_ = 10; + g_linearPosTimeModel->sampleRate_ = 0; + int64_t retPos = g_linearPosTimeModel->GetTimeOfPos(posInFrame); + EXPECT_EQ(invalidTime, retPos); +} + +/** +* @tc.name : Test Init API +* @tc.type : FUNC +* @tc.number: Init_001 +* @tc.desc : Test Init interface. +*/ +HWTEST(AudioServiceCommonUnitTest, Init_001, TestSize.Level1) +{ + const size_t testMaxSize = 16 * 1024 * 1024 + 1; + size_t testSize = 3840; + std::unique_ptr ringCache = AudioRingCache::Create(testSize); + EXPECT_NE(nullptr, ringCache); + ringCache->cacheTotalSize_ = testMaxSize; + bool result = ringCache->Init(); + EXPECT_EQ(result, false); +} + +/** +* @tc.name : Test Init API +* @tc.type : FUNC +* @tc.number: Init_002 +* @tc.desc : Test Init interface. +*/ +HWTEST(AudioServiceCommonUnitTest, Init_002, TestSize.Level1) +{ + size_t testSize = 3840; + std::unique_ptr ringCache = AudioRingCache::Create(testSize); + EXPECT_NE(nullptr, ringCache); + ringCache->cacheTotalSize_ = -1; + bool result = ringCache->Init(); + EXPECT_EQ(result, false); +} + +/** +* @tc.name : Test Create API +* @tc.type : FUNC +* @tc.number: Create_001 +* @tc.desc : Test Create interface. +*/ +HWTEST(AudioServiceCommonUnitTest, Create_001, TestSize.Level1) +{ + size_t testSize = 3840; + size_t cacheSize = 16 * 1024 * 1024 + 1; + std::unique_ptr ringCache = AudioRingCache::Create(testSize); + EXPECT_NE(nullptr, ringCache); + std::unique_ptr result = ringCache->Create(cacheSize); + EXPECT_EQ(result, nullptr); +} + +/services/audio_service/test/unittest/audio_group_manager_unit_test.cpp +/** +* @tc.name : Test Audio API +* @tc.type : FUNC +* @tc.number: SetVolume_004 +* @tc.desc : Test cross ring cache. +*/ +HWTEST(AudioGroupManagerUnitTest, SetVolume_004, TestSize.Level1) +{ + AudioGroupManager audioGroupManager(1); + int32_t ret = audioGroupManager.SetVolume(STREAM_ALL, 0, 0, 123); + EXPECT_EQ(ret, ERR_PERMISSION_DENIED); +} + +/** +* @tc.name : Test Audio API +* @tc.type : FUNC +* @tc.number: SetVolume_005 +* @tc.desc : Test cross ring cache. +*/ +HWTEST(AudioGroupManagerUnitTest, SetVolume_005, TestSize.Level1) +{ + AudioGroupManager audioGroupManager(1); + int32_t ret = audioGroupManager.SetVolume(STREAM_DEFAULT, 0, 0, 123); + EXPECT_EQ(ret, ERR_NOT_SUPPORTED); +} + +/** +* @tc.name : Test Audio API +* @tc.type : FUNC +* @tc.number: SetVolume_006 +* @tc.desc : Test cross ring cache. +*/ +HWTEST(AudioGroupManagerUnitTest, SetVolume_006, TestSize.Level1) +{ + AudioGroupManager audioGroupManager(1); + audioGroupManager.connectType_ = CONNECT_TYPE_DISTRIBUTED; + int32_t ret = audioGroupManager.SetVolume(STREAM_DEFAULT, 0, 0, 123); + EXPECT_EQ(ret, SUCCESS); +} + +/** +* @tc.name : Test Audio API +* @tc.type : FUNC +* @tc.number: GetVolume_004 +* @tc.desc : Test cross ring cache. +*/ +HWTEST(AudioGroupManagerUnitTest, GetVolume_004, TestSize.Level1) +{ + AudioGroupManager audioGroupManager(1); + int32_t ret = audioGroupManager.GetVolume(STREAM_ACCESSIBILITY, 123); + EXPECT_EQ(ret, 5); +} + +/** +* @tc.name : Test Audio API +* @tc.type : FUNC +* @tc.number: GetVolume_005 +* @tc.desc : Test cross ring cache. +*/ +HWTEST(AudioGroupManagerUnitTest, GetVolume_005, TestSize.Level1) +{ + AudioGroupManager audioGroupManager(1); + audioGroupManager.connectType_ = CONNECT_TYPE_DISTRIBUTED; + int32_t ret = audioGroupManager.GetVolume(STREAM_ACCESSIBILITY, 123); + EXPECT_EQ(ret, 0); +} + +/** +* @tc.name : Test Audio API +* @tc.type : FUNC +* @tc.number: GetMaxVolume_004 +* @tc.desc : Test cross ring cache. +*/ +HWTEST(AudioGroupManagerUnitTest, GetMaxVolume_004, TestSize.Level1) +{ + AudioGroupManager audioGroupManager(1); + audioGroupManager.connectType_ = CONNECT_TYPE_DISTRIBUTED; + int32_t ret = audioGroupManager.GetMaxVolume(STREAM_ULTRASONIC); + EXPECT_EQ(ret, 0); +} + +/** +* @tc.name : Test Audio API +* @tc.type : FUNC +* @tc.number: IsStreamMute_003 +* @tc.desc : Test cross ring cache. +*/ +HWTEST(AudioGroupManagerUnitTest, IsStreamMute_003, TestSize.Level1) +{ + AudioGroupManager audioGroupManager(1); + audioGroupManager.connectType_ = ConnectType::CONNECT_TYPE_LOCAL; + bool isMute = false; + int32_t ret = audioGroupManager.IsStreamMute(AudioStreamType::STREAM_ACCESSIBILITY, isMute); + EXPECT_EQ(ret, SUCCESS); +} + +/** +* @tc.name : Test Audio API +* @tc.type : FUNC +* @tc.number: IsStreamMute_004 +* @tc.desc : Test cross ring cache. +*/ +HWTEST(AudioGroupManagerUnitTest, IsStreamMute_004, TestSize.Level1) +{ + AudioGroupManager audioGroupManager(1); + audioGroupManager.connectType_ = ConnectType::CONNECT_TYPE_LOCAL; + bool isMute = false; + int32_t ret = audioGroupManager.IsStreamMute(AudioStreamType::STREAM_ALL, isMute); + EXPECT_EQ(ret, SUCCESS); +} + +/frameworks/native/toneplayer/test/unittest/audio_toneplayer_unit_test.cpp +/** + * @tc.name : Test TonePlayerImpl API + * @tc.type : FUNC + * @tc.number: TonePlayerImpl_025 + * @tc.desc : Test CheckToneStopped interface. + */ +HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_025, TestSize.Level4) +{ + AudioRendererInfo rendererInfo = {}; + rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC; + rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF; + rendererInfo.rendererFlags = 0; + + std::shared_ptr toneplayer = std::make_shared("", rendererInfo); + EXPECT_NE(toneplayer, nullptr); + + toneplayer->toneInfo_ = std::make_shared(); + EXPECT_NE(toneplayer->toneInfo_, nullptr); + + toneplayer->toneState_ = TonePlayerImpl::TONE_STARTING; + toneplayer->currSegment_ = 0; + toneplayer->totalSample_ = 9000; + toneplayer->maxSample_ = 8000; + toneplayer->toneInfo_->segments[1].duration = 1; + + bool ret = toneplayer->CheckToneStopped(); + EXPECT_EQ(ret, true); +} + +/** + * @tc.name : Test TonePlayerImpl API + * @tc.type : FUNC + * @tc.number: TonePlayerImpl_026 + * @tc.desc : Test CheckToneStopped interface. + */ +HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_026, TestSize.Level4) +{ + AudioRendererInfo rendererInfo = {}; + rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC; + rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF; + rendererInfo.rendererFlags = 0; + + std::shared_ptr toneplayer = std::make_shared("", rendererInfo); + EXPECT_NE(toneplayer, nullptr); + + toneplayer->toneInfo_ = std::make_shared(); + EXPECT_NE(toneplayer->toneInfo_, nullptr); + + toneplayer->toneState_ = TonePlayerImpl::TONE_STARTING; + toneplayer->currSegment_ = 0; + toneplayer->totalSample_ = 8000; + toneplayer->maxSample_ = 8000; + toneplayer->toneInfo_->segments[1].duration = 0; + + bool ret = toneplayer->CheckToneStopped(); + EXPECT_EQ(ret, true); +} + + -- Gitee From 1a50d9051a4e5266e686c12b27c70c82b6d50400 Mon Sep 17 00:00:00 2001 From: weiyuantian Date: Wed, 20 Aug 2025 08:24:16 +0000 Subject: [PATCH 02/20] update services/audio_service/test/unittest/audio_0820_DT_test. Signed-off-by: weiyuantian --- .../test/unittest/audio_0820_DT_test | 1219 +++++++++-------- 1 file changed, 683 insertions(+), 536 deletions(-) diff --git a/services/audio_service/test/unittest/audio_0820_DT_test b/services/audio_service/test/unittest/audio_0820_DT_test index 4b0bf450c5..c354f28836 100644 --- a/services/audio_service/test/unittest/audio_0820_DT_test +++ b/services/audio_service/test/unittest/audio_0820_DT_test @@ -1,634 +1,781 @@ -/services/audio_service/test/unittest/format_converter_unit_test.cpp -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: F32MonoToS16Stereo_002 - * @tc.desc : Test FormatConverter interface. +/* + * 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. */ -HWTEST_F(FormatConverterUnitTest, F32MonoToS16Stereo_002, TestSize.Level1) -{ - BufferDesc srcDesc; - BufferDesc dstDesc; - int32_t ret = -1; - uint8_t srcBuffer[4] = {0}; - uint8_t dstBuffer[4] = {0}; - - srcDesc.bufLength = 4; - srcDesc.buffer = nullptr; - dstDesc.bufLength = 4; - dstDesc.buffer = dstBuffer; - - ret = FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); + +#ifndef STANDALONE_MODE_MANAGER_UNIT_TEST_H +#define STANDALONE_MODE_MANAGER_UNIT_TEST_H + +#include "gtest/gtest.h" +#include "audio_interrupt_service.h" +#include "standalone_mode_manager.h" +namespace OHOS { +namespace AudioStandard { + +class StandaloneModeManagerUnitTest : 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 // STANDALONE_MODE_MANAGER_UNIT_TEST_H + - srcDesc.bufLength = 4; - srcDesc.buffer = srcBuffer; - dstDesc.bufLength = 4; - dstDesc.buffer = nullptr; - ret = FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); - srcDesc.bufLength = 5; - srcDesc.buffer = srcBuffer; - dstDesc.bufLength = 5; - dstDesc.buffer = dstBuffer; - ret = FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); -} -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: F32MonoToS16Stereo_CapMax_001 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, F32MonoToS16Stereo_CapMax_001, TestSize.Level1) -{ - BufferDesc srcDesc; - BufferDesc dstDesc; - int32_t ret = -1; - uint8_t srcBuffer[4] = {2}; - uint8_t dstBuffer[4] = {0}; - - srcDesc.bufLength = 4; - srcDesc.buffer = srcBuffer; - dstDesc.bufLength = 4; - dstDesc.buffer = dstBuffer; - - ret = FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, 0); -} /** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: F32MonoToS16Stereo_CapMax_002 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, F32MonoToS16Stereo_CapMax_002, TestSize.Level1) +* @tc.name : Test AudioInterruptService +* @tc.number: AudioInterruptService_045 +* @tc.desc : Test AudioInterruptService_045 +*/ +HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_045, TestSize.Level1) { - BufferDesc srcDesc; - BufferDesc dstDesc; - int32_t ret = -1; - uint8_t srcBuffer[4] = {-2}; - uint8_t dstBuffer[4] = {0}; - - srcDesc.bufLength = 4; - srcDesc.buffer = srcBuffer; - dstDesc.bufLength = 4; - dstDesc.buffer = dstBuffer; - - ret = FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, 0); + auto audioInterruptService = std::make_shared(); + ASSERT_NE(audioInterruptService, nullptr); + + int32_t fakePid = 123; + AudioInterrupt incomingInterrupt; + incomingInterrupt.pid = fakePid; + incomingInterrupt.audioFocusType.streamType = STREAM_MUSIC; + AudioSessionStrategy audioSessionStrategy; + InterruptEventInternal interruptEvent; + audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT; + audioInterruptService->sessionService_ = AudioSessionService::GetAudioSessionService(); + audioInterruptService->sessionService_->sessionMap_[fakePid] = nullptr; + auto ret = audioInterruptService->ActivateAudioSession(1, fakePid, audioSessionStrategy, true); + audioInterruptService->ResumeFocusByStreamId(fakePid, interruptEvent); + EXPECT_EQ(ERROR, ret); } -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: F32StereoToS16Stereo_002 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, F32StereoToS16Stereo_002, TestSize.Level1) -{ - BufferDesc srcDesc; - BufferDesc dstDesc; - int32_t ret = -1; - uint8_t srcBuffer[8] = {0}; - uint8_t dstBuffer[4] = {0}; - - srcDesc.bufLength = 4; - srcDesc.buffer = nullptr; - dstDesc.bufLength = 2; - dstDesc.buffer = dstBuffer; - - ret = FormatConverter::F32StereoToS16Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); - srcDesc.bufLength = 4; - srcDesc.buffer = srcBuffer; - dstDesc.bufLength = 2; - dstDesc.buffer = nullptr; - ret = FormatConverter::F32StereoToS16Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); - srcDesc.bufLength = 6; - srcDesc.buffer = srcBuffer; - dstDesc.bufLength = 3; - dstDesc.buffer = dstBuffer; - ret = FormatConverter::F32StereoToS16Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); -} /** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: S16StereoToF32Mono_002 - * @tc.desc : Test FormatConverter interface. + * @tc.name : Test AudioInterruptService. + * @tc.number: AudioInterruptService_RemoveExistingFocus_001 + * @tc.desc : Test RemoveExistingFocus. */ -HWTEST_F(FormatConverterUnitTest, S16StereoToF32Mono_002, TestSize.Level1) +HWTEST(AudioInterruptUnitTest, AudioInterruptService_RemoveExistingFocus_001, TestSize.Level1) { - BufferDesc srcDesc; - BufferDesc dstDesc; - int32_t ret = -1; - uint8_t srcBuffer[8] = {0}; - uint8_t dstBuffer[4] = {0}; - - srcDesc.bufLength = 4; - srcDesc.buffer = nullptr; - dstDesc.bufLength = 4; - dstDesc.buffer = dstBuffer; - - ret = FormatConverter::S16StereoToF32Mono(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); - - srcDesc.bufLength = 4; - srcDesc.buffer = srcBuffer; - dstDesc.bufLength = 4; - dstDesc.buffer = nullptr; - - ret = FormatConverter::S16StereoToF32Mono(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); + auto interruptServiceTest = GetTnterruptServiceTest(); + interruptServiceTest->zonesMap_.clear(); + int32_t appUid = 1; + auto audioInterruptZone = std::make_shared(); + AudioInterrupt audioInterrupt1; + audioInterrupt1.sessionId = 100; + audioInterrupt1.uid = 1; + std::unordered_set uidActivedSessions; + audioInterruptZone->audioFocusInfoList.clear(); + audioInterruptZone->audioFocusInfoList.emplace_back(audioInterrupt1, AudioFocuState{PAUSE}); + EXPECT_EQ(interruptServiceTest->zonesMap_.find(0), interruptServiceTest->zonesMap_.end()); + interruptServiceTest->zonesMap_[0] = std::make_shared(); + interruptServiceTest->zonesMap_[1] = audioInterruptZone; + interruptServiceTest->zonesMap_[2] = std::make_shared(); + interruptServiceTest->RemoveExistingFocus(appUid, uidActivedSessions); } - + /** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: S16MonoToS32Stereo_001 - * @tc.desc : Test FormatConverter interface. + * @tc.name : Test AudioInterruptService. + * @tc.number: AudioInterruptService_ResumeFocusByStreamId_001 + * @tc.desc : Test ResumeFocusByStreamId. */ -HWTEST_F(FormatConverterUnitTest, S16MonoToS32Stereo_001, TestSize.Level1) +HWTEST(AudioInterruptUnitTest, AudioInterruptService_ResumeFocusByStreamId_001, TestSize.Level1) { - BufferDesc srcDesc; - BufferDesc dstDesc; - int32_t ret = -1; - uint8_t srcBuffer[8] = {0}; - uint8_t dstBuffer[4] = {0}; - - srcDesc.bufLength = 2; - srcDesc.buffer = nullptr; - dstDesc.bufLength = 8; - dstDesc.buffer = dstBuffer; - - ret = FormatConverter::S16MonoToS32Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); - - srcDesc.bufLength = 2; - srcDesc.buffer = srcBuffer; - dstDesc.bufLength = 8; - dstDesc.buffer = nullptr; - - ret = FormatConverter::S16MonoToS32Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); - - srcDesc.bufLength = 4; - srcDesc.buffer = srcBuffer; - dstDesc.bufLength = 8; - dstDesc.buffer = dstBuffer; - - ret = FormatConverter::S16MonoToS32Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); + auto interruptServiceTest = GetTnterruptServiceTest(); + InterruptEventInternal interruptEvent; + interruptServiceTest->ResumeFocusByStreamId(0, interruptEvent); + interruptServiceTest->zonesMap_[0] = std::make_shared(); + auto retStatus = interruptServiceTest->SetAudioInterruptCallback(0, 0, + sptr::MakeSptr(), 0); + EXPECT_EQ(retStatus, SUCCESS); + interruptServiceTest->ResumeFocusByStreamId(0, interruptEvent); } -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: S32StereoToS16Stereo_001 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, S32StereoToS16Stereo_001, TestSize.Level1) -{ - BufferDesc srcDesc; - BufferDesc dstDesc; - int32_t ret = -1; - uint8_t srcBuffer[8] = {0}; - uint8_t dstBuffer[4] = {0}; - - srcDesc.bufLength = 8; - srcDesc.buffer = nullptr; - dstDesc.bufLength = 4; - dstDesc.buffer = dstBuffer; - - ret = FormatConverter::S32StereoToS16Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); - srcDesc.bufLength = 8; - srcDesc.buffer = srcBuffer; - dstDesc.bufLength = 4; - dstDesc.buffer = nullptr; - ret = FormatConverter::S32StereoToS16Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); -} -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: S32MonoToS16Stereo_001 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, S32MonoToS16Stereo_001, TestSize.Level1) -{ - BufferDesc srcDesc; - BufferDesc dstDesc; - int32_t ret = -1; - uint8_t srcBuffer[8] = {0}; - uint8_t dstBuffer[4] = {0}; - - srcDesc.bufLength = 4; - srcDesc.buffer = srcBuffer; - dstDesc.bufLength = 4; - dstDesc.buffer = dstBuffer; - - ret = FormatConverter::S32MonoToS16Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, 0); -} -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: S16StereoToS16Mono_001 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, S16StereoToS16Mono_001, TestSize.Level1) -{ - BufferDesc srcDesc; - BufferDesc dstDesc; - int32_t ret = -1; - uint8_t srcBuffer[8] = {0}; - uint8_t dstBuffer[4] = {0}; - - srcDesc.bufLength = 8; - srcDesc.buffer = nullptr; - dstDesc.bufLength = 4; - dstDesc.buffer = dstBuffer; - - ret = FormatConverter::S16StereoToS16Mono(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); + ret = interruptService->ActivateAudioSession(0, incomingInterrupt.pid, strategyTest, true); + EXPECT_EQ(SUCCESS, ret); + ret = interruptService->CanMixForSession( - srcDesc.bufLength = 8; - srcDesc.buffer = srcBuffer; - dstDesc.bufLength = 4; - dstDesc.buffer = nullptr; - ret = FormatConverter::S16StereoToS16Mono(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); - srcDesc.bufLength = 8; - srcDesc.buffer = srcBuffer; - dstDesc.bufLength = 4; - dstDesc.buffer = dstBuffer; - ret = FormatConverter::S16StereoToS16Mono(srcDesc, dstDesc); - EXPECT_EQ(ret, 0); -} -/services/audio_service/test/unittest/client/capturer_in_client_unit_test.cpp + /** - * @tc.name : Test OnOperationHandled API - * @tc.type : FUNC - * @tc.number: OnOperationHandled_002 - * @tc.desc : Test OnOperationHandled interface. + * @tc.name : Test AudioInterruptUnitTest. + * @tc.number: SetAppConcurrencyMode_001 + * @tc.desc : Test SetAppConcurrencyMode. */ -HWTEST(CapturerInClientUnitTest, OnOperationHandled_002, TestSize.Level1) +HWTEST(AudioInterruptUnitTest, SetAppConcurrencyMode_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = - std::make_shared(STREAM_MUSIC, getpid()); - Operation operation = Operation::RESTORE_SESSION; - int64_t result = 1; - capturerInClientInner_->audioStreamTracker_ = nullptr; - int32_t ret = capturerInClientInner_->OnOperationHandled(operation, result); + sptr server = GetPolicyServerTest(); + ASSERT_TRUE(server != nullptr); + int32_t uid = 0; + int32_t mode = 0; + auto ret = server->SetAppConcurrencyMode(uid, mode); EXPECT_EQ(ret, SUCCESS); + server->interruptService_ = nullptr; + ret = server->SetAppConcurrencyMode(uid, mode); + server->interruptService_ = std::make_shared(); + EXPECT_EQ(ret, ERR_UNKNOWN); } - + /** - * @tc.name : Test GetFrameCount API - * @tc.type : FUNC - * @tc.number: GetFrameCount_002 - * @tc.desc : Test GetFrameCount interface. + * @tc.name : Test AudioInterruptUnitTest. + * @tc.number: SetAppSilentOnDisplay_001 + * @tc.desc : Test SetAppSilentOnDisplay. */ -HWTEST(CapturerInClientUnitTest, GetFrameCount_002, TestSize.Level1) +HWTEST(AudioInterruptUnitTest, SetAppSilentOnDisplay_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner = - std::make_shared(STREAM_MUSIC, getpid()); - uint32_t frameCount = -111; - capturerInClientInner->capturerMode_ = CAPTURE_MODE_CALLBACK; - - int32_t result = capturerInClientInner->GetFrameCount(frameCount); - EXPECT_EQ(result, SUCCESS); + sptr server = GetPolicyServerTest(); + ASSERT_TRUE(server != nullptr); + int32_t displayId = 1; + auto ret = server->SetAppSilentOnDisplay(displayId); + EXPECT_EQ(ret, SUCCESS); + server->interruptService_ = nullptr; + ret = server->SetAppSilentOnDisplay(displayId); + server->interruptService_ = std::make_shared(); + EXPECT_EQ(ret, ERR_UNKNOWN); } - + /** - * @tc.name : Test Clear API - * @tc.type : FUNC - * @tc.number: Clear_002 - * @tc.desc : Test Clear interface. - */ -HWTEST(CapturerInClientUnitTest, Clear_002, TestSize.Level1) +* @tc.name : Test AudioInterruptUnitTest. +* @tc.number: AudioPolicyServer_009 +* @tc.desc : Test DeactivateAudioInterrupt. +*/ +HWTEST(AudioInterruptUnitTest, AudioPolicyServer_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = - std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->capturerMode_ = CAPTURE_MODE_NORMAL; - capturerInClientInner_->cbBuffer_.reset(new uint8_t[VALUE_TEN]); - int32_t ret = capturerInClientInner_->Clear(); - EXPECT_EQ(ret, ERR_INCORRECT_MODE); + auto policyServerTest = GetPolicyServerTest(); + int32_t systemAbilityId = 3009; + bool runOnCreate = false; + sptr server = sptr::MakeSptr(systemAbilityId, runOnCreate); + + AudioInterrupt audioInterrupt; + int32_t zoneID = 456; + pid_t pid = 1; + pid_t uid = 1; + int32_t strategy = 0; + server->interruptService_ = std::make_shared(); + int32_t result = server->DeactivateAudioInterrupt(audioInterrupt, zoneID); + EXPECT_EQ(result, ERR_UNKNOWN); + EXPECT_EQ(policyServerTest->ActivateAudioSession(strategy), SUCCESS); + server->RegisteredStreamListenerClientDied(pid, uid); } -/** - * @tc.name : Test StopAudioStream API - * @tc.type : FUNC - * @tc.number: StopAudioStream_004 - * @tc.desc : Test StopAudioStream interface. - */ -HWTEST(CapturerInClientUnitTest, StopAudioStream_004, TestSize.Level1) -{ - std::shared_ptr capturerInClientInner = - std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner->state_ = State::PAUSED; - capturerInClientInner->capturerMode_ = CAPTURE_MODE_CALLBACK; - capturerInClientInner->ipcStream_ = std::make_shared().get(); - bool result = capturerInClientInner->StopAudioStream(); - EXPECT_EQ(capturerInClientInner->state_, State::INVALID); - EXPECT_EQ(result, false); -} -/** - * @tc.name : Test Read API - * @tc.type : FUNC - * @tc.number: Read_002 - * @tc.desc : Test Read interface. - */ -HWTEST(CapturerInClientUnitTest, Read_002, TestSize.Level1) -{ - std::shared_ptr capturerInClientInner_ = - std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->state_ = State::NEW; - size_t userSize = 16; - uint8_t buffer = 0; - bool isBlockingRead = false; - capturerInClientInner_->readLogTimes_ = VALUE_TEN; - int32_t ret = capturerInClientInner_->Read(buffer, userSize, isBlockingRead); - EXPECT_EQ(ret, ERR_ILLEGAL_STATE); -} -services/audio_service/test/unittest/audio_service_common_unit_test.cpp + +#include "audio_errors.h" +#include "standalone_mode_manager_unit_test.h" +#include "audio_session_info.h" +#include "audio_bundle_manager.h" +#include "audio_volume.h" +#include "audio_interrupt_service.h" +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { + +void StandaloneModeManagerUnitTest::SetUpTestCase(void) {} +void StandaloneModeManagerUnitTest::TearDownTestCase(void) {} +void StandaloneModeManagerUnitTest::SetUp(void) {} +void StandaloneModeManagerUnitTest::TearDown(void) {} + +static int32_t STANDALONE_MOED = 5; + /** -* @tc.name : Test GetTimeOfPos API -* @tc.type : FUNC -* @tc.number: GetTimeOfPos_001 -* @tc.desc : Test GetTimeOfPos interface. +* @tc.name : Test CheckAndRecordStandaloneApp. +* @tc.number: StandaloneModeManagerUnitTest_001. +* @tc.desc : Test CheckAndRecordStandaloneApp. */ -HWTEST(AudioServiceCommonUnitTest, GetTimeOfPos_001, TestSize.Level1) +HWTEST_F(StandaloneModeManagerUnitTest,StandaloneModeManagerUnitTest_001, TestSize.Level1) { - g_linearPosTimeModel = std::make_unique(); - - uint64_t posInFrame = 20; - int64_t invalidTime = -1; - g_linearPosTimeModel->stampFrame_ = 0; - g_linearPosTimeModel->sampleRate_ = 0; - int64_t retPos = g_linearPosTimeModel->GetTimeOfPos(posInFrame); - EXPECT_EQ(invalidTime, retPos); + int32_t appUid = 1; + bool isOnlyRecordUid = false; + int32_t sessionId = 1; + int32_t ownerPid = 1; + int32_t displayId = 1; + int32_t mode = STANDALONE_MOED; + std::shared_ptr interruptService = + std::make_shared(); + StandaloneModeManager::GetInstance().Init(interruptService); + StandaloneModeManager::GetInstance().EraseDeactivateAudioStream( + appUid, sessionId); + bool ret = StandaloneModeManager::GetInstance().CheckAndRecordStandaloneApp( + appUid, isOnlyRecordUid, sessionId); + EXPECT_EQ(ret, false); + StandaloneModeManager::GetInstance().SetAppSilentOnDisplay(ownerPid, displayId); + ret = StandaloneModeManager::GetInstance().CheckAndRecordStandaloneApp( + appUid, isOnlyRecordUid, sessionId); + EXPECT_EQ(ret, false); + ownerPid = 1; + StandaloneModeManager::GetInstance().ResumeAllStandaloneApp(ownerPid); } - + /** -* @tc.name : Test GetTimeOfPos API -* @tc.type : FUNC -* @tc.number: GetTimeOfPos_002 -* @tc.desc : Test GetTimeOfPos interface. +* @tc.name : Test SetAppSilentOnDisplay. +* @tc.number: StandaloneModeManagerUnitTest_002. +* @tc.desc : Test SetAppSilentOnDisplay. */ -HWTEST(AudioServiceCommonUnitTest, GetTimeOfPos_002, TestSize.Level1) +HWTEST_F(StandaloneModeManagerUnitTest, StandaloneModeManagerUnitTest_002, TestSize.Level1) { - g_linearPosTimeModel = std::make_unique(); - - uint64_t posInFrame = 1; - int64_t invalidTime = -1; - g_linearPosTimeModel->stampFrame_ = 10; - g_linearPosTimeModel->sampleRate_ = 0; - int64_t retPos = g_linearPosTimeModel->GetTimeOfPos(posInFrame); - EXPECT_EQ(invalidTime, retPos); + int32_t ownerPid = 1; + int32_t displayId = 1; + int32_t appUid = 1; + int32_t mode = STANDALONE_MOED; + std::shared_ptr interruptService = + std::make_shared(); + StandaloneModeManager::GetInstance().Init(interruptService); + auto ret = StandaloneModeManager::GetInstance().SetAppSilentOnDisplay(ownerPid, displayId); + EXPECT_EQ(ret, 0); + displayId = -1; + ret = StandaloneModeManager::GetInstance().SetAppSilentOnDisplay(ownerPid, displayId); + EXPECT_EQ(ret, 0); + ownerPid = 0; + ret = StandaloneModeManager::GetInstance().SetAppSilentOnDisplay(ownerPid, displayId); + EXPECT_EQ(ret, 0); + ownerPid = 1; + StandaloneModeManager::GetInstance().ResumeAllStandaloneApp(ownerPid); } - + /** -* @tc.name : Test Init API -* @tc.type : FUNC -* @tc.number: Init_001 -* @tc.desc : Test Init interface. +* @tc.name : Test SetAppConcurrencyMode. +* @tc.number: StandaloneModeManagerUnitTest_003 +* @tc.desc : Test SetAppConcurrencyMode. */ -HWTEST(AudioServiceCommonUnitTest, Init_001, TestSize.Level1) +HWTEST_F(StandaloneModeManagerUnitTest, StandaloneModeManagerUnitTest_003, TestSize.Level1) { - const size_t testMaxSize = 16 * 1024 * 1024 + 1; - size_t testSize = 3840; - std::unique_ptr ringCache = AudioRingCache::Create(testSize); - EXPECT_NE(nullptr, ringCache); - ringCache->cacheTotalSize_ = testMaxSize; - bool result = ringCache->Init(); - EXPECT_EQ(result, false); + int32_t ownerPid = 1; + int32_t appUid = 1; + int32_t mode = STANDALONE_MOED; + int32_t sessionId = 1; + std::shared_ptr interruptService = + std::make_shared(); + auto ret = StandaloneModeManager::GetInstance().SetAppConcurrencyMode(ownerPid, appUid, mode); + EXPECT_EQ(ret, 0); + StandaloneModeManager::GetInstance().EraseDeactivateAudioStream(appUid, sessionId); + StandaloneModeManager::GetInstance().CheckAndRecordStandaloneApp(appUid, false, sessionId); + mode = 0; + ret = StandaloneModeManager::GetInstance().SetAppConcurrencyMode(ownerPid, appUid, mode); + EXPECT_EQ(ret, 0); + StandaloneModeManager::GetInstance().CheckAndRecordStandaloneApp(appUid, false, sessionId); + StandaloneModeManager::GetInstance().EraseDeactivateAudioStream(appUid, sessionId); + mode = 1; + ret = StandaloneModeManager::GetInstance().SetAppConcurrencyMode(ownerPid, appUid, mode); + EXPECT_EQ(ret, 0); + ownerPid = 0; + ret = StandaloneModeManager::GetInstance().SetAppConcurrencyMode(ownerPid, appUid, mode); + EXPECT_EQ(ret, -1); + ownerPid = 1; + StandaloneModeManager::GetInstance().ResumeAllStandaloneApp(ownerPid); } - + /** -* @tc.name : Test Init API -* @tc.type : FUNC -* @tc.number: Init_002 -* @tc.desc : Test Init interface. +* @tc.name : Test ResumeAllStandaloneApp. +* @tc.number: StandaloneModeManagerUnitTest_004 +* @tc.desc : Test ResumeAllStandaloneApp. */ -HWTEST(AudioServiceCommonUnitTest, Init_002, TestSize.Level1) +HWTEST_F(StandaloneModeManagerUnitTest, StandaloneModeManagerUnitTest_004, TestSize.Level1) { - size_t testSize = 3840; - std::unique_ptr ringCache = AudioRingCache::Create(testSize); - EXPECT_NE(nullptr, ringCache); - ringCache->cacheTotalSize_ = -1; - bool result = ringCache->Init(); - EXPECT_EQ(result, false); + int32_t ownerPid = 1; + int32_t appUid = 1; + int32_t displayId = 1; + int32_t sessionId = 1; + bool isOnlyRecordUid = false; + int32_t mode = STANDALONE_MOED; + std::shared_ptr interruptService = + std::make_shared(); + auto ret = StandaloneModeManager::GetInstance().SetAppSilentOnDisplay(ownerPid, displayId); + EXPECT_EQ(ret, 0); + StandaloneModeManager::GetInstance().CheckAndRecordStandaloneApp( + appUid, isOnlyRecordUid, sessionId); + ownerPid = 0; + StandaloneModeManager::GetInstance().ResumeAllStandaloneApp(ownerPid); + ownerPid = 1; + StandaloneModeManager::GetInstance().ResumeAllStandaloneApp(ownerPid); } - + /** -* @tc.name : Test Create API -* @tc.type : FUNC -* @tc.number: Create_001 -* @tc.desc : Test Create interface. +* @tc.name : Test ResumeAllStandaloneApp. +* @tc.number: StandaloneModeManagerUnitTest_005 +* @tc.desc : Test ResumeAllStandaloneApp. */ -HWTEST(AudioServiceCommonUnitTest, Create_001, TestSize.Level1) +HWTEST_F(StandaloneModeManagerUnitTest, StandaloneModeManagerUnitTest_005, TestSize.Level1) { - size_t testSize = 3840; - size_t cacheSize = 16 * 1024 * 1024 + 1; - std::unique_ptr ringCache = AudioRingCache::Create(testSize); - EXPECT_NE(nullptr, ringCache); - std::unique_ptr result = ringCache->Create(cacheSize); - EXPECT_EQ(result, nullptr); + auto standaloneModeManager = new StandaloneModeManager(); + EXPECT_NE(standaloneModeManager, nullptr); + delete standaloneModeManager; } - -/services/audio_service/test/unittest/audio_group_manager_unit_test.cpp + /** -* @tc.name : Test Audio API -* @tc.type : FUNC -* @tc.number: SetVolume_004 -* @tc.desc : Test cross ring cache. +* @tc.name : Test ResumeAllStandaloneApp. +* @tc.number: StandaloneModeManagerUnitTest_006 +* @tc.desc : Test ResumeAllStandaloneApp. */ -HWTEST(AudioGroupManagerUnitTest, SetVolume_004, TestSize.Level1) +HWTEST_F(StandaloneModeManagerUnitTest, StandaloneModeManagerUnitTest_006, TestSize.Level1) { - AudioGroupManager audioGroupManager(1); - int32_t ret = audioGroupManager.SetVolume(STREAM_ALL, 0, 0, 123); - EXPECT_EQ(ret, ERR_PERMISSION_DENIED); + int32_t appUid = 1; + StandaloneModeManager::GetInstance().interruptService_ = nullptr; + EXPECT_EQ(StandaloneModeManager::GetInstance().interruptService_, nullptr); + StandaloneModeManager::GetInstance().RemoveExistingFocus(appUid); + StandaloneModeManager::GetInstance().ExitStandaloneAndResumeFocus(appUid); } + +} // namespace AudioStandard +} // namespace OHOS -/** -* @tc.name : Test Audio API -* @tc.type : FUNC -* @tc.number: SetVolume_005 -* @tc.desc : Test cross ring cache. -*/ -HWTEST(AudioGroupManagerUnitTest, SetVolume_005, TestSize.Level1) + + + +int32_t AudioSystemManager::SetAppConcurrencyMode(const int32_t appUid, const int32_t mode) { - AudioGroupManager audioGroupManager(1); - int32_t ret = audioGroupManager.SetVolume(STREAM_DEFAULT, 0, 0, 123); - EXPECT_EQ(ret, ERR_NOT_SUPPORTED); + bool ret = PermissionUtil::VerifyIsSystemApp(); + CHECK_AND_RETURN_RET_LOG(ret, ERR_SYSTEM_PERMISSION_DENIED, + "SetAppConcurrencyMode: No system permission"); + ret = PermissionUtil::VerifySelfPermission(); + CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED, + "SetAppConcurrencyMode: No system permission"); + return AudioPolicyManager::GetInstance().SetAppConcurrencyMode(appUid, mode); } - -/** -* @tc.name : Test Audio API -* @tc.type : FUNC -* @tc.number: SetVolume_006 -* @tc.desc : Test cross ring cache. -*/ -HWTEST(AudioGroupManagerUnitTest, SetVolume_006, TestSize.Level1) + +int32_t AudioSystemManager::SetAppSilentOnDisplay(const int32_t displayId) { - AudioGroupManager audioGroupManager(1); - audioGroupManager.connectType_ = CONNECT_TYPE_DISTRIBUTED; - int32_t ret = audioGroupManager.SetVolume(STREAM_DEFAULT, 0, 0, 123); - EXPECT_EQ(ret, SUCCESS); + bool ret = PermissionUtil::VerifyIsSystemApp(); + CHECK_AND_RETURN_RET_LOG(ret, ERR_SYSTEM_PERMISSION_DENIED, + "SetAppSilentOnDisplay: No system permission"); + ret = PermissionUtil::VerifySelfPermission(); + CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED, + "SetAppSilentOnDisplay: No system permission"); + return AudioPolicyManager::GetInstance().SetAppSilentOnDisplay(displayId); } -/** -* @tc.name : Test Audio API -* @tc.type : FUNC -* @tc.number: GetVolume_004 -* @tc.desc : Test cross ring cache. -*/ -HWTEST(AudioGroupManagerUnitTest, GetVolume_004, TestSize.Level1) -{ - AudioGroupManager audioGroupManager(1); - int32_t ret = audioGroupManager.GetVolume(STREAM_ACCESSIBILITY, 123); - EXPECT_EQ(ret, 5); + + + + +"fuzztest/standalonemodemanager_fuzzer:fuzztest", + + + + AudioPolicyManager::GetInstance().SetAppConcurrencyMode(appUid, mode); + AudioPolicyManager::GetInstance().SetAppSilentOnDisplay(displayId); + + + +# 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. + +import("//build/ohos.gni") +import("//build/test.gni") +import("../../../accessibility.gni") +import("../../../appgallery.gni") +import("../../../av_session.gni") +import("../../../bluetooth_part.gni") +import("../../../config.gni") + +ohos_fuzztest("StandaloneModeManagerFuzzTest") { + module_out_path = "audio_framework/audio_framework_route" + fuzz_config_file = "../standalonemodemanager_fuzzer" + + include_dirs = [ + "../../../services/audio_policy/server/include", + "../../../services/audio_policy/server/domain/zone/include", + "../../../services/audio_policy/server/src", + "../../../services/audio_policy/server/src/interface", + "../../../services/audio_policy/server/infra/async_action_handler/include", + "../../../services/audio_policy/server/domain/interrupt/include", + "../../../services/audio_policy/server/src/service/service", + "../../../services/audio_policy/client/include", + "../../../services/audio_policy/client/src", + "../../../services/audio_policy/client/proxy", + "../../../services/audio_policy/common/include", + "../../../frameworks/native/audiopolicy/include", + ] + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + "-fno-access-control", + ] + + sources = [ + "standalone_mode_manager_fuzzer.cpp", + ] + + cflags_cc = [ "-std=c++20" ] + + deps = [ + "../../../services/audio_policy:audio_policy_service_static", + "../../../services/audio_policy:audio_policy_service", + "../../../services/audio_policy:audio_policy_client", + "../../../services/audio_service/idl:audio_framework_interface", + ] + 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:app_manager", + "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", + "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", + ] + + configs = [ "../../../services/audio_policy:audio_policy_public_config" ] + + defines = [] + if (audio_framework_enable_unittest_debug) { + defines += [ "INTERRUPT_UNITTEST" ] + } + + if (audio_framework_feature_double_pnp_detect) { + defines += [ "AUDIO_DOUBLE_PNP_DETECT" ] + } + + 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 (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" ] + } +} + +group("fuzztest") { + testonly = true + deps = [ ":StandaloneModeManagerFuzzTest" ] } -/** -* @tc.name : Test Audio API -* @tc.type : FUNC -* @tc.number: GetVolume_005 -* @tc.desc : Test cross ring cache. + + + + + + + + + + + + 1000 + + 300 + + 4096 + + + + + + + +/* +* 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. */ -HWTEST(AudioGroupManagerUnitTest, GetVolume_005, TestSize.Level1) + +#include "standalone_mode_manager.h" +#include "audio_interrupt_service.h" +#include "audio_session_info.h" +#include "audio_bundle_manager.h" +#include "audio_volume.h" +using namespace std; + +namespace OHOS { +namespace AudioStandard { + +static const uint8_t* RAW_DATA = nullptr; +static size_t g_dataSize = 0; +static size_t g_pos; +const size_t THRESHOLD = 10; +typedef void (*TestPtr)(); + +template +uint32_t GetArrLength(T& arr) { - AudioGroupManager audioGroupManager(1); - audioGroupManager.connectType_ = CONNECT_TYPE_DISTRIBUTED; - int32_t ret = audioGroupManager.GetVolume(STREAM_ACCESSIBILITY, 123); - EXPECT_EQ(ret, 0); + if (arr == nullptr) { + AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__); + return 0; + } + return sizeof(arr) / sizeof(arr[0]); } - -/** -* @tc.name : Test Audio API -* @tc.type : FUNC -* @tc.number: GetMaxVolume_004 -* @tc.desc : Test cross ring cache. -*/ -HWTEST(AudioGroupManagerUnitTest, GetMaxVolume_004, TestSize.Level1) + +template +T GetData() { - AudioGroupManager audioGroupManager(1); - audioGroupManager.connectType_ = CONNECT_TYPE_DISTRIBUTED; - int32_t ret = audioGroupManager.GetMaxVolume(STREAM_ULTRASONIC); - EXPECT_EQ(ret, 0); + T object {}; + size_t objectSize = sizeof(object); + if (g_dataSize < g_pos) { + return object; + } + if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) { + return object; + } + errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize); + if (ret != EOK) { + return {}; + } + g_pos += objectSize; + return object; } - -/** -* @tc.name : Test Audio API -* @tc.type : FUNC -* @tc.number: IsStreamMute_003 -* @tc.desc : Test cross ring cache. -*/ -HWTEST(AudioGroupManagerUnitTest, IsStreamMute_003, TestSize.Level1) + +void StandaloneModeManagerInItFuzzTest() { - AudioGroupManager audioGroupManager(1); - audioGroupManager.connectType_ = ConnectType::CONNECT_TYPE_LOCAL; - bool isMute = false; - int32_t ret = audioGroupManager.IsStreamMute(AudioStreamType::STREAM_ACCESSIBILITY, isMute); - EXPECT_EQ(ret, SUCCESS); + std::shared_ptr interruptService = + std::make_shared(); + StandaloneModeManager::GetInstance().Init(interruptService); } - -/** -* @tc.name : Test Audio API -* @tc.type : FUNC -* @tc.number: IsStreamMute_004 -* @tc.desc : Test cross ring cache. -*/ -HWTEST(AudioGroupManagerUnitTest, IsStreamMute_004, TestSize.Level1) + +void StandaloneModeManagerCheckAndRecordStandaloneAppFuzzTest() { - AudioGroupManager audioGroupManager(1); - audioGroupManager.connectType_ = ConnectType::CONNECT_TYPE_LOCAL; - bool isMute = false; - int32_t ret = audioGroupManager.IsStreamMute(AudioStreamType::STREAM_ALL, isMute); - EXPECT_EQ(ret, SUCCESS); + std::shared_ptr interruptService = + std::make_shared(); + StandaloneModeManager::GetInstance().Init(interruptService); + int32_t appUid = GetData(); + int32_t sessionId = GetData(); + bool isOnlyRecordUid = GetData(); + StandaloneModeManager::GetInstance().CheckAndRecordStandaloneApp(appUid, + isOnlyRecordUid, sessionId); } - -/frameworks/native/toneplayer/test/unittest/audio_toneplayer_unit_test.cpp -/** - * @tc.name : Test TonePlayerImpl API - * @tc.type : FUNC - * @tc.number: TonePlayerImpl_025 - * @tc.desc : Test CheckToneStopped interface. - */ -HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_025, TestSize.Level4) + +void StandaloneModeManagerSetAppSilentOnDisplayFuzzTest() { - AudioRendererInfo rendererInfo = {}; - rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC; - rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF; - rendererInfo.rendererFlags = 0; - - std::shared_ptr toneplayer = std::make_shared("", rendererInfo); - EXPECT_NE(toneplayer, nullptr); - - toneplayer->toneInfo_ = std::make_shared(); - EXPECT_NE(toneplayer->toneInfo_, nullptr); - - toneplayer->toneState_ = TonePlayerImpl::TONE_STARTING; - toneplayer->currSegment_ = 0; - toneplayer->totalSample_ = 9000; - toneplayer->maxSample_ = 8000; - toneplayer->toneInfo_->segments[1].duration = 1; - - bool ret = toneplayer->CheckToneStopped(); - EXPECT_EQ(ret, true); + std::shared_ptr interruptService = + std::make_shared(); + StandaloneModeManager::GetInstance().Init(interruptService); + int32_t ownerPid = GetData(); + int32_t displayId = GetData(); + StandaloneModeManager::GetInstance().SetAppSilentOnDisplay(ownerPid, displayId); } - -/** - * @tc.name : Test TonePlayerImpl API - * @tc.type : FUNC - * @tc.number: TonePlayerImpl_026 - * @tc.desc : Test CheckToneStopped interface. - */ -HWTEST(AudioToneplayerUnitTest, TonePlayerImpl_026, TestSize.Level4) + +void StandaloneModeManagerSetAppConcurrencyModeFuzzTest() { - AudioRendererInfo rendererInfo = {}; - rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC; - rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_DTMF; - rendererInfo.rendererFlags = 0; - - std::shared_ptr toneplayer = std::make_shared("", rendererInfo); - EXPECT_NE(toneplayer, nullptr); + std::shared_ptr interruptService = + std::make_shared(); + StandaloneModeManager::GetInstance().Init(interruptService); + int32_t ownerPid = GetData(); + int32_t appUid = GetData(); + int32_t mode = GetData(); + StandaloneModeManager::GetInstance().SetAppConcurrencyMode(ownerPid, appUid, mode); +} + +void StandaloneModeManagerEraseDeactivateAudioStreamFuzzTest() +{ + std::shared_ptr interruptService = + std::make_shared(); + StandaloneModeManager::GetInstance().Init(interruptService); + int32_t appUid = GetData(); + int32_t sessionId = GetData(); + StandaloneModeManager::GetInstance().EraseDeactivateAudioStream(appUid, sessionId); +} + +void StandaloneModeManagerResumeAllStandaloneAppFuzzTest() +{ + std::shared_ptr interruptService = + std::make_shared(); + StandaloneModeManager::GetInstance().Init(interruptService); + int32_t appUid = GetData(); + StandaloneModeManager::GetInstance().ResumeAllStandaloneApp(appUid); +} + +TestPtr g_testPtrs[] = { + StandaloneModeManagerInItFuzzTest, + StandaloneModeManagerCheckAndRecordStandaloneAppFuzzTest, + StandaloneModeManagerSetAppSilentOnDisplayFuzzTest, + StandaloneModeManagerSetAppConcurrencyModeFuzzTest, + StandaloneModeManagerEraseDeactivateAudioStreamFuzzTest, + StandaloneModeManagerResumeAllStandaloneAppFuzzTest, +}; + +void FuzzTest(const uint8_t* rawData, size_t size) +{ + if (rawData == nullptr) { + return; + } + + RAW_DATA = rawData; + g_dataSize = size; + g_pos = 0; + + uint32_t code = GetData(); + uint32_t len = GetArrLength(g_testPtrs); + if (len > 0) { + g_testPtrs[code % len](); + } else { + AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__); + } + return; +} + +} // namespace AudioStandard +} // namesapce OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) +{ + if (size < OHOS::AudioStandard::THRESHOLD) { + return 0; + } + OHOS::AudioStandard::FuzzTest(data, size); + return 0; +} - toneplayer->toneInfo_ = std::make_shared(); - EXPECT_NE(toneplayer->toneInfo_, nullptr); - toneplayer->toneState_ = TonePlayerImpl::TONE_STARTING; - toneplayer->currSegment_ = 0; - toneplayer->totalSample_ = 8000; - toneplayer->maxSample_ = 8000; - toneplayer->toneInfo_->segments[1].duration = 0; - bool ret = toneplayer->CheckToneStopped(); - EXPECT_EQ(ret, true); -} + server->interruptService_ = std::make_shared(); + int32_t result = server->DeactivateAudioInterrupt(audioInterrupt, zoneID -- Gitee From 30802e684ad6e190dbc18367c3002ba572f2e3c9 Mon Sep 17 00:00:00 2001 From: weiyuantian Date: Wed, 20 Aug 2025 08:47:56 +0000 Subject: [PATCH 03/20] update services/audio_service/test/unittest/audio_0820_DT_test. Signed-off-by: weiyuantian --- .../test/unittest/audio_0820_DT_test | 916 +++++------------- 1 file changed, 225 insertions(+), 691 deletions(-) diff --git a/services/audio_service/test/unittest/audio_0820_DT_test b/services/audio_service/test/unittest/audio_0820_DT_test index c354f28836..241f483e12 100644 --- a/services/audio_service/test/unittest/audio_0820_DT_test +++ b/services/audio_service/test/unittest/audio_0820_DT_test @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. + * 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 @@ -13,769 +13,303 @@ * limitations under the License. */ -#ifndef STANDALONE_MODE_MANAGER_UNIT_TEST_H -#define STANDALONE_MODE_MANAGER_UNIT_TEST_H +#ifndef ST_STANDALONE_MODE_MANAGER_H +#define ST_STANDALONE_MODE_MANAGER_H + +#include +#include +#include +#include "audio_info.h" -#include "gtest/gtest.h" -#include "audio_interrupt_service.h" -#include "standalone_mode_manager.h" namespace OHOS { namespace AudioStandard { -class StandaloneModeManagerUnitTest : public testing::Test { +static constexpr int32_t INVALID_ID = INT_MIN; + +class AudioInterruptService; +class StandaloneModeManager { +private: + static std::mutex instanceMutex; + static StandaloneModeManager* instance; 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 StandaloneModeManager &GetInstance(); + void Init(std::shared_ptr interruptService); + bool CheckAndRecordStandaloneApp(const int32_t appUid, const bool isOnlyRecordUid = true, + const int32_t sessionId = -1); + int32_t SetAppSilentOnDisplay(const int32_t ownerPid, const int32_t displayId); + int32_t SetAppConcurrencyMode(const int32_t ownerPid, + const int32_t appUid, const int32_t mode); + void EraseDeactivateAudioStream(const int32_t appUid, + const int32_t sessionId); + void ResumeAllStandaloneApp(const int32_t appPid); + +private: + StandaloneModeManager() = default; + ~StandaloneModeManager(); + StandaloneModeManager(const StandaloneModeManager&) = delete; + StandaloneModeManager &operator = (const StandaloneModeManager&) = delete; + + void CleanAllStandaloneInfo(); + void RemoveExistingFocus(const int32_t appUid); + bool CheckOwnerPidPermissions(const int32_t ownerPid); + void ExitStandaloneAndResumeFocus(const int32_t appUid); + bool CheckAppOnVirtualScreenByUid(const int32_t appUid); + void RecordStandaloneAppSessionIdInfo(const int32_t appUid, const bool isOnlyRecordUid = true, + const int32_t sessionId = -1); + + std::recursive_mutex mutex_; + std::shared_ptr interruptService_; + int32_t ownerPid_ = INVALID_ID; + int32_t displayId_ = INVALID_ID; + bool isSetSilentDisplay_ = false; + std::unordered_map>activeZoneSessionsMap_; //{appUid {sessionId}} }; } // namespace AudioStandard } // namespace OHOS -#endif // STANDALONE_MODE_MANAGER_UNIT_TEST_H - - - - - - - -/** -* @tc.name : Test AudioInterruptService -* @tc.number: AudioInterruptService_045 -* @tc.desc : Test AudioInterruptService_045 -*/ -HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_045, TestSize.Level1) -{ - auto audioInterruptService = std::make_shared(); - ASSERT_NE(audioInterruptService, nullptr); - - int32_t fakePid = 123; - AudioInterrupt incomingInterrupt; - incomingInterrupt.pid = fakePid; - incomingInterrupt.audioFocusType.streamType = STREAM_MUSIC; - AudioSessionStrategy audioSessionStrategy; - InterruptEventInternal interruptEvent; - audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT; - audioInterruptService->sessionService_ = AudioSessionService::GetAudioSessionService(); - audioInterruptService->sessionService_->sessionMap_[fakePid] = nullptr; - auto ret = audioInterruptService->ActivateAudioSession(1, fakePid, audioSessionStrategy, true); - audioInterruptService->ResumeFocusByStreamId(fakePid, interruptEvent); - EXPECT_EQ(ERROR, ret); -} - - - - - - -/** - * @tc.name : Test AudioInterruptService. - * @tc.number: AudioInterruptService_RemoveExistingFocus_001 - * @tc.desc : Test RemoveExistingFocus. - */ -HWTEST(AudioInterruptUnitTest, AudioInterruptService_RemoveExistingFocus_001, TestSize.Level1) -{ - auto interruptServiceTest = GetTnterruptServiceTest(); - interruptServiceTest->zonesMap_.clear(); - int32_t appUid = 1; - auto audioInterruptZone = std::make_shared(); - AudioInterrupt audioInterrupt1; - audioInterrupt1.sessionId = 100; - audioInterrupt1.uid = 1; - std::unordered_set uidActivedSessions; - audioInterruptZone->audioFocusInfoList.clear(); - audioInterruptZone->audioFocusInfoList.emplace_back(audioInterrupt1, AudioFocuState{PAUSE}); - EXPECT_EQ(interruptServiceTest->zonesMap_.find(0), interruptServiceTest->zonesMap_.end()); - interruptServiceTest->zonesMap_[0] = std::make_shared(); - interruptServiceTest->zonesMap_[1] = audioInterruptZone; - interruptServiceTest->zonesMap_[2] = std::make_shared(); - interruptServiceTest->RemoveExistingFocus(appUid, uidActivedSessions); -} -/** - * @tc.name : Test AudioInterruptService. - * @tc.number: AudioInterruptService_ResumeFocusByStreamId_001 - * @tc.desc : Test ResumeFocusByStreamId. - */ -HWTEST(AudioInterruptUnitTest, AudioInterruptService_ResumeFocusByStreamId_001, TestSize.Level1) -{ - auto interruptServiceTest = GetTnterruptServiceTest(); - InterruptEventInternal interruptEvent; - interruptServiceTest->ResumeFocusByStreamId(0, interruptEvent); - interruptServiceTest->zonesMap_[0] = std::make_shared(); - auto retStatus = interruptServiceTest->SetAudioInterruptCallback(0, 0, - sptr::MakeSptr(), 0); - EXPECT_EQ(retStatus, SUCCESS); - interruptServiceTest->ResumeFocusByStreamId(0, interruptEvent); -} - - +#endif // ST_STANDALONE_MODE_MANAGER_H - ret = interruptService->ActivateAudioSession(0, incomingInterrupt.pid, strategyTest, true); - EXPECT_EQ(SUCCESS, ret); - ret = interruptService->CanMixForSession( - - -/** - * @tc.name : Test AudioInterruptUnitTest. - * @tc.number: SetAppConcurrencyMode_001 - * @tc.desc : Test SetAppConcurrencyMode. - */ -HWTEST(AudioInterruptUnitTest, SetAppConcurrencyMode_001, TestSize.Level1) -{ - sptr server = GetPolicyServerTest(); - ASSERT_TRUE(server != nullptr); - int32_t uid = 0; - int32_t mode = 0; - auto ret = server->SetAppConcurrencyMode(uid, mode); - EXPECT_EQ(ret, SUCCESS); - server->interruptService_ = nullptr; - ret = server->SetAppConcurrencyMode(uid, mode); - server->interruptService_ = std::make_shared(); - EXPECT_EQ(ret, ERR_UNKNOWN); -} - -/** - * @tc.name : Test AudioInterruptUnitTest. - * @tc.number: SetAppSilentOnDisplay_001 - * @tc.desc : Test SetAppSilentOnDisplay. +/* + * 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. */ -HWTEST(AudioInterruptUnitTest, SetAppSilentOnDisplay_001, TestSize.Level1) -{ - sptr server = GetPolicyServerTest(); - ASSERT_TRUE(server != nullptr); - int32_t displayId = 1; - auto ret = server->SetAppSilentOnDisplay(displayId); - EXPECT_EQ(ret, SUCCESS); - server->interruptService_ = nullptr; - ret = server->SetAppSilentOnDisplay(displayId); - server->interruptService_ = std::make_shared(); - EXPECT_EQ(ret, ERR_UNKNOWN); -} - -/** -* @tc.name : Test AudioInterruptUnitTest. -* @tc.number: AudioPolicyServer_009 -* @tc.desc : Test DeactivateAudioInterrupt. -*/ -HWTEST(AudioInterruptUnitTest, AudioPolicyServer_001, TestSize.Level1) -{ - auto policyServerTest = GetPolicyServerTest(); - int32_t systemAbilityId = 3009; - bool runOnCreate = false; - sptr server = sptr::MakeSptr(systemAbilityId, runOnCreate); +#ifndef LOG_TAG +#define LOG_TAG "StandaloneModeManager" +#endif - AudioInterrupt audioInterrupt; - int32_t zoneID = 456; - pid_t pid = 1; - pid_t uid = 1; - int32_t strategy = 0; - server->interruptService_ = std::make_shared(); - int32_t result = server->DeactivateAudioInterrupt(audioInterrupt, zoneID); - EXPECT_EQ(result, ERR_UNKNOWN); - EXPECT_EQ(policyServerTest->ActivateAudioSession(strategy), SUCCESS); - server->RegisteredStreamListenerClientDied(pid, uid); -} - - - - -#include "audio_errors.h" -#include "standalone_mode_manager_unit_test.h" +#include "standalone_mode_manager.h" +#include "audio_log.h" #include "audio_session_info.h" #include "audio_bundle_manager.h" +#include "window_manager.h" #include "audio_volume.h" #include "audio_interrupt_service.h" -using namespace testing::ext; namespace OHOS { namespace AudioStandard { -void StandaloneModeManagerUnitTest::SetUpTestCase(void) {} -void StandaloneModeManagerUnitTest::TearDownTestCase(void) {} -void StandaloneModeManagerUnitTest::SetUp(void) {} -void StandaloneModeManagerUnitTest::TearDown(void) {} - -static int32_t STANDALONE_MOED = 5; - -/** -* @tc.name : Test CheckAndRecordStandaloneApp. -* @tc.number: StandaloneModeManagerUnitTest_001. -* @tc.desc : Test CheckAndRecordStandaloneApp. -*/ -HWTEST_F(StandaloneModeManagerUnitTest,StandaloneModeManagerUnitTest_001, TestSize.Level1) -{ - int32_t appUid = 1; - bool isOnlyRecordUid = false; - int32_t sessionId = 1; - int32_t ownerPid = 1; - int32_t displayId = 1; - int32_t mode = STANDALONE_MOED; - std::shared_ptr interruptService = - std::make_shared(); - StandaloneModeManager::GetInstance().Init(interruptService); - StandaloneModeManager::GetInstance().EraseDeactivateAudioStream( - appUid, sessionId); - bool ret = StandaloneModeManager::GetInstance().CheckAndRecordStandaloneApp( - appUid, isOnlyRecordUid, sessionId); - EXPECT_EQ(ret, false); - StandaloneModeManager::GetInstance().SetAppSilentOnDisplay(ownerPid, displayId); - ret = StandaloneModeManager::GetInstance().CheckAndRecordStandaloneApp( - appUid, isOnlyRecordUid, sessionId); - EXPECT_EQ(ret, false); - ownerPid = 1; - StandaloneModeManager::GetInstance().ResumeAllStandaloneApp(ownerPid); -} +std::mutex StandaloneModeManager::instanceMutex; +StandaloneModeManager* StandaloneModeManager::instance; -/** -* @tc.name : Test SetAppSilentOnDisplay. -* @tc.number: StandaloneModeManagerUnitTest_002. -* @tc.desc : Test SetAppSilentOnDisplay. -*/ -HWTEST_F(StandaloneModeManagerUnitTest, StandaloneModeManagerUnitTest_002, TestSize.Level1) +StandaloneModeManager &StandaloneModeManager::GetInstance() { - int32_t ownerPid = 1; - int32_t displayId = 1; - int32_t appUid = 1; - int32_t mode = STANDALONE_MOED; - std::shared_ptr interruptService = - std::make_shared(); - StandaloneModeManager::GetInstance().Init(interruptService); - auto ret = StandaloneModeManager::GetInstance().SetAppSilentOnDisplay(ownerPid, displayId); - EXPECT_EQ(ret, 0); - displayId = -1; - ret = StandaloneModeManager::GetInstance().SetAppSilentOnDisplay(ownerPid, displayId); - EXPECT_EQ(ret, 0); - ownerPid = 0; - ret = StandaloneModeManager::GetInstance().SetAppSilentOnDisplay(ownerPid, displayId); - EXPECT_EQ(ret, 0); - ownerPid = 1; - StandaloneModeManager::GetInstance().ResumeAllStandaloneApp(ownerPid); -} - -/** -* @tc.name : Test SetAppConcurrencyMode. -* @tc.number: StandaloneModeManagerUnitTest_003 -* @tc.desc : Test SetAppConcurrencyMode. -*/ -HWTEST_F(StandaloneModeManagerUnitTest, StandaloneModeManagerUnitTest_003, TestSize.Level1) -{ - int32_t ownerPid = 1; - int32_t appUid = 1; - int32_t mode = STANDALONE_MOED; - int32_t sessionId = 1; - std::shared_ptr interruptService = - std::make_shared(); - auto ret = StandaloneModeManager::GetInstance().SetAppConcurrencyMode(ownerPid, appUid, mode); - EXPECT_EQ(ret, 0); - StandaloneModeManager::GetInstance().EraseDeactivateAudioStream(appUid, sessionId); - StandaloneModeManager::GetInstance().CheckAndRecordStandaloneApp(appUid, false, sessionId); - mode = 0; - ret = StandaloneModeManager::GetInstance().SetAppConcurrencyMode(ownerPid, appUid, mode); - EXPECT_EQ(ret, 0); - StandaloneModeManager::GetInstance().CheckAndRecordStandaloneApp(appUid, false, sessionId); - StandaloneModeManager::GetInstance().EraseDeactivateAudioStream(appUid, sessionId); - mode = 1; - ret = StandaloneModeManager::GetInstance().SetAppConcurrencyMode(ownerPid, appUid, mode); - EXPECT_EQ(ret, 0); - ownerPid = 0; - ret = StandaloneModeManager::GetInstance().SetAppConcurrencyMode(ownerPid, appUid, mode); - EXPECT_EQ(ret, -1); - ownerPid = 1; - StandaloneModeManager::GetInstance().ResumeAllStandaloneApp(ownerPid); + std::lock_guard lock(instanceMutex); + if (instance == nullptr) { + instance = new StandaloneModeManager(); + } + return *instance; } -/** -* @tc.name : Test ResumeAllStandaloneApp. -* @tc.number: StandaloneModeManagerUnitTest_004 -* @tc.desc : Test ResumeAllStandaloneApp. -*/ -HWTEST_F(StandaloneModeManagerUnitTest, StandaloneModeManagerUnitTest_004, TestSize.Level1) +void StandaloneModeManager::Init(std::shared_ptr interruptService) { - int32_t ownerPid = 1; - int32_t appUid = 1; - int32_t displayId = 1; - int32_t sessionId = 1; - bool isOnlyRecordUid = false; - int32_t mode = STANDALONE_MOED; - std::shared_ptr interruptService = - std::make_shared(); - auto ret = StandaloneModeManager::GetInstance().SetAppSilentOnDisplay(ownerPid, displayId); - EXPECT_EQ(ret, 0); - StandaloneModeManager::GetInstance().CheckAndRecordStandaloneApp( - appUid, isOnlyRecordUid, sessionId); - ownerPid = 0; - StandaloneModeManager::GetInstance().ResumeAllStandaloneApp(ownerPid); - ownerPid = 1; - StandaloneModeManager::GetInstance().ResumeAllStandaloneApp(ownerPid); + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_LOG(interruptService != nullptr, + "interruptService is nullptr"); + interruptService_ = interruptService; } -/** -* @tc.name : Test ResumeAllStandaloneApp. -* @tc.number: StandaloneModeManagerUnitTest_005 -* @tc.desc : Test ResumeAllStandaloneApp. -*/ -HWTEST_F(StandaloneModeManagerUnitTest, StandaloneModeManagerUnitTest_005, TestSize.Level1) +StandaloneModeManager::~StandaloneModeManager() { - auto standaloneModeManager = new StandaloneModeManager(); - EXPECT_NE(standaloneModeManager, nullptr); - delete standaloneModeManager; + CleanAllStandaloneInfo(); } -/** -* @tc.name : Test ResumeAllStandaloneApp. -* @tc.number: StandaloneModeManagerUnitTest_006 -* @tc.desc : Test ResumeAllStandaloneApp. -*/ -HWTEST_F(StandaloneModeManagerUnitTest, StandaloneModeManagerUnitTest_006, TestSize.Level1) +int32_t StandaloneModeManager::SetAppSilentOnDisplay(const int32_t ownerPid, const int32_t displayId) { - int32_t appUid = 1; - StandaloneModeManager::GetInstance().interruptService_ = nullptr; - EXPECT_EQ(StandaloneModeManager::GetInstance().interruptService_, nullptr); - StandaloneModeManager::GetInstance().RemoveExistingFocus(appUid); - StandaloneModeManager::GetInstance().ExitStandaloneAndResumeFocus(appUid); + std::lock_guard lock(mutex_); + if (!CheckOwnerPidPermissions(ownerPid)) { + return -1; + } + isSetSilentDisplay_ = displayId > 0 ? true : false; + displayId_ = isSetSilentDisplay_ ? displayId : INVALID_ID; + if (displayId == -1) { + ResumeAllStandaloneApp(ownerPid); + } + return 0; } -} // namespace AudioStandard -} // namespace OHOS - - - - -int32_t AudioSystemManager::SetAppConcurrencyMode(const int32_t appUid, const int32_t mode) +bool StandaloneModeManager::CheckOwnerPidPermissions(const int32_t ownerPid) { - bool ret = PermissionUtil::VerifyIsSystemApp(); - CHECK_AND_RETURN_RET_LOG(ret, ERR_SYSTEM_PERMISSION_DENIED, - "SetAppConcurrencyMode: No system permission"); - ret = PermissionUtil::VerifySelfPermission(); - CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED, - "SetAppConcurrencyMode: No system permission"); - return AudioPolicyManager::GetInstance().SetAppConcurrencyMode(appUid, mode); + std::lock_guard lock(mutex_); + if (ownerPid_ == INVALID_ID) { + ownerPid_ = ownerPid; + AUDIO_INFO_LOG("Init Owner Pid is %{public}d", ownerPid); + } else if (ownerPid != ownerPid_) { + AUDIO_ERR_LOG("currentAppPid %{public}d ownerPid %{public}d ", ownerPid, ownerPid_); + return false; + } + return true; } -int32_t AudioSystemManager::SetAppSilentOnDisplay(const int32_t displayId) +void StandaloneModeManager::ExitStandaloneAndResumeFocus(const int32_t appUid) { - bool ret = PermissionUtil::VerifyIsSystemApp(); - CHECK_AND_RETURN_RET_LOG(ret, ERR_SYSTEM_PERMISSION_DENIED, - "SetAppSilentOnDisplay: No system permission"); - ret = PermissionUtil::VerifySelfPermission(); - CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED, - "SetAppSilentOnDisplay: No system permission"); - return AudioPolicyManager::GetInstance().SetAppSilentOnDisplay(displayId); -} - - - - - -"fuzztest/standalonemodemanager_fuzzer:fuzztest", - - - - AudioPolicyManager::GetInstance().SetAppConcurrencyMode(appUid, mode); - AudioPolicyManager::GetInstance().SetAppSilentOnDisplay(displayId); - - - -# 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. - -import("//build/ohos.gni") -import("//build/test.gni") -import("../../../accessibility.gni") -import("../../../appgallery.gni") -import("../../../av_session.gni") -import("../../../bluetooth_part.gni") -import("../../../config.gni") - -ohos_fuzztest("StandaloneModeManagerFuzzTest") { - module_out_path = "audio_framework/audio_framework_route" - fuzz_config_file = "../standalonemodemanager_fuzzer" - - include_dirs = [ - "../../../services/audio_policy/server/include", - "../../../services/audio_policy/server/domain/zone/include", - "../../../services/audio_policy/server/src", - "../../../services/audio_policy/server/src/interface", - "../../../services/audio_policy/server/infra/async_action_handler/include", - "../../../services/audio_policy/server/domain/interrupt/include", - "../../../services/audio_policy/server/src/service/service", - "../../../services/audio_policy/client/include", - "../../../services/audio_policy/client/src", - "../../../services/audio_policy/client/proxy", - "../../../services/audio_policy/common/include", - "../../../frameworks/native/audiopolicy/include", - ] - - cflags = [ - "-g", - "-O0", - "-Wno-unused-variable", - "-fno-omit-frame-pointer", - "-fno-access-control", - ] - - sources = [ - "standalone_mode_manager_fuzzer.cpp", - ] - - cflags_cc = [ "-std=c++20" ] - - deps = [ - "../../../services/audio_policy:audio_policy_service_static", - "../../../services/audio_policy:audio_policy_service", - "../../../services/audio_policy:audio_policy_client", - "../../../services/audio_service/idl:audio_framework_interface", - ] - 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:app_manager", - "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", - "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", - ] - - configs = [ "../../../services/audio_policy:audio_policy_public_config" ] - - defines = [] - if (audio_framework_enable_unittest_debug) { - defines += [ "INTERRUPT_UNITTEST" ] - } - - if (audio_framework_feature_double_pnp_detect) { - defines += [ "AUDIO_DOUBLE_PNP_DETECT" ] - } - - 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 (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" ] - } -} - -group("fuzztest") { - testonly = true - deps = [ ":StandaloneModeManagerFuzzTest" ] -} - - - - - - - - - - - - - 1000 - - 300 - - 4096 - - - - - - - -/* -* 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 "standalone_mode_manager.h" -#include "audio_interrupt_service.h" -#include "audio_session_info.h" -#include "audio_bundle_manager.h" -#include "audio_volume.h" -using namespace std; - -namespace OHOS { -namespace AudioStandard { - -static const uint8_t* RAW_DATA = nullptr; -static size_t g_dataSize = 0; -static size_t g_pos; -const size_t THRESHOLD = 10; -typedef void (*TestPtr)(); + std::lock_guard lock(mutex_); + if (interruptService_ == nullptr) { + return; + } + if (activeZoneSessionsMap_.find(appUid) == activeZoneSessionsMap_.end()) { + AUDIO_ERR_LOG("Exit Standalone Focus Not Find"); + return; + } -template -uint32_t GetArrLength(T& arr) -{ - if (arr == nullptr) { - AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__); - return 0; + auto standaloneAppSessionsList = activeZoneSessionsMap_[appUid]; + for (auto &sessionId : standaloneAppSessionsList) { + InterruptEventInternal interruptEventResume {INTERRUPT_TYPE_BEGIN, + INTERRUPT_SHARE, INTERRUPT_HINT_EXIT_STANDALONE, 1.0f}; + interruptService_->ResumeFocusByStreamId(sessionId, interruptEventResume); } - return sizeof(arr) / sizeof(arr[0]); + activeZoneSessionsMap_.erase(appUid); } -template -T GetData() +void StandaloneModeManager::ResumeAllStandaloneApp(const int32_t appPid) { - T object {}; - size_t objectSize = sizeof(object); - if (g_dataSize < g_pos) { - return object; - } - if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) { - return object; + std::lock_guard lock(mutex_); + if (appPid != ownerPid_) { + return; } - errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize); - if (ret != EOK) { - return {}; + AUDIO_INFO_LOG("Begin Resume All Standalone App"); + if (!activeZoneSessionsMap_.empty()) { + auto tempActiveZoneSessionsMap = activeZoneSessionsMap_; + for (auto &[appUid, _] : tempActiveZoneSessionsMap) { + ExitStandaloneAndResumeFocus(appUid); + AudioVolume::GetInstance()->SetAppVolumeMute(appUid, false); + } } - g_pos += objectSize; - return object; + CleanAllStandaloneInfo(); } -void StandaloneModeManagerInItFuzzTest() +void StandaloneModeManager::CleanAllStandaloneInfo() { - std::shared_ptr interruptService = - std::make_shared(); - StandaloneModeManager::GetInstance().Init(interruptService); + std::lock_guard lock(mutex_); + ownerPid_ = INVALID_ID; + displayId_ = INVALID_ID; + isSetSilentDisplay_ = false; + activeZoneSessionsMap_.clear(); } -void StandaloneModeManagerCheckAndRecordStandaloneAppFuzzTest() +void StandaloneModeManager::RemoveExistingFocus(const int32_t appUid) { - std::shared_ptr interruptService = - std::make_shared(); - StandaloneModeManager::GetInstance().Init(interruptService); - int32_t appUid = GetData(); - int32_t sessionId = GetData(); - bool isOnlyRecordUid = GetData(); - StandaloneModeManager::GetInstance().CheckAndRecordStandaloneApp(appUid, - isOnlyRecordUid, sessionId); + std::lock_guard lock(mutex_); + if (interruptService_ == nullptr) { + return; + } + std::unordered_set uidActivedSessions = {}; + interruptService_->RemoveExistingFocus(appUid, uidActivedSessions); + if (!uidActivedSessions.empty()) { + for (auto sessionId : uidActivedSessions) { + activeZoneSessionsMap_[appUid].insert(sessionId); + } + } } -void StandaloneModeManagerSetAppSilentOnDisplayFuzzTest() +int32_t StandaloneModeManager::SetAppConcurrencyMode(const int32_t ownerPid, + const int32_t appUid, const int32_t mode) { - std::shared_ptr interruptService = - std::make_shared(); - StandaloneModeManager::GetInstance().Init(interruptService); - int32_t ownerPid = GetData(); - int32_t displayId = GetData(); - StandaloneModeManager::GetInstance().SetAppSilentOnDisplay(ownerPid, displayId); + std::lock_guard lock(mutex_); + AUDIO_INFO_LOG("Set App Concurrency Mode : ownerPid = %{public}d Standalone" + "appUid = %{public}d concurrencyMode = %{public}d", ownerPid, appUid, mode); + if (!CheckOwnerPidPermissions(ownerPid)) { + return -1; + } + AudioConcurrencyMode concurrencyMode = static_cast(mode); + switch (concurrencyMode) { + case AudioConcurrencyMode::STANDALONE: + RecordStandaloneAppSessionIdInfo(appUid); + RemoveExistingFocus(appUid); + break; + case AudioConcurrencyMode::DEFAULT: + ExitStandaloneAndResumeFocus(appUid); + break; + default: + break; + } + return 0; } -void StandaloneModeManagerSetAppConcurrencyModeFuzzTest() +bool StandaloneModeManager::CheckAppOnVirtualScreenByUid(const int32_t appUid) { - std::shared_ptr interruptService = - std::make_shared(); - StandaloneModeManager::GetInstance().Init(interruptService); - int32_t ownerPid = GetData(); - int32_t appUid = GetData(); - int32_t mode = GetData(); - StandaloneModeManager::GetInstance().SetAppConcurrencyMode(ownerPid, appUid, mode); + std::lock_guard lock(mutex_); + std::string bundleName = AudioBundleManager::GetBundleNameFromUid(appUid); + if (bundleName.empty()) { + AUDIO_ERR_LOG("Get BundleName From Uid Fail"); + return false; + } + OHOS::Rosen::WindowInfoOption windowInfoOption = {}; + windowInfoOption.displayId = displayId_; + std::vector> ogInfos = {}; + auto ret = OHOS::Rosen::WindowManager::GetInstance().ListWindowInfo(windowInfoOption, ogInfos); + AUDIO_INFO_LOG("ListWindowIfo size is %{public}d, ret = %{public}d", + static_cast(ogInfos.size()), ret); + for (auto &iter : ogInfos) { + if (iter->windowMetaInfo.bundleName == bundleName) { + AUDIO_INFO_LOG("Exist Standalone App On Virtual Screen ownerUid" + " = %{public}d, bundleName = %{public}s", appUid, bundleName.c_str()); + return true; + } + } + return false; } -void StandaloneModeManagerEraseDeactivateAudioStreamFuzzTest() +bool StandaloneModeManager::CheckAndRecordStandaloneApp(const int32_t appUid, + const bool isOnlyRecordUid, const int32_t sessionId) { - std::shared_ptr interruptService = - std::make_shared(); - StandaloneModeManager::GetInstance().Init(interruptService); - int32_t appUid = GetData(); - int32_t sessionId = GetData(); - StandaloneModeManager::GetInstance().EraseDeactivateAudioStream(appUid, sessionId); + std::lock_guard lock(mutex_); + if (ownerPid_ == INVALID_ID && !isSetSilentDisplay_) { + AUDIO_ERR_LOG("Standalone Mode Not Activation"); + return false; + } + if (activeZoneSessionsMap_.find(appUid) != activeZoneSessionsMap_.end()) { + RecordStandaloneAppSessionIdInfo(appUid, isOnlyRecordUid, sessionId); + return true; + } + if (isSetSilentDisplay_ && CheckAppOnVirtualScreenByUid(appUid)) { + RecordStandaloneAppSessionIdInfo(appUid, isOnlyRecordUid, sessionId); + AudioVolume::GetInstance()->SetAppVolumeMute(appUid, true); + return true; + } + return false; } -void StandaloneModeManagerResumeAllStandaloneAppFuzzTest() +void StandaloneModeManager::RecordStandaloneAppSessionIdInfo(const int32_t appUid, + const bool isOnlyRecordUid, const int32_t sessionId) { - std::shared_ptr interruptService = - std::make_shared(); - StandaloneModeManager::GetInstance().Init(interruptService); - int32_t appUid = GetData(); - StandaloneModeManager::GetInstance().ResumeAllStandaloneApp(appUid); + std::lock_guard lock(mutex_); + if (isOnlyRecordUid) { + std::unordered_set sessionIdInfoMap = {}; + activeZoneSessionsMap_[appUid] = std::move(sessionIdInfoMap); + return; + } + activeZoneSessionsMap_[appUid].insert(sessionId); } -TestPtr g_testPtrs[] = { - StandaloneModeManagerInItFuzzTest, - StandaloneModeManagerCheckAndRecordStandaloneAppFuzzTest, - StandaloneModeManagerSetAppSilentOnDisplayFuzzTest, - StandaloneModeManagerSetAppConcurrencyModeFuzzTest, - StandaloneModeManagerEraseDeactivateAudioStreamFuzzTest, - StandaloneModeManagerResumeAllStandaloneAppFuzzTest, -}; - -void FuzzTest(const uint8_t* rawData, size_t size) +void StandaloneModeManager::EraseDeactivateAudioStream(const int32_t appUid, + const int32_t sessionId) { - if (rawData == nullptr) { - return; + std::lock_guard lock(mutex_); + if (activeZoneSessionsMap_.find(appUid) == activeZoneSessionsMap_.end()) { + return; } - - RAW_DATA = rawData; - g_dataSize = size; - g_pos = 0; - - uint32_t code = GetData(); - uint32_t len = GetArrLength(g_testPtrs); - if (len > 0) { - g_testPtrs[code % len](); - } else { - AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__); + if (activeZoneSessionsMap_[appUid].empty()) { + return; } - return; + activeZoneSessionsMap_[appUid].erase(sessionId); } } // namespace AudioStandard -} // namesapce OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) -{ - if (size < OHOS::AudioStandard::THRESHOLD) { - return 0; - } - OHOS::AudioStandard::FuzzTest(data, size); - return 0; -} - - - - server->interruptService_ = std::make_shared(); - int32_t result = server->DeactivateAudioInterrupt(audioInterrupt, zoneID - - +} // namespace OHOS -- Gitee From b1328752026fa23ccb12364000677a9e3474b674 Mon Sep 17 00:00:00 2001 From: weiyuantian Date: Wed, 20 Aug 2025 09:13:01 +0000 Subject: [PATCH 04/20] update services/audio_service/test/unittest/audio_0820_DT_test. Signed-off-by: weiyuantian --- .../test/unittest/audio_0820_DT_test | 315 ------------------ 1 file changed, 315 deletions(-) diff --git a/services/audio_service/test/unittest/audio_0820_DT_test b/services/audio_service/test/unittest/audio_0820_DT_test index 241f483e12..e69de29bb2 100644 --- a/services/audio_service/test/unittest/audio_0820_DT_test +++ b/services/audio_service/test/unittest/audio_0820_DT_test @@ -1,315 +0,0 @@ -/* - * 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 ST_STANDALONE_MODE_MANAGER_H -#define ST_STANDALONE_MODE_MANAGER_H - -#include -#include -#include -#include "audio_info.h" - -namespace OHOS { -namespace AudioStandard { - -static constexpr int32_t INVALID_ID = INT_MIN; - -class AudioInterruptService; -class StandaloneModeManager { -private: - static std::mutex instanceMutex; - static StandaloneModeManager* instance; -public: - static StandaloneModeManager &GetInstance(); - void Init(std::shared_ptr interruptService); - bool CheckAndRecordStandaloneApp(const int32_t appUid, const bool isOnlyRecordUid = true, - const int32_t sessionId = -1); - int32_t SetAppSilentOnDisplay(const int32_t ownerPid, const int32_t displayId); - int32_t SetAppConcurrencyMode(const int32_t ownerPid, - const int32_t appUid, const int32_t mode); - void EraseDeactivateAudioStream(const int32_t appUid, - const int32_t sessionId); - void ResumeAllStandaloneApp(const int32_t appPid); - -private: - StandaloneModeManager() = default; - ~StandaloneModeManager(); - StandaloneModeManager(const StandaloneModeManager&) = delete; - StandaloneModeManager &operator = (const StandaloneModeManager&) = delete; - - void CleanAllStandaloneInfo(); - void RemoveExistingFocus(const int32_t appUid); - bool CheckOwnerPidPermissions(const int32_t ownerPid); - void ExitStandaloneAndResumeFocus(const int32_t appUid); - bool CheckAppOnVirtualScreenByUid(const int32_t appUid); - void RecordStandaloneAppSessionIdInfo(const int32_t appUid, const bool isOnlyRecordUid = true, - const int32_t sessionId = -1); - - std::recursive_mutex mutex_; - std::shared_ptr interruptService_; - int32_t ownerPid_ = INVALID_ID; - int32_t displayId_ = INVALID_ID; - bool isSetSilentDisplay_ = false; - std::unordered_map>activeZoneSessionsMap_; //{appUid {sessionId}} -}; -} // namespace AudioStandard -} // namespace OHOS - -#endif // ST_STANDALONE_MODE_MANAGER_H - - - - - - - -/* - * 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 LOG_TAG -#define LOG_TAG "StandaloneModeManager" -#endif - -#include "standalone_mode_manager.h" -#include "audio_log.h" -#include "audio_session_info.h" -#include "audio_bundle_manager.h" -#include "window_manager.h" -#include "audio_volume.h" -#include "audio_interrupt_service.h" - -namespace OHOS { -namespace AudioStandard { - -std::mutex StandaloneModeManager::instanceMutex; -StandaloneModeManager* StandaloneModeManager::instance; - -StandaloneModeManager &StandaloneModeManager::GetInstance() -{ - std::lock_guard lock(instanceMutex); - if (instance == nullptr) { - instance = new StandaloneModeManager(); - } - return *instance; -} - -void StandaloneModeManager::Init(std::shared_ptr interruptService) -{ - std::lock_guard lock(mutex_); - CHECK_AND_RETURN_LOG(interruptService != nullptr, - "interruptService is nullptr"); - interruptService_ = interruptService; -} - -StandaloneModeManager::~StandaloneModeManager() -{ - CleanAllStandaloneInfo(); -} - -int32_t StandaloneModeManager::SetAppSilentOnDisplay(const int32_t ownerPid, const int32_t displayId) -{ - std::lock_guard lock(mutex_); - if (!CheckOwnerPidPermissions(ownerPid)) { - return -1; - } - isSetSilentDisplay_ = displayId > 0 ? true : false; - displayId_ = isSetSilentDisplay_ ? displayId : INVALID_ID; - if (displayId == -1) { - ResumeAllStandaloneApp(ownerPid); - } - return 0; -} - -bool StandaloneModeManager::CheckOwnerPidPermissions(const int32_t ownerPid) -{ - std::lock_guard lock(mutex_); - if (ownerPid_ == INVALID_ID) { - ownerPid_ = ownerPid; - AUDIO_INFO_LOG("Init Owner Pid is %{public}d", ownerPid); - } else if (ownerPid != ownerPid_) { - AUDIO_ERR_LOG("currentAppPid %{public}d ownerPid %{public}d ", ownerPid, ownerPid_); - return false; - } - return true; -} - -void StandaloneModeManager::ExitStandaloneAndResumeFocus(const int32_t appUid) -{ - std::lock_guard lock(mutex_); - if (interruptService_ == nullptr) { - return; - } - if (activeZoneSessionsMap_.find(appUid) == activeZoneSessionsMap_.end()) { - AUDIO_ERR_LOG("Exit Standalone Focus Not Find"); - return; - } - - auto standaloneAppSessionsList = activeZoneSessionsMap_[appUid]; - for (auto &sessionId : standaloneAppSessionsList) { - InterruptEventInternal interruptEventResume {INTERRUPT_TYPE_BEGIN, - INTERRUPT_SHARE, INTERRUPT_HINT_EXIT_STANDALONE, 1.0f}; - interruptService_->ResumeFocusByStreamId(sessionId, interruptEventResume); - } - activeZoneSessionsMap_.erase(appUid); -} - -void StandaloneModeManager::ResumeAllStandaloneApp(const int32_t appPid) -{ - std::lock_guard lock(mutex_); - if (appPid != ownerPid_) { - return; - } - AUDIO_INFO_LOG("Begin Resume All Standalone App"); - if (!activeZoneSessionsMap_.empty()) { - auto tempActiveZoneSessionsMap = activeZoneSessionsMap_; - for (auto &[appUid, _] : tempActiveZoneSessionsMap) { - ExitStandaloneAndResumeFocus(appUid); - AudioVolume::GetInstance()->SetAppVolumeMute(appUid, false); - } - } - CleanAllStandaloneInfo(); -} - -void StandaloneModeManager::CleanAllStandaloneInfo() -{ - std::lock_guard lock(mutex_); - ownerPid_ = INVALID_ID; - displayId_ = INVALID_ID; - isSetSilentDisplay_ = false; - activeZoneSessionsMap_.clear(); -} - -void StandaloneModeManager::RemoveExistingFocus(const int32_t appUid) -{ - std::lock_guard lock(mutex_); - if (interruptService_ == nullptr) { - return; - } - std::unordered_set uidActivedSessions = {}; - interruptService_->RemoveExistingFocus(appUid, uidActivedSessions); - if (!uidActivedSessions.empty()) { - for (auto sessionId : uidActivedSessions) { - activeZoneSessionsMap_[appUid].insert(sessionId); - } - } -} - -int32_t StandaloneModeManager::SetAppConcurrencyMode(const int32_t ownerPid, - const int32_t appUid, const int32_t mode) -{ - std::lock_guard lock(mutex_); - AUDIO_INFO_LOG("Set App Concurrency Mode : ownerPid = %{public}d Standalone" - "appUid = %{public}d concurrencyMode = %{public}d", ownerPid, appUid, mode); - if (!CheckOwnerPidPermissions(ownerPid)) { - return -1; - } - AudioConcurrencyMode concurrencyMode = static_cast(mode); - switch (concurrencyMode) { - case AudioConcurrencyMode::STANDALONE: - RecordStandaloneAppSessionIdInfo(appUid); - RemoveExistingFocus(appUid); - break; - case AudioConcurrencyMode::DEFAULT: - ExitStandaloneAndResumeFocus(appUid); - break; - default: - break; - } - return 0; -} - -bool StandaloneModeManager::CheckAppOnVirtualScreenByUid(const int32_t appUid) -{ - std::lock_guard lock(mutex_); - std::string bundleName = AudioBundleManager::GetBundleNameFromUid(appUid); - if (bundleName.empty()) { - AUDIO_ERR_LOG("Get BundleName From Uid Fail"); - return false; - } - OHOS::Rosen::WindowInfoOption windowInfoOption = {}; - windowInfoOption.displayId = displayId_; - std::vector> ogInfos = {}; - auto ret = OHOS::Rosen::WindowManager::GetInstance().ListWindowInfo(windowInfoOption, ogInfos); - AUDIO_INFO_LOG("ListWindowIfo size is %{public}d, ret = %{public}d", - static_cast(ogInfos.size()), ret); - for (auto &iter : ogInfos) { - if (iter->windowMetaInfo.bundleName == bundleName) { - AUDIO_INFO_LOG("Exist Standalone App On Virtual Screen ownerUid" - " = %{public}d, bundleName = %{public}s", appUid, bundleName.c_str()); - return true; - } - } - return false; -} - -bool StandaloneModeManager::CheckAndRecordStandaloneApp(const int32_t appUid, - const bool isOnlyRecordUid, const int32_t sessionId) -{ - std::lock_guard lock(mutex_); - if (ownerPid_ == INVALID_ID && !isSetSilentDisplay_) { - AUDIO_ERR_LOG("Standalone Mode Not Activation"); - return false; - } - if (activeZoneSessionsMap_.find(appUid) != activeZoneSessionsMap_.end()) { - RecordStandaloneAppSessionIdInfo(appUid, isOnlyRecordUid, sessionId); - return true; - } - if (isSetSilentDisplay_ && CheckAppOnVirtualScreenByUid(appUid)) { - RecordStandaloneAppSessionIdInfo(appUid, isOnlyRecordUid, sessionId); - AudioVolume::GetInstance()->SetAppVolumeMute(appUid, true); - return true; - } - return false; -} - -void StandaloneModeManager::RecordStandaloneAppSessionIdInfo(const int32_t appUid, - const bool isOnlyRecordUid, const int32_t sessionId) -{ - std::lock_guard lock(mutex_); - if (isOnlyRecordUid) { - std::unordered_set sessionIdInfoMap = {}; - activeZoneSessionsMap_[appUid] = std::move(sessionIdInfoMap); - return; - } - activeZoneSessionsMap_[appUid].insert(sessionId); -} - -void StandaloneModeManager::EraseDeactivateAudioStream(const int32_t appUid, - const int32_t sessionId) -{ - std::lock_guard lock(mutex_); - if (activeZoneSessionsMap_.find(appUid) == activeZoneSessionsMap_.end()) { - return; - } - if (activeZoneSessionsMap_[appUid].empty()) { - return; - } - activeZoneSessionsMap_[appUid].erase(sessionId); -} - -} // namespace AudioStandard -} // namespace OHOS -- Gitee From f986da945ec35d09d964eca225221ba8ac6e4639 Mon Sep 17 00:00:00 2001 From: weiyuantian Date: Thu, 21 Aug 2025 03:34:43 +0000 Subject: [PATCH 05/20] update services/audio_service/test/unittest/audio_0820_DT_test. Signed-off-by: weiyuantian --- .../test/unittest/audio_0820_DT_test | 233 ++++++++++++++++++ 1 file changed, 233 insertions(+) diff --git a/services/audio_service/test/unittest/audio_0820_DT_test b/services/audio_service/test/unittest/audio_0820_DT_test index e69de29bb2..e887c8b2ed 100644 --- a/services/audio_service/test/unittest/audio_0820_DT_test +++ b/services/audio_service/test/unittest/audio_0820_DT_test @@ -0,0 +1,233 @@ +BufferDesc srcDescTest; +BufferDesc dstDescTest; +uint8_t srcBufferTest[8] = {0}; +uint8_t dstBufferTest[8] = {0}; + +class BufferDescTest { +public: + BufferDescTest(uint8_t *buffersrc, uint8_t *bufferdst, size_t bufLengthsrc, size_t bufLengthdst) { + srcDescTest.buffer = buffersrc; + dstDescTest.buffer = bufferdst; + srcDescTest.bufLength = bufLengthsrc; + dstDescTest.bufLength = bufLengthdst; + } +}; + + + + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: F32MonoToS16Stereo_002 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, F32MonoToS16Stereo_002, TestSize.Level1) +{ + int32_t ret = -1; + BufferDescTest(nullptr, dstBufferTest, 4, 4); + ret = FormatConverter::F32MonoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); + EXPECT_EQ(srcDescTest.buffer, nullptr); + + BufferDescTest(srcBufferTest, nullptr, 4, 4); + ret = FormatConverter::F32MonoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); + EXPECT_EQ(dstDescTest.buffer, nullptr); + + BufferDescTest(srcBufferTest, dstBufferTest, 5, 5); + ret = FormatConverter::F32MonoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); + EXPECT_EQ(dstDescTest.bufLength, 5); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: F32MonoToS16Stereo_CapMax_001 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, F32MonoToS16Stereo_CapMax_001, TestSize.Level1) +{ + int32_t ret = -1; + uint8_t srcBuffer[4] = {2}; + uint8_t dstBuffer[4] = {0}; + BufferDescTest(srcBuffer, dstBuffer, 4, 4); + ret = FormatConverter::F32MonoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, 0); + EXPECT_EQ(*srcDescTest.buffer, 2); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: F32MonoToS16Stereo_CapMax_002 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, F32MonoToS16Stereo_CapMax_002, TestSize.Level1) +{ + int32_t ret = -1; + uint8_t srcBuffer[4] = {-2}; + uint8_t dstBuffer[4] = {0}; + BufferDescTest(srcBuffer, dstBuffer, 4, 4); + ret = FormatConverter::F32MonoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, 0); + EXPECT_EQ(*srcDescTest.buffer, 254); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: F32StereoToS16Stereo_002 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, F32StereoToS16Stereo_002, TestSize.Level1) +{ + int32_t ret = -1; + BufferDescTest(nullptr, dstBufferTest, 4, 2); + ret = FormatConverter::F32StereoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); + EXPECT_EQ(srcDescTest.buffer, nullptr); + + BufferDescTest(srcBufferTest, nullptr, 4, 2); + ret = FormatConverter::F32StereoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); + EXPECT_EQ(dstDescTest.buffer, nullptr); + + BufferDescTest(srcBufferTest, dstBufferTest, 6, 3); + ret = FormatConverter::F32StereoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); + EXPECT_EQ(srcDescTest.bufLength, 6); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: S16StereoToF32Mono_002 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, S16StereoToF32Mono_002, TestSize.Level1) +{ + int32_t ret = -1; + BufferDescTest(nullptr, dstBufferTest, 4, 4); + ret = FormatConverter::S16StereoToF32Mono(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); + EXPECT_EQ(srcDescTest.buffer, nullptr); + + BufferDescTest(srcBufferTest, nullptr, 4, 4); + ret = FormatConverter::S16StereoToF32Mono(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); + EXPECT_EQ(dstDescTest.buffer, nullptr); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: S16MonoToS32Stereo_001 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, S16MonoToS32Stereo_001, TestSize.Level1) +{ + int32_t ret = -1; + BufferDescTest(nullptr, dstBufferTest, 2, 8); + ret = FormatConverter::S16MonoToS32Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); + EXPECT_EQ(srcDescTest.buffer, nullptr); + + BufferDescTest(srcBufferTest, nullptr, 2, 8); + ret = FormatConverter::S16MonoToS32Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); + EXPECT_EQ(dstDescTest.buffer, nullptr); + + BufferDescTest(srcBufferTest, dstBufferTest, 4, 8); + ret = FormatConverter::S16MonoToS32Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); + EXPECT_EQ(srcDescTest.bufLength, 4); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: S32StereoToS16Stereo_001 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, S32StereoToS16Stereo_001, TestSize.Level1) +{ + int32_t ret = -1; + BufferDescTest(nullptr, dstBufferTest, 8, 4); + ret = FormatConverter::S32StereoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); + EXPECT_EQ(srcDescTest.buffer, nullptr); + + BufferDescTest(srcBufferTest, nullptr, 8, 4); + ret = FormatConverter::S32StereoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); + EXPECT_EQ(dstDescTest.buffer, nullptr); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: S32MonoToS16Stereo_001 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, S32MonoToS16Stereo_001, TestSize.Level1) +{ + int32_t ret = -1; + BufferDescTest(srcBufferTest, dstBufferTest, 4, 4); + ret = FormatConverter::S32MonoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, 0); + EXPECT_EQ(srcDescTest.bufLength, 4); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: S16StereoToS16Mono_001 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, S16StereoToS16Mono_001, TestSize.Level1) +{ + int32_t ret = -1; + BufferDescTest(nullptr, dstBufferTest, 8, 4); + ret = FormatConverter::S16StereoToS16Mono(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); + EXPECT_EQ(srcDescTest.buffer, nullptr); + + BufferDescTest(srcBufferTest, nullptr, 8, 4); + ret = FormatConverter::S16StereoToS16Mono(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); + EXPECT_EQ(dstDescTest.buffer, nullptr); + + BufferDescTest(srcBufferTest, dstBufferTest, 8, 4); + ret = FormatConverter::S16StereoToS16Mono(srcDescTest, dstDescTest); + EXPECT_EQ(ret, 0); + EXPECT_EQ(srcDescTest.bufLength, 8); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: S16MonoToS16Stereo_004 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, S16MonoToS16Stereo_004, TestSize.Level1) +{ + int32_t ret = -1; + BufferDescTest(srcBufferTest, dstBufferTest, 4, 8); + ret = FormatConverter::S16MonoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, 0); + EXPECT_EQ(srcDescTest.bufLength, 4); + + ret = FormatConverter::S16StereoToS32Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, 0); + EXPECT_EQ(dstDescTest.bufLength, 8); + + ret = FormatConverter::S32MonoToS32Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, 0); + EXPECT_NE(dstDescTest.buffer, nullptr); + + ret = FormatConverter::F32MonoToS32Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, 0); + EXPECT_EQ(*srcDescTest.buffer, 0); +} \ No newline at end of file -- Gitee From 250837040939a6ea8070a7ce0afa774465c48d51 Mon Sep 17 00:00:00 2001 From: weiyuantian Date: Thu, 21 Aug 2025 07:06:32 +0000 Subject: [PATCH 06/20] update services/audio_service/test/unittest/audio_0820_DT_test. Signed-off-by: weiyuantian --- .../test/unittest/audio_0820_DT_test | 233 ------------------ 1 file changed, 233 deletions(-) diff --git a/services/audio_service/test/unittest/audio_0820_DT_test b/services/audio_service/test/unittest/audio_0820_DT_test index e887c8b2ed..e69de29bb2 100644 --- a/services/audio_service/test/unittest/audio_0820_DT_test +++ b/services/audio_service/test/unittest/audio_0820_DT_test @@ -1,233 +0,0 @@ -BufferDesc srcDescTest; -BufferDesc dstDescTest; -uint8_t srcBufferTest[8] = {0}; -uint8_t dstBufferTest[8] = {0}; - -class BufferDescTest { -public: - BufferDescTest(uint8_t *buffersrc, uint8_t *bufferdst, size_t bufLengthsrc, size_t bufLengthdst) { - srcDescTest.buffer = buffersrc; - dstDescTest.buffer = bufferdst; - srcDescTest.bufLength = bufLengthsrc; - dstDescTest.bufLength = bufLengthdst; - } -}; - - - - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: F32MonoToS16Stereo_002 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, F32MonoToS16Stereo_002, TestSize.Level1) -{ - int32_t ret = -1; - BufferDescTest(nullptr, dstBufferTest, 4, 4); - ret = FormatConverter::F32MonoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); - EXPECT_EQ(srcDescTest.buffer, nullptr); - - BufferDescTest(srcBufferTest, nullptr, 4, 4); - ret = FormatConverter::F32MonoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); - EXPECT_EQ(dstDescTest.buffer, nullptr); - - BufferDescTest(srcBufferTest, dstBufferTest, 5, 5); - ret = FormatConverter::F32MonoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); - EXPECT_EQ(dstDescTest.bufLength, 5); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: F32MonoToS16Stereo_CapMax_001 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, F32MonoToS16Stereo_CapMax_001, TestSize.Level1) -{ - int32_t ret = -1; - uint8_t srcBuffer[4] = {2}; - uint8_t dstBuffer[4] = {0}; - BufferDescTest(srcBuffer, dstBuffer, 4, 4); - ret = FormatConverter::F32MonoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, 0); - EXPECT_EQ(*srcDescTest.buffer, 2); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: F32MonoToS16Stereo_CapMax_002 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, F32MonoToS16Stereo_CapMax_002, TestSize.Level1) -{ - int32_t ret = -1; - uint8_t srcBuffer[4] = {-2}; - uint8_t dstBuffer[4] = {0}; - BufferDescTest(srcBuffer, dstBuffer, 4, 4); - ret = FormatConverter::F32MonoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, 0); - EXPECT_EQ(*srcDescTest.buffer, 254); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: F32StereoToS16Stereo_002 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, F32StereoToS16Stereo_002, TestSize.Level1) -{ - int32_t ret = -1; - BufferDescTest(nullptr, dstBufferTest, 4, 2); - ret = FormatConverter::F32StereoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); - EXPECT_EQ(srcDescTest.buffer, nullptr); - - BufferDescTest(srcBufferTest, nullptr, 4, 2); - ret = FormatConverter::F32StereoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); - EXPECT_EQ(dstDescTest.buffer, nullptr); - - BufferDescTest(srcBufferTest, dstBufferTest, 6, 3); - ret = FormatConverter::F32StereoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); - EXPECT_EQ(srcDescTest.bufLength, 6); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: S16StereoToF32Mono_002 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, S16StereoToF32Mono_002, TestSize.Level1) -{ - int32_t ret = -1; - BufferDescTest(nullptr, dstBufferTest, 4, 4); - ret = FormatConverter::S16StereoToF32Mono(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); - EXPECT_EQ(srcDescTest.buffer, nullptr); - - BufferDescTest(srcBufferTest, nullptr, 4, 4); - ret = FormatConverter::S16StereoToF32Mono(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); - EXPECT_EQ(dstDescTest.buffer, nullptr); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: S16MonoToS32Stereo_001 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, S16MonoToS32Stereo_001, TestSize.Level1) -{ - int32_t ret = -1; - BufferDescTest(nullptr, dstBufferTest, 2, 8); - ret = FormatConverter::S16MonoToS32Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); - EXPECT_EQ(srcDescTest.buffer, nullptr); - - BufferDescTest(srcBufferTest, nullptr, 2, 8); - ret = FormatConverter::S16MonoToS32Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); - EXPECT_EQ(dstDescTest.buffer, nullptr); - - BufferDescTest(srcBufferTest, dstBufferTest, 4, 8); - ret = FormatConverter::S16MonoToS32Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); - EXPECT_EQ(srcDescTest.bufLength, 4); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: S32StereoToS16Stereo_001 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, S32StereoToS16Stereo_001, TestSize.Level1) -{ - int32_t ret = -1; - BufferDescTest(nullptr, dstBufferTest, 8, 4); - ret = FormatConverter::S32StereoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); - EXPECT_EQ(srcDescTest.buffer, nullptr); - - BufferDescTest(srcBufferTest, nullptr, 8, 4); - ret = FormatConverter::S32StereoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); - EXPECT_EQ(dstDescTest.buffer, nullptr); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: S32MonoToS16Stereo_001 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, S32MonoToS16Stereo_001, TestSize.Level1) -{ - int32_t ret = -1; - BufferDescTest(srcBufferTest, dstBufferTest, 4, 4); - ret = FormatConverter::S32MonoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, 0); - EXPECT_EQ(srcDescTest.bufLength, 4); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: S16StereoToS16Mono_001 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, S16StereoToS16Mono_001, TestSize.Level1) -{ - int32_t ret = -1; - BufferDescTest(nullptr, dstBufferTest, 8, 4); - ret = FormatConverter::S16StereoToS16Mono(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); - EXPECT_EQ(srcDescTest.buffer, nullptr); - - BufferDescTest(srcBufferTest, nullptr, 8, 4); - ret = FormatConverter::S16StereoToS16Mono(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); - EXPECT_EQ(dstDescTest.buffer, nullptr); - - BufferDescTest(srcBufferTest, dstBufferTest, 8, 4); - ret = FormatConverter::S16StereoToS16Mono(srcDescTest, dstDescTest); - EXPECT_EQ(ret, 0); - EXPECT_EQ(srcDescTest.bufLength, 8); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: S16MonoToS16Stereo_004 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, S16MonoToS16Stereo_004, TestSize.Level1) -{ - int32_t ret = -1; - BufferDescTest(srcBufferTest, dstBufferTest, 4, 8); - ret = FormatConverter::S16MonoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, 0); - EXPECT_EQ(srcDescTest.bufLength, 4); - - ret = FormatConverter::S16StereoToS32Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, 0); - EXPECT_EQ(dstDescTest.bufLength, 8); - - ret = FormatConverter::S32MonoToS32Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, 0); - EXPECT_NE(dstDescTest.buffer, nullptr); - - ret = FormatConverter::F32MonoToS32Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, 0); - EXPECT_EQ(*srcDescTest.buffer, 0); -} \ No newline at end of file -- Gitee From 34054cc14b9424ac5dd242a5419a2d89dbbd56dc Mon Sep 17 00:00:00 2001 From: weiyuantian Date: Sat, 23 Aug 2025 08:49:27 +0000 Subject: [PATCH 07/20] update services/audio_service/test/unittest/audio_0820_DT_test. Signed-off-by: weiyuantian --- .../test/unittest/audio_0820_DT_test | 330 ++++++++++++++++++ 1 file changed, 330 insertions(+) diff --git a/services/audio_service/test/unittest/audio_0820_DT_test b/services/audio_service/test/unittest/audio_0820_DT_test index e69de29bb2..686488ca37 100644 --- a/services/audio_service/test/unittest/audio_0820_DT_test +++ b/services/audio_service/test/unittest/audio_0820_DT_test @@ -0,0 +1,330 @@ +uint8_t srcBufferTest[8] = {1, 2, 3, 4}; +uint8_t dstBufferTest[8] = {0}; + +class BufferDescTest { +public: + BufferDescTest(BufferDesc *srcDesc, BufferDesc *dstDesc, uint8_t *buffersrc, + uint8_t *bufferdst, size_t bufLengthsrc, size_t bufLengthdst) + { + srcDesc->buffer = buffersrc; + dstDesc->buffer = bufferdst; + srcDesc->bufLength = bufLengthsrc; + dstDesc->bufLength = bufLengthdst; + } +}; + + + + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: F32MonoToS16Stereo_002 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, F32MonoToS16Stereo_002, TestSize.Level1) +{ + BufferDesc srcDesc; + BufferDesc dstDesc; + int32_t ret = -1; + BufferDescTest(&srcDesc, &dstDesc, nullptr, dstBufferTest, 4, 4); + ret = FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); + + BufferDescTest(&srcDesc, &dstDesc, srcBufferTest, nullptr, 4, 4); + ret = FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); + + BufferDescTest(&srcDesc, &dstDesc, srcBufferTest, dstBufferTest, 5, 5); + ret = FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: F32MonoToS16Stereo_CapMax_001 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, F32MonoToS16Stereo_CapMax_001, TestSize.Level1) +{ + BufferDesc srcDescTest; + BufferDesc dstDescTest; + int32_t ret = -1; + uint8_t srcBuffer[4] = {2, 3, 4, 5}; + uint8_t dstBuffer[4] = {0}; + BufferDescTest(&srcDescTest, &dstDescTest, srcBuffer, dstBuffer, 4, 4); + ret = FormatConverter::F32MonoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, 0); + EXPECT_EQ(*dstDescTest.buffer, 0); + EXPECT_EQ(*dstDescTest.buffer + 1, 1); + EXPECT_EQ(*dstDescTest.buffer + 2, 2); + EXPECT_EQ(*dstDescTest.buffer + 3, 3); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: F32MonoToS16Stereo_CapMax_002 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, F32MonoToS16Stereo_CapMax_002, TestSize.Level1) +{ + BufferDesc srcDescTest; + BufferDesc dstDescTest; + int32_t ret = -1; + uint8_t srcBuffer[4] = {-2, 0, 1, 2}; + uint8_t dstBuffer[4] = {0}; + BufferDescTest(&srcDescTest, &dstDescTest, srcBuffer, dstBuffer, 4, 4); + ret = FormatConverter::F32MonoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, 0); + EXPECT_EQ(*dstDescTest.buffer, 0); + EXPECT_EQ(*dstDescTest.buffer + 1, 1); + EXPECT_EQ(*dstDescTest.buffer + 2, 2); + EXPECT_EQ(*dstDescTest.buffer + 3, 3); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: F32StereoToS16Stereo_002 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, F32StereoToS16Stereo_002, TestSize.Level1) +{ + BufferDesc srcDesc; + BufferDesc dstDesc; + int32_t ret = -1; + BufferDescTest(&srcDesc, &dstDesc, nullptr, dstBufferTest, 4, 2); + ret = FormatConverter::F32StereoToS16Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); + + BufferDescTest(&srcDesc, &dstDesc, srcBufferTest, nullptr, 4, 2); + ret = FormatConverter::F32StereoToS16Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); + + BufferDescTest(&srcDesc, &dstDesc, srcBufferTest, dstBufferTest, 6, 3); + ret = FormatConverter::F32StereoToS16Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: S16StereoToF32Mono_002 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, S16StereoToF32Mono_002, TestSize.Level1) +{ + BufferDesc srcDesc; + BufferDesc dstDesc; + int32_t ret = -1; + BufferDescTest(&srcDesc, &dstDesc, nullptr, dstBufferTest, 4, 4); + ret = FormatConverter::S16StereoToF32Mono(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); + + BufferDescTest(&srcDesc, &dstDesc, srcBufferTest, nullptr, 4, 4); + ret = FormatConverter::S16StereoToF32Mono(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: S16MonoToS32Stereo_001 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, S16MonoToS32Stereo_001, TestSize.Level1) +{ + BufferDesc srcDesc; + BufferDesc dstDesc; + int32_t ret = -1; + BufferDescTest(&srcDesc, &dstDesc, nullptr, dstBufferTest, 2, 8); + ret = FormatConverter::S16MonoToS32Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); + + BufferDescTest(&srcDesc, &dstDesc, srcBufferTest, nullptr, 2, 8); + ret = FormatConverter::S16MonoToS32Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); + + BufferDescTest(&srcDesc, &dstDesc, srcBufferTest, dstBufferTest, 4, 8); + ret = FormatConverter::S16MonoToS32Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: S32StereoToS16Stereo_001 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, S32StereoToS16Stereo_001, TestSize.Level1) +{ + BufferDesc srcDesc; + BufferDesc dstDesc; + int32_t ret = -1; + BufferDescTest(&srcDesc, &dstDesc, nullptr, dstBufferTest, 8, 4); + ret = FormatConverter::S32StereoToS16Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); + + BufferDescTest(&srcDesc, &dstDesc, srcBufferTest, nullptr, 8, 4); + ret = FormatConverter::S32StereoToS16Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, -1); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: S32MonoToS16Stereo_001 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, S32MonoToS16Stereo_001, TestSize.Level1) +{ + BufferDesc srcDesc; + BufferDesc dstDesc; + int32_t ret = -1; + BufferDescTest(&srcDesc, &dstDesc, srcBufferTest, dstBufferTest, 4, 4); + ret = FormatConverter::S32MonoToS16Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, 0); + EXPECT_EQ(*dstDesc.buffer, 2); + EXPECT_EQ(*dstDesc.buffer + 1, 3); + EXPECT_EQ(*dstDesc.buffer + 2, 4); + EXPECT_EQ(*dstDesc.buffer + 3, 5); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: S16MonoToS16Stereo_004 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, S16MonoToS16Stereo_004, TestSize.Level1) +{ + BufferDesc srcDesc; + BufferDesc dstDesc; + int32_t ret = -1; + BufferDescTest(&srcDesc, &dstDesc, srcBufferTest, dstBufferTest, 4, 8); + ret = FormatConverter::S16MonoToS16Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, 0); + EXPECT_EQ(*dstDesc.buffer, 1); + EXPECT_EQ(*dstDesc.buffer + 1, 2); + EXPECT_EQ(*dstDesc.buffer + 2, 3); + EXPECT_EQ(*dstDesc.buffer + 3, 4); + + ret = FormatConverter::S16StereoToS32Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, 0); + EXPECT_EQ(*dstDesc.buffer, 2); + EXPECT_EQ(*dstDesc.buffer + 1, 3); + EXPECT_EQ(*dstDesc.buffer + 2, 4); + EXPECT_EQ(*dstDesc.buffer + 3, 5); + + ret = FormatConverter::S32MonoToS32Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, 0); + EXPECT_EQ(*dstDesc.buffer, 1); + EXPECT_EQ(*dstDesc.buffer + 1, 2); + EXPECT_EQ(*dstDesc.buffer + 2, 3); + EXPECT_EQ(*dstDesc.buffer + 3, 4); + + + ret = FormatConverter::F32MonoToS32Stereo(srcDesc, dstDesc); + EXPECT_EQ(ret, 0); + EXPECT_EQ(*dstDesc.buffer, 0); + EXPECT_EQ(*dstDesc.buffer + 1, 1); + EXPECT_EQ(*dstDesc.buffer + 2, 2); + EXPECT_EQ(*dstDesc.buffer + 3, 3); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: S16StereoToS16Mono_001 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, S16StereoToS16Mono_001, TestSize.Level1) +{ + BufferDesc srcDesc; + BufferDesc dstDesc; + int32_t ret = -1; + BufferDescTest(&srcDesc, &dstDesc, srcBufferTest, dstBufferTest, 8, 4); + ret = FormatConverter::S16StereoToS16Mono(srcDesc, dstDesc); + EXPECT_EQ(ret, 0); + EXPECT_EQ(*dstDesc.buffer, 2); + EXPECT_EQ(*dstDesc.buffer + 1, 3); + EXPECT_EQ(*dstDesc.buffer + 2, 4); + EXPECT_EQ(*dstDesc.buffer + 3, 5); + +} + + +/** + * @tc.name : Test CacheExtraParameters API + * @tc.type : FUNC + * @tc.number: CacheExtraParameters_001 + * @tc.desc : Test CacheExtraParameters interface. + */ +HWTEST_F(AudioServerUnitTest, CacheExtraParameters_001, TestSize.Level4) +{ + EXPECT_NE(nullptr, audioServer); + std::string key = "test_key"; + std::vector> kvpairs = {{"sub_key1", "value1"}, {"sub_key2", "value2"}}; + int32_t ret = audioServer->CacheExtraParameters(key, kvpairs); + EXPECT_EQ(false, ret); +} + +/** + * @tc.name : Test RestoreRenderSink API + * @tc.type : FUNC + * @tc.number: RestoreRenderSink_001 + * @tc.desc : Test RestoreRenderSink interface. + */ +HWTEST_F(AudioServerUnitTest, RestoreRenderSink_001, TestSize.Level4) +{ + EXPECT_NE(nullptr, audioServer); + std::string sinkName = "primary"; + int32_t ret = audioServer->RestoreRenderSink(sinkName); + EXPECT_EQ(ERR_OPERATION_FAILED, ret); +} + +/** + * @tc.name : Test GetEffectLiveParameter API + * @tc.type : FUNC + * @tc.number: GetEffectLiveParameter_001 + * @tc.desc : Test GetEffectLiveParameter interface. + */ +HWTEST_F(AudioServerUnitTest, GetEffectLiveParameter_001, TestSize.Level4) +{ + EXPECT_NE(nullptr, audioServer); + std::vector subKeys = {"key1", "key2"}; + std::vector> result; + bool ret = audioServer->GetEffectLiveParameter(subKeys, result); + EXPECT_EQ(false, ret); +} + +/** + * @tc.name : Test GetExtraParametersInner API + * @tc.type : FUNC + * @tc.number: GetExtraParametersInner_001 + * @tc.desc : Test GetExtraParametersInner interface. + */ +HWTEST_F(AudioServerUnitTest, GetExtraParametersInner_001, TestSize.Level1) +{ + EXPECT_NE(nullptr, audioServer); + std::string mainKey = "hpae_effect"; + std::vector subKeys = {"key1", "key2"}; + std::vector> result; + bool ret = audioServer->GetExtraParametersInner(mainKey, subKeys, result); + EXPECT_EQ(true, ret); +} + +/** + * @tc.name : Test CheckMaxLoopbackInstances API + * @tc.type : FUNC + * @tc.number: CheckMaxLoopbackInstances_003 + * @tc.desc : Test CheckMaxLoopbackInstances interface. + */ +HWTEST_F(AudioServerUnitTest, CheckMaxLoopbackInstances_003, TestSize.Level1) +{ + EXPECT_NE(nullptr, audioServer); + int32_t ret = audioServer->CheckMaxLoopbackInstances(AUDIO_MODE_PLAYBACK); + EXPECT_EQ(ret, SUCCESS); +} -- Gitee From acb095a730000bfe47395b1046a5cad75e73820f Mon Sep 17 00:00:00 2001 From: weiyuantian Date: Sat, 23 Aug 2025 09:01:41 +0000 Subject: [PATCH 08/20] update services/audio_service/test/unittest/audio_0820_DT_test. Signed-off-by: weiyuantian --- .../test/unittest/audio_0820_DT_test | 329 ------------------ 1 file changed, 329 deletions(-) diff --git a/services/audio_service/test/unittest/audio_0820_DT_test b/services/audio_service/test/unittest/audio_0820_DT_test index 686488ca37..8b13789179 100644 --- a/services/audio_service/test/unittest/audio_0820_DT_test +++ b/services/audio_service/test/unittest/audio_0820_DT_test @@ -1,330 +1 @@ -uint8_t srcBufferTest[8] = {1, 2, 3, 4}; -uint8_t dstBufferTest[8] = {0}; -class BufferDescTest { -public: - BufferDescTest(BufferDesc *srcDesc, BufferDesc *dstDesc, uint8_t *buffersrc, - uint8_t *bufferdst, size_t bufLengthsrc, size_t bufLengthdst) - { - srcDesc->buffer = buffersrc; - dstDesc->buffer = bufferdst; - srcDesc->bufLength = bufLengthsrc; - dstDesc->bufLength = bufLengthdst; - } -}; - - - - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: F32MonoToS16Stereo_002 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, F32MonoToS16Stereo_002, TestSize.Level1) -{ - BufferDesc srcDesc; - BufferDesc dstDesc; - int32_t ret = -1; - BufferDescTest(&srcDesc, &dstDesc, nullptr, dstBufferTest, 4, 4); - ret = FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); - - BufferDescTest(&srcDesc, &dstDesc, srcBufferTest, nullptr, 4, 4); - ret = FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); - - BufferDescTest(&srcDesc, &dstDesc, srcBufferTest, dstBufferTest, 5, 5); - ret = FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: F32MonoToS16Stereo_CapMax_001 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, F32MonoToS16Stereo_CapMax_001, TestSize.Level1) -{ - BufferDesc srcDescTest; - BufferDesc dstDescTest; - int32_t ret = -1; - uint8_t srcBuffer[4] = {2, 3, 4, 5}; - uint8_t dstBuffer[4] = {0}; - BufferDescTest(&srcDescTest, &dstDescTest, srcBuffer, dstBuffer, 4, 4); - ret = FormatConverter::F32MonoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, 0); - EXPECT_EQ(*dstDescTest.buffer, 0); - EXPECT_EQ(*dstDescTest.buffer + 1, 1); - EXPECT_EQ(*dstDescTest.buffer + 2, 2); - EXPECT_EQ(*dstDescTest.buffer + 3, 3); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: F32MonoToS16Stereo_CapMax_002 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, F32MonoToS16Stereo_CapMax_002, TestSize.Level1) -{ - BufferDesc srcDescTest; - BufferDesc dstDescTest; - int32_t ret = -1; - uint8_t srcBuffer[4] = {-2, 0, 1, 2}; - uint8_t dstBuffer[4] = {0}; - BufferDescTest(&srcDescTest, &dstDescTest, srcBuffer, dstBuffer, 4, 4); - ret = FormatConverter::F32MonoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, 0); - EXPECT_EQ(*dstDescTest.buffer, 0); - EXPECT_EQ(*dstDescTest.buffer + 1, 1); - EXPECT_EQ(*dstDescTest.buffer + 2, 2); - EXPECT_EQ(*dstDescTest.buffer + 3, 3); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: F32StereoToS16Stereo_002 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, F32StereoToS16Stereo_002, TestSize.Level1) -{ - BufferDesc srcDesc; - BufferDesc dstDesc; - int32_t ret = -1; - BufferDescTest(&srcDesc, &dstDesc, nullptr, dstBufferTest, 4, 2); - ret = FormatConverter::F32StereoToS16Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); - - BufferDescTest(&srcDesc, &dstDesc, srcBufferTest, nullptr, 4, 2); - ret = FormatConverter::F32StereoToS16Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); - - BufferDescTest(&srcDesc, &dstDesc, srcBufferTest, dstBufferTest, 6, 3); - ret = FormatConverter::F32StereoToS16Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: S16StereoToF32Mono_002 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, S16StereoToF32Mono_002, TestSize.Level1) -{ - BufferDesc srcDesc; - BufferDesc dstDesc; - int32_t ret = -1; - BufferDescTest(&srcDesc, &dstDesc, nullptr, dstBufferTest, 4, 4); - ret = FormatConverter::S16StereoToF32Mono(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); - - BufferDescTest(&srcDesc, &dstDesc, srcBufferTest, nullptr, 4, 4); - ret = FormatConverter::S16StereoToF32Mono(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: S16MonoToS32Stereo_001 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, S16MonoToS32Stereo_001, TestSize.Level1) -{ - BufferDesc srcDesc; - BufferDesc dstDesc; - int32_t ret = -1; - BufferDescTest(&srcDesc, &dstDesc, nullptr, dstBufferTest, 2, 8); - ret = FormatConverter::S16MonoToS32Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); - - BufferDescTest(&srcDesc, &dstDesc, srcBufferTest, nullptr, 2, 8); - ret = FormatConverter::S16MonoToS32Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); - - BufferDescTest(&srcDesc, &dstDesc, srcBufferTest, dstBufferTest, 4, 8); - ret = FormatConverter::S16MonoToS32Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: S32StereoToS16Stereo_001 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, S32StereoToS16Stereo_001, TestSize.Level1) -{ - BufferDesc srcDesc; - BufferDesc dstDesc; - int32_t ret = -1; - BufferDescTest(&srcDesc, &dstDesc, nullptr, dstBufferTest, 8, 4); - ret = FormatConverter::S32StereoToS16Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); - - BufferDescTest(&srcDesc, &dstDesc, srcBufferTest, nullptr, 8, 4); - ret = FormatConverter::S32StereoToS16Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, -1); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: S32MonoToS16Stereo_001 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, S32MonoToS16Stereo_001, TestSize.Level1) -{ - BufferDesc srcDesc; - BufferDesc dstDesc; - int32_t ret = -1; - BufferDescTest(&srcDesc, &dstDesc, srcBufferTest, dstBufferTest, 4, 4); - ret = FormatConverter::S32MonoToS16Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, 0); - EXPECT_EQ(*dstDesc.buffer, 2); - EXPECT_EQ(*dstDesc.buffer + 1, 3); - EXPECT_EQ(*dstDesc.buffer + 2, 4); - EXPECT_EQ(*dstDesc.buffer + 3, 5); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: S16MonoToS16Stereo_004 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, S16MonoToS16Stereo_004, TestSize.Level1) -{ - BufferDesc srcDesc; - BufferDesc dstDesc; - int32_t ret = -1; - BufferDescTest(&srcDesc, &dstDesc, srcBufferTest, dstBufferTest, 4, 8); - ret = FormatConverter::S16MonoToS16Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, 0); - EXPECT_EQ(*dstDesc.buffer, 1); - EXPECT_EQ(*dstDesc.buffer + 1, 2); - EXPECT_EQ(*dstDesc.buffer + 2, 3); - EXPECT_EQ(*dstDesc.buffer + 3, 4); - - ret = FormatConverter::S16StereoToS32Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, 0); - EXPECT_EQ(*dstDesc.buffer, 2); - EXPECT_EQ(*dstDesc.buffer + 1, 3); - EXPECT_EQ(*dstDesc.buffer + 2, 4); - EXPECT_EQ(*dstDesc.buffer + 3, 5); - - ret = FormatConverter::S32MonoToS32Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, 0); - EXPECT_EQ(*dstDesc.buffer, 1); - EXPECT_EQ(*dstDesc.buffer + 1, 2); - EXPECT_EQ(*dstDesc.buffer + 2, 3); - EXPECT_EQ(*dstDesc.buffer + 3, 4); - - - ret = FormatConverter::F32MonoToS32Stereo(srcDesc, dstDesc); - EXPECT_EQ(ret, 0); - EXPECT_EQ(*dstDesc.buffer, 0); - EXPECT_EQ(*dstDesc.buffer + 1, 1); - EXPECT_EQ(*dstDesc.buffer + 2, 2); - EXPECT_EQ(*dstDesc.buffer + 3, 3); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: S16StereoToS16Mono_001 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, S16StereoToS16Mono_001, TestSize.Level1) -{ - BufferDesc srcDesc; - BufferDesc dstDesc; - int32_t ret = -1; - BufferDescTest(&srcDesc, &dstDesc, srcBufferTest, dstBufferTest, 8, 4); - ret = FormatConverter::S16StereoToS16Mono(srcDesc, dstDesc); - EXPECT_EQ(ret, 0); - EXPECT_EQ(*dstDesc.buffer, 2); - EXPECT_EQ(*dstDesc.buffer + 1, 3); - EXPECT_EQ(*dstDesc.buffer + 2, 4); - EXPECT_EQ(*dstDesc.buffer + 3, 5); - -} - - -/** - * @tc.name : Test CacheExtraParameters API - * @tc.type : FUNC - * @tc.number: CacheExtraParameters_001 - * @tc.desc : Test CacheExtraParameters interface. - */ -HWTEST_F(AudioServerUnitTest, CacheExtraParameters_001, TestSize.Level4) -{ - EXPECT_NE(nullptr, audioServer); - std::string key = "test_key"; - std::vector> kvpairs = {{"sub_key1", "value1"}, {"sub_key2", "value2"}}; - int32_t ret = audioServer->CacheExtraParameters(key, kvpairs); - EXPECT_EQ(false, ret); -} - -/** - * @tc.name : Test RestoreRenderSink API - * @tc.type : FUNC - * @tc.number: RestoreRenderSink_001 - * @tc.desc : Test RestoreRenderSink interface. - */ -HWTEST_F(AudioServerUnitTest, RestoreRenderSink_001, TestSize.Level4) -{ - EXPECT_NE(nullptr, audioServer); - std::string sinkName = "primary"; - int32_t ret = audioServer->RestoreRenderSink(sinkName); - EXPECT_EQ(ERR_OPERATION_FAILED, ret); -} - -/** - * @tc.name : Test GetEffectLiveParameter API - * @tc.type : FUNC - * @tc.number: GetEffectLiveParameter_001 - * @tc.desc : Test GetEffectLiveParameter interface. - */ -HWTEST_F(AudioServerUnitTest, GetEffectLiveParameter_001, TestSize.Level4) -{ - EXPECT_NE(nullptr, audioServer); - std::vector subKeys = {"key1", "key2"}; - std::vector> result; - bool ret = audioServer->GetEffectLiveParameter(subKeys, result); - EXPECT_EQ(false, ret); -} - -/** - * @tc.name : Test GetExtraParametersInner API - * @tc.type : FUNC - * @tc.number: GetExtraParametersInner_001 - * @tc.desc : Test GetExtraParametersInner interface. - */ -HWTEST_F(AudioServerUnitTest, GetExtraParametersInner_001, TestSize.Level1) -{ - EXPECT_NE(nullptr, audioServer); - std::string mainKey = "hpae_effect"; - std::vector subKeys = {"key1", "key2"}; - std::vector> result; - bool ret = audioServer->GetExtraParametersInner(mainKey, subKeys, result); - EXPECT_EQ(true, ret); -} - -/** - * @tc.name : Test CheckMaxLoopbackInstances API - * @tc.type : FUNC - * @tc.number: CheckMaxLoopbackInstances_003 - * @tc.desc : Test CheckMaxLoopbackInstances interface. - */ -HWTEST_F(AudioServerUnitTest, CheckMaxLoopbackInstances_003, TestSize.Level1) -{ - EXPECT_NE(nullptr, audioServer); - int32_t ret = audioServer->CheckMaxLoopbackInstances(AUDIO_MODE_PLAYBACK); - EXPECT_EQ(ret, SUCCESS); -} -- Gitee From f1b30667e4392bbacbf5ee053ae10e2b4cac4f2c Mon Sep 17 00:00:00 2001 From: weiyuantian Date: Sat, 23 Aug 2025 09:38:46 +0000 Subject: [PATCH 09/20] update services/audio_service/test/unittest/audio_0820_DT_test. Signed-off-by: weiyuantian --- .../test/unittest/audio_0820_DT_test | 233 ++++++++++++++++++ 1 file changed, 233 insertions(+) diff --git a/services/audio_service/test/unittest/audio_0820_DT_test b/services/audio_service/test/unittest/audio_0820_DT_test index 8b13789179..92b6e23602 100644 --- a/services/audio_service/test/unittest/audio_0820_DT_test +++ b/services/audio_service/test/unittest/audio_0820_DT_test @@ -1 +1,234 @@ +BufferDesc srcDescTest; +BufferDesc dstDescTest; +uint8_t srcBufferTest[8] = {1, 2, 3, 4}; +uint8_t dstBufferTest[8] = {0}; +class BufferDescTest { +public: + BufferDescTest(uint8_t *buffersrc, uint8_t *bufferdst, size_t bufLengthsrc, size_t bufLengthdst) + { + srcDescTest.buffer = buffersrc; + dstDescTest.buffer = bufferdst; + srcDescTest.bufLength = bufLengthsrc; + dstDescTest.bufLength = bufLengthdst; + } +}; + + + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: F32MonoToS16Stereo_002 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, F32MonoToS16Stereo_002, TestSize.Level1) +{ + int32_t ret = -1; + BufferDescTest(nullptr, dstBufferTest, 4, 4); + ret = FormatConverter::F32MonoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); + + BufferDescTest(srcBufferTest, nullptr, 4, 4); + ret = FormatConverter::F32MonoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); + + BufferDescTest(srcBufferTest, dstBufferTest, 5, 5); + ret = FormatConverter::F32MonoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: F32MonoToS16Stereo_CapMax_001 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, F32MonoToS16Stereo_CapMax_001, TestSize.Level1) +{ + int32_t ret = -1; + uint8_t srcBuffer[4] = {2, 3, 4, 5}; + uint8_t dstBuffer[4] = {0}; + BufferDescTest(srcBuffer, dstBuffer, 4, 4); + ret = FormatConverter::F32MonoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, 0); + EXPECT_EQ(*dstDescTest.buffer, 0); + EXPECT_EQ(*dstDescTest.buffer + 1, 1); + EXPECT_EQ(*dstDescTest.buffer + 2, 2); + EXPECT_EQ(*dstDescTest.buffer + 3, 3); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: F32MonoToS16Stereo_CapMax_002 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, F32MonoToS16Stereo_CapMax_002, TestSize.Level1) +{ + int32_t ret = -1; + uint8_t srcBuffer[4] = {-2, 0, 1, 2}; + uint8_t dstBuffer[4] = {0}; + BufferDescTest(srcBuffer, dstBuffer, 4, 4); + ret = FormatConverter::F32MonoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, 0); + EXPECT_EQ(*dstDescTest.buffer, 0); + EXPECT_EQ(*dstDescTest.buffer + 1, 1); + EXPECT_EQ(*dstDescTest.buffer + 2, 2); + EXPECT_EQ(*dstDescTest.buffer + 3, 3); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: F32StereoToS16Stereo_002 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, F32StereoToS16Stereo_002, TestSize.Level1) +{ + int32_t ret = -1; + BufferDescTest(nullptr, dstBufferTest, 4, 2); + ret = FormatConverter::F32StereoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); + + BufferDescTest(srcBufferTest, nullptr, 4, 2); + ret = FormatConverter::F32StereoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); + + BufferDescTest(srcBufferTest, dstBufferTest, 6, 3); + ret = FormatConverter::F32StereoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: S16StereoToF32Mono_002 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, S16StereoToF32Mono_002, TestSize.Level1) +{ + int32_t ret = -1; + BufferDescTest(nullptr, dstBufferTest, 4, 4); + ret = FormatConverter::S16StereoToF32Mono(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); + + BufferDescTest(srcBufferTest, nullptr, 4, 4); + ret = FormatConverter::S16StereoToF32Mono(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: S16MonoToS32Stereo_001 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, S16MonoToS32Stereo_001, TestSize.Level1) +{ + int32_t ret = -1; + BufferDescTest(nullptr, dstBufferTest, 2, 8); + ret = FormatConverter::S16MonoToS32Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); + + BufferDescTest(srcBufferTest, nullptr, 2, 8); + ret = FormatConverter::S16MonoToS32Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); + + BufferDescTest(srcBufferTest, dstBufferTest, 4, 8); + ret = FormatConverter::S16MonoToS32Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: S32StereoToS16Stereo_001 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, S32StereoToS16Stereo_001, TestSize.Level1) +{ + int32_t ret = -1; + BufferDescTest(nullptr, dstBufferTest, 8, 4); + ret = FormatConverter::S32StereoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); + + BufferDescTest(srcBufferTest, nullptr, 8, 4); + ret = FormatConverter::S32StereoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, -1); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: S32MonoToS16Stereo_001 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, S32MonoToS16Stereo_001, TestSize.Level1) +{ + int32_t ret = -1; + BufferDescTest(srcBufferTest, dstBufferTest, 4, 4); + ret = FormatConverter::S32MonoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, 0); + EXPECT_EQ(*dstDescTest.buffer, 2); + EXPECT_EQ(*dstDescTest.buffer + 1, 3); + EXPECT_EQ(*dstDescTest.buffer + 2, 4); + EXPECT_EQ(*dstDescTest.buffer + 3, 5); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: S16MonoToS16Stereo_004 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, S16MonoToS16Stereo_004, TestSize.Level1) +{ + int32_t ret = -1; + BufferDescTest(srcBufferTest, dstBufferTest, 4, 8); + ret = FormatConverter::S16MonoToS16Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, 0); + EXPECT_EQ(*dstDescTest.buffer, 1); + EXPECT_EQ(*dstDescTest.buffer + 1, 2); + EXPECT_EQ(*dstDescTest.buffer + 2, 3); + EXPECT_EQ(*dstDescTest.buffer + 3, 4); + + ret = FormatConverter::S16StereoToS32Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, 0); + EXPECT_EQ(*dstDescTest.buffer, 2); + EXPECT_EQ(*dstDescTest.buffer + 1, 3); + EXPECT_EQ(*dstDescTest.buffer + 2, 4); + EXPECT_EQ(*dstDescTest.buffer + 3, 5); + + ret = FormatConverter::S32MonoToS32Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, 0); + EXPECT_EQ(*dstDescTest.buffer, 1); + EXPECT_EQ(*dstDescTest.buffer + 1, 2); + EXPECT_EQ(*dstDescTest.buffer + 2, 3); + EXPECT_EQ(*dstDescTest.buffer + 3, 4); + + ret = FormatConverter::F32MonoToS32Stereo(srcDescTest, dstDescTest); + EXPECT_EQ(ret, 0); + EXPECT_EQ(*dstDescTest.buffer, 0); + EXPECT_EQ(*dstDescTest.buffer + 1, 1); + EXPECT_EQ(*dstDescTest.buffer + 2, 2); + EXPECT_EQ(*dstDescTest.buffer + 3, 3); +} + +/** + * @tc.name : Test FormatConverter API + * @tc.type : FUNC + * @tc.number: S16StereoToS16Mono_001 + * @tc.desc : Test FormatConverter interface. + */ +HWTEST_F(FormatConverterUnitTest, S16StereoToS16Mono_001, TestSize.Level1) +{ + int32_t ret = -1; + BufferDescTest(srcBufferTest, dstBufferTest, 8, 4); + ret = FormatConverter::S16StereoToS16Mono(srcDescTest, dstDescTest); + EXPECT_EQ(ret, 0); + EXPECT_EQ(*dstDescTest.buffer, 2); + EXPECT_EQ(*dstDescTest.buffer + 1, 3); + EXPECT_EQ(*dstDescTest.buffer + 2, 4); + EXPECT_EQ(*dstDescTest.buffer + 3, 5); +} \ No newline at end of file -- Gitee From 11b037a230d7dd585556982c0db348b5756dd1ee Mon Sep 17 00:00:00 2001 From: weiyuantian Date: Sat, 23 Aug 2025 09:41:36 +0000 Subject: [PATCH 10/20] update services/audio_service/test/unittest/audio_0820_DT_test. Signed-off-by: weiyuantian --- .../test/unittest/audio_0820_DT_test | 234 ------------------ 1 file changed, 234 deletions(-) diff --git a/services/audio_service/test/unittest/audio_0820_DT_test b/services/audio_service/test/unittest/audio_0820_DT_test index 92b6e23602..e69de29bb2 100644 --- a/services/audio_service/test/unittest/audio_0820_DT_test +++ b/services/audio_service/test/unittest/audio_0820_DT_test @@ -1,234 +0,0 @@ -BufferDesc srcDescTest; -BufferDesc dstDescTest; -uint8_t srcBufferTest[8] = {1, 2, 3, 4}; -uint8_t dstBufferTest[8] = {0}; - -class BufferDescTest { -public: - BufferDescTest(uint8_t *buffersrc, uint8_t *bufferdst, size_t bufLengthsrc, size_t bufLengthdst) - { - srcDescTest.buffer = buffersrc; - dstDescTest.buffer = bufferdst; - srcDescTest.bufLength = bufLengthsrc; - dstDescTest.bufLength = bufLengthdst; - } -}; - - - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: F32MonoToS16Stereo_002 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, F32MonoToS16Stereo_002, TestSize.Level1) -{ - int32_t ret = -1; - BufferDescTest(nullptr, dstBufferTest, 4, 4); - ret = FormatConverter::F32MonoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); - - BufferDescTest(srcBufferTest, nullptr, 4, 4); - ret = FormatConverter::F32MonoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); - - BufferDescTest(srcBufferTest, dstBufferTest, 5, 5); - ret = FormatConverter::F32MonoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: F32MonoToS16Stereo_CapMax_001 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, F32MonoToS16Stereo_CapMax_001, TestSize.Level1) -{ - int32_t ret = -1; - uint8_t srcBuffer[4] = {2, 3, 4, 5}; - uint8_t dstBuffer[4] = {0}; - BufferDescTest(srcBuffer, dstBuffer, 4, 4); - ret = FormatConverter::F32MonoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, 0); - EXPECT_EQ(*dstDescTest.buffer, 0); - EXPECT_EQ(*dstDescTest.buffer + 1, 1); - EXPECT_EQ(*dstDescTest.buffer + 2, 2); - EXPECT_EQ(*dstDescTest.buffer + 3, 3); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: F32MonoToS16Stereo_CapMax_002 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, F32MonoToS16Stereo_CapMax_002, TestSize.Level1) -{ - int32_t ret = -1; - uint8_t srcBuffer[4] = {-2, 0, 1, 2}; - uint8_t dstBuffer[4] = {0}; - BufferDescTest(srcBuffer, dstBuffer, 4, 4); - ret = FormatConverter::F32MonoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, 0); - EXPECT_EQ(*dstDescTest.buffer, 0); - EXPECT_EQ(*dstDescTest.buffer + 1, 1); - EXPECT_EQ(*dstDescTest.buffer + 2, 2); - EXPECT_EQ(*dstDescTest.buffer + 3, 3); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: F32StereoToS16Stereo_002 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, F32StereoToS16Stereo_002, TestSize.Level1) -{ - int32_t ret = -1; - BufferDescTest(nullptr, dstBufferTest, 4, 2); - ret = FormatConverter::F32StereoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); - - BufferDescTest(srcBufferTest, nullptr, 4, 2); - ret = FormatConverter::F32StereoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); - - BufferDescTest(srcBufferTest, dstBufferTest, 6, 3); - ret = FormatConverter::F32StereoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: S16StereoToF32Mono_002 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, S16StereoToF32Mono_002, TestSize.Level1) -{ - int32_t ret = -1; - BufferDescTest(nullptr, dstBufferTest, 4, 4); - ret = FormatConverter::S16StereoToF32Mono(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); - - BufferDescTest(srcBufferTest, nullptr, 4, 4); - ret = FormatConverter::S16StereoToF32Mono(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: S16MonoToS32Stereo_001 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, S16MonoToS32Stereo_001, TestSize.Level1) -{ - int32_t ret = -1; - BufferDescTest(nullptr, dstBufferTest, 2, 8); - ret = FormatConverter::S16MonoToS32Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); - - BufferDescTest(srcBufferTest, nullptr, 2, 8); - ret = FormatConverter::S16MonoToS32Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); - - BufferDescTest(srcBufferTest, dstBufferTest, 4, 8); - ret = FormatConverter::S16MonoToS32Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: S32StereoToS16Stereo_001 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, S32StereoToS16Stereo_001, TestSize.Level1) -{ - int32_t ret = -1; - BufferDescTest(nullptr, dstBufferTest, 8, 4); - ret = FormatConverter::S32StereoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); - - BufferDescTest(srcBufferTest, nullptr, 8, 4); - ret = FormatConverter::S32StereoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, -1); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: S32MonoToS16Stereo_001 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, S32MonoToS16Stereo_001, TestSize.Level1) -{ - int32_t ret = -1; - BufferDescTest(srcBufferTest, dstBufferTest, 4, 4); - ret = FormatConverter::S32MonoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, 0); - EXPECT_EQ(*dstDescTest.buffer, 2); - EXPECT_EQ(*dstDescTest.buffer + 1, 3); - EXPECT_EQ(*dstDescTest.buffer + 2, 4); - EXPECT_EQ(*dstDescTest.buffer + 3, 5); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: S16MonoToS16Stereo_004 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, S16MonoToS16Stereo_004, TestSize.Level1) -{ - int32_t ret = -1; - BufferDescTest(srcBufferTest, dstBufferTest, 4, 8); - ret = FormatConverter::S16MonoToS16Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, 0); - EXPECT_EQ(*dstDescTest.buffer, 1); - EXPECT_EQ(*dstDescTest.buffer + 1, 2); - EXPECT_EQ(*dstDescTest.buffer + 2, 3); - EXPECT_EQ(*dstDescTest.buffer + 3, 4); - - ret = FormatConverter::S16StereoToS32Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, 0); - EXPECT_EQ(*dstDescTest.buffer, 2); - EXPECT_EQ(*dstDescTest.buffer + 1, 3); - EXPECT_EQ(*dstDescTest.buffer + 2, 4); - EXPECT_EQ(*dstDescTest.buffer + 3, 5); - - ret = FormatConverter::S32MonoToS32Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, 0); - EXPECT_EQ(*dstDescTest.buffer, 1); - EXPECT_EQ(*dstDescTest.buffer + 1, 2); - EXPECT_EQ(*dstDescTest.buffer + 2, 3); - EXPECT_EQ(*dstDescTest.buffer + 3, 4); - - ret = FormatConverter::F32MonoToS32Stereo(srcDescTest, dstDescTest); - EXPECT_EQ(ret, 0); - EXPECT_EQ(*dstDescTest.buffer, 0); - EXPECT_EQ(*dstDescTest.buffer + 1, 1); - EXPECT_EQ(*dstDescTest.buffer + 2, 2); - EXPECT_EQ(*dstDescTest.buffer + 3, 3); -} - -/** - * @tc.name : Test FormatConverter API - * @tc.type : FUNC - * @tc.number: S16StereoToS16Mono_001 - * @tc.desc : Test FormatConverter interface. - */ -HWTEST_F(FormatConverterUnitTest, S16StereoToS16Mono_001, TestSize.Level1) -{ - int32_t ret = -1; - BufferDescTest(srcBufferTest, dstBufferTest, 8, 4); - ret = FormatConverter::S16StereoToS16Mono(srcDescTest, dstDescTest); - EXPECT_EQ(ret, 0); - EXPECT_EQ(*dstDescTest.buffer, 2); - EXPECT_EQ(*dstDescTest.buffer + 1, 3); - EXPECT_EQ(*dstDescTest.buffer + 2, 4); - EXPECT_EQ(*dstDescTest.buffer + 3, 5); -} \ No newline at end of file -- Gitee From 9bd61021c112f0fa102258464c41aacc80249829 Mon Sep 17 00:00:00 2001 From: weiyuantian Date: Sat, 23 Aug 2025 10:26:10 +0000 Subject: [PATCH 11/20] update services/audio_service/test/unittest/audio_0820_DT_test. Signed-off-by: weiyuantian --- .../test/unittest/audio_0820_DT_test | 416 ++++++++++++++++++ 1 file changed, 416 insertions(+) diff --git a/services/audio_service/test/unittest/audio_0820_DT_test b/services/audio_service/test/unittest/audio_0820_DT_test index e69de29bb2..02004c07a0 100644 --- a/services/audio_service/test/unittest/audio_0820_DT_test +++ b/services/audio_service/test/unittest/audio_0820_DT_test @@ -0,0 +1,416 @@ + +ohos_unittest("sle_audio_operation_callback_stub_impl_unit_test") { + module_out_path = module_output_path + + include_dirs = [ + "./test/sle_audio_operation_callback_stub_impl_unit_test/include", + "../stub/include", + "../../../audio_policy/server/include", + "../../../audio_policy/server/domain/zone/include", + "../../../audio_policy/server/src", + "../../../audio_policy/server/src/interface", + "../../../audio_policy/server/infra/async_action_handler/include", + "../../../audio_policy/server/domain/interrupt/include", + "../../../audio_policy/server/src/service/service", + "../../../audio_policy/client/include", + "../../../audio_policy/client/src", + "../../../audio_policy/client/proxy", + "../../../audio_policy/common/include", + "../../../../frameworks/native/audiopolicy/include", + ] + + cflags = [ + "-Wall", + "-Werror", + "-Wno-macro-redefined", + ] + + cflags_cc = cflags + cflags_cc += [ "-fno-access-control" ] + + sanitize = { + cfi = true + cfi_cross_dso = true + boundary_sanitize = true + debug = false + integer_overflow = true + ubsan = true + } + + 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", + "pulseaudio:pulse", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + "accessibility:accessibility_common", + "accessibility:accessibilityconfig", + "ability_runtime:wantagent_innerkits", + ] + + sources = [ + "./test/sle_audio_operation_callback_stub_impl_unit_test/src/sle_audio_operation_callback_stub_impl_unit_test.cpp", + "../stub/src/sle_audio_operation_callback_stub_impl.cpp", + "../../../audio_policy/server/domain/zone/src/audio_zone_service.cpp", + "../service/src/audio_policy_manager.cpp", + "../service/src/audio_policy_manager_zone.cpp", + "./src/audio_policy_client_stub_impl.cpp", + ] + + deps = [ + "../../../../services/audio_service/idl:audio_framework_interface", + "../../../audio_policy:audio_policy_service_static", + ] + + configs = [ + "../../../../services/audio_policy:audio_policy_public_config", + "../../../../services/audio_policy:audio_policy_client_config", + ] + + if (bluetooth_part_enable == true) { + deps += + [ "../../../../frameworks/native/bluetoothclient:audio_bluetooth_client" ] + external_deps += [ "bluetooth:btframework" ] + } +} + + + +/* + * 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_operation_callback_stub_impl_unit_test.h" +#include "audio_errors.h" +#include "audio_policy_log.h" +#include "sle_audio_device_manager.h" + +#include +#include +#include +using namespace testing::ext; + +namespace OHOS { +namespace AudioStandard { + +void SleAudioOperationCallbackStubImplUnitTest::SetUpTestCase(void) {} +void SleAudioOperationCallbackStubImplUnitTest::TearDownTestCase(void) {} +void SleAudioOperationCallbackStubImplUnitTest::SetUp(void) {} +void SleAudioOperationCallbackStubImplUnitTest::TearDown(void) {} + +/** +* @tc.name : Test SleAudioOperationCallbackStubImplUnitTest. +* @tc.number: CallbackStubUnitTest_001 +* @tc.desc : Test SleAudioOperationCallbackStubImpl +*/ +HWTEST(SleAudioOperationCallbackStubImplUnitTest, CallbackStubUnitTest_001, TestSize.Level4) +{ + auto audioSleCb = new (std::nothrow) SleAudioOperationCallbackStubImpl(); + EXPECT_NE(audioSleCb, nullptr); + std::shared_ptr sleAudioOperationCallback; + auto ret = audioSleCb->SetSleAudioOperationCallback(sleAudioOperationCallback); + EXPECT_NE(-1, ret); + sleAudioOperationCallback = nullptr; + ret = audioSleCb->SetSleAudioOperationCallback(sleAudioOperationCallback); + EXPECT_NE(SUCCESS, ret); + delete audioSleCb; +} + +/** +* @tc.name : Test SleAudioOperationCallbackStubImplUnitTest. +* @tc.number: CallbackStubUnitTest_002 +* @tc.desc : Test GetSleAudioDeviceList +*/ +HWTEST(SleAudioOperationCallbackStubImplUnitTest, CallbackStubUnitTest_002, TestSize.Level4) +{ + auto audioSleCb = new (std::nothrow) SleAudioOperationCallbackStubImpl(); + std::vector devices; + EXPECT_NE(audioSleCb, nullptr); + auto ret = audioSleCb->GetSleAudioDeviceList(devices); + EXPECT_NE(SUCCESS, ret); + std::shared_ptr sleAudioOperationCallback; + audioSleCb->sleAudioOperationCallback_ = sleAudioOperationCallback; + ret = audioSleCb->GetSleAudioDeviceList(devices); + EXPECT_NE(-1, ret); + delete audioSleCb; +} + +/** +* @tc.name : Test SleAudioOperationCallbackStubImplUnitTest. +* @tc.number: CallbackStubUnitTest_003 +* @tc.desc : Test IsInBandRingOpen +*/ +HWTEST(SleAudioOperationCallbackStubImplUnitTest, CallbackStubUnitTest_003, TestSize.Level4) +{ + auto audioSleCb = new (std::nothrow) SleAudioOperationCallbackStubImpl(); + EXPECT_NE(audioSleCb, nullptr); + std::string device = "test"; + bool result = true; + auto ret = audioSleCb->IsInBandRingOpen(device, result); + EXPECT_EQ(SUCCESS, ret); + std::shared_ptr sleAudioOperationCallback; + audioSleCb->sleAudioOperationCallback_ = sleAudioOperationCallback; + ret = audioSleCb->IsInBandRingOpen(device, result); + EXPECT_NE(-1, ret); + delete audioSleCb; +} + +/** +* @tc.name : Test SleAudioOperationCallbackStubImplUnitTest. +* @tc.number: CallbackStubUnitTest_004 +* @tc.desc : Test GetSupportStreamType +*/ +HWTEST(SleAudioOperationCallbackStubImplUnitTest, CallbackStubUnitTest_004, TestSize.Level4) +{ + auto audioSleCb = new (std::nothrow) SleAudioOperationCallbackStubImpl(); + EXPECT_NE(audioSleCb, nullptr); + std::string device = "test"; + uint32_t retType = 0; + auto ret = audioSleCb->GetSupportStreamType(device, retType); + EXPECT_EQ(SUCCESS, ret); + std::shared_ptr sleAudioOperationCallback; + audioSleCb->sleAudioOperationCallback_ = sleAudioOperationCallback; + ret = audioSleCb->GetSupportStreamType(device, retType); + EXPECT_NE(-1, ret); + delete audioSleCb; +} + +/** +* @tc.name : Test SleAudioOperationCallbackStubImplUnitTest. +* @tc.number: CallbackStubUnitTest_005 +* @tc.desc : Test SetActiveSinkDevice +*/ +HWTEST(SleAudioOperationCallbackStubImplUnitTest, CallbackStubUnitTest_005, TestSize.Level4) +{ + auto audioSleCb = new (std::nothrow) SleAudioOperationCallbackStubImpl(); + EXPECT_NE(audioSleCb, nullptr); + std::string device = "test"; + uint32_t streamType = 0; + int32_t result = 0; + auto ret = audioSleCb->SetActiveSinkDevice(device, streamType, result); + EXPECT_NE(SUCCESS, ret); + std::shared_ptr sleAudioOperationCallback; + audioSleCb->sleAudioOperationCallback_ = sleAudioOperationCallback; + ret = audioSleCb->SetActiveSinkDevice(device, streamType, result); + EXPECT_NE(-1, ret); + delete audioSleCb; +} + +/** +* @tc.name : Test SleAudioOperationCallbackStubImplUnitTest. +* @tc.number: CallbackStubUnitTest_006 +* @tc.desc : Test StartPlaying +*/ +HWTEST(SleAudioOperationCallbackStubImplUnitTest, CallbackStubUnitTest_006, TestSize.Level4) +{ + auto audioSleCb = new (std::nothrow) SleAudioOperationCallbackStubImpl(); + EXPECT_NE(audioSleCb, nullptr); + std::string device = "test"; + uint32_t streamType = 0; + int32_t result = 0; + auto ret = audioSleCb->StartPlaying(device, streamType, result); + EXPECT_NE(SUCCESS, ret); + std::shared_ptr sleAudioOperationCallback; + audioSleCb->sleAudioOperationCallback_ = sleAudioOperationCallback; + ret = audioSleCb->StartPlaying(device, streamType, result); + EXPECT_NE(-1, ret); + delete audioSleCb; +} + +/** +* @tc.name : Test SleAudioOperationCallbackStubImplUnitTest. +* @tc.number: CallbackStubUnitTest_007 +* @tc.desc : Test StopPlaying +*/ +HWTEST(SleAudioOperationCallbackStubImplUnitTest, CallbackStubUnitTest_007, TestSize.Level4) +{ + auto audioSleCb = new (std::nothrow) SleAudioOperationCallbackStubImpl(); + EXPECT_NE(audioSleCb, nullptr); + std::string device = "test"; + uint32_t streamType = 0; + int32_t result = 0; + auto ret = audioSleCb->StopPlaying(device, streamType, result); + EXPECT_NE(SUCCESS, ret); + std::shared_ptr sleAudioOperationCallback; + audioSleCb->sleAudioOperationCallback_ = sleAudioOperationCallback; + ret = audioSleCb->StopPlaying(device, streamType, result); + EXPECT_NE(-1, ret); + delete audioSleCb; +} + +/** +* @tc.name : Test SleAudioOperationCallbackStubImplUnitTest. +* @tc.number: CallbackStubUnitTest_008 +* @tc.desc : Test ConnectAllowedProfiles +*/ +HWTEST(SleAudioOperationCallbackStubImplUnitTest, CallbackStubUnitTest_008, TestSize.Level4) +{ + auto audioSleCb = new (std::nothrow) SleAudioOperationCallbackStubImpl(); + EXPECT_NE(audioSleCb, nullptr); + std::string device = "test"; + int32_t result = 0; + auto ret = audioSleCb->ConnectAllowedProfiles(device, result); + EXPECT_NE(SUCCESS, ret); + std::shared_ptr sleAudioOperationCallback; + audioSleCb->sleAudioOperationCallback_ = sleAudioOperationCallback; + ret = audioSleCb->ConnectAllowedProfiles(device, result); + EXPECT_NE(-1, ret); + delete audioSleCb; +} + +/** +* @tc.name : Test SleAudioOperationCallbackStubImplUnitTest. +* @tc.number: CallbackStubUnitTest_009 +* @tc.desc : Test SetDeviceAbsVolume +*/ +HWTEST(SleAudioOperationCallbackStubImplUnitTest, CallbackStubUnitTest_009, TestSize.Level4) +{ + auto audioSleCb = new (std::nothrow) SleAudioOperationCallbackStubImpl(); + EXPECT_NE(audioSleCb, nullptr); + std::string remoteAddr = "test"; + uint32_t volume = 100; + uint32_t streamType = 0; + int32_t result = 0; + auto ret = audioSleCb->SetDeviceAbsVolume(remoteAddr, volume, streamType, result); + EXPECT_NE(SUCCESS, ret); + std::shared_ptr sleAudioOperationCallback; + audioSleCb->sleAudioOperationCallback_ = sleAudioOperationCallback; + ret = audioSleCb->SetDeviceAbsVolume(remoteAddr, volume, streamType, result); + EXPECT_NE(-1, ret); + delete audioSleCb; +} + +/** +* @tc.name : Test SleAudioOperationCallbackStubImplUnitTest. +* @tc.number: CallbackStubUnitTest_010 +* @tc.desc : Test SendUserSelection +*/ +HWTEST(SleAudioOperationCallbackStubImplUnitTest, CallbackStubUnitTest_010, TestSize.Level4) +{ + auto audioSleCb = new (std::nothrow) SleAudioOperationCallbackStubImpl(); + EXPECT_NE(audioSleCb, nullptr); + std::string device = "test"; + uint32_t streamType = 0; + int32_t result = 0; + auto ret = audioSleCb->SendUserSelection(device, streamType, result); + EXPECT_NE(SUCCESS, ret); + std::shared_ptr sleAudioOperationCallback; + audioSleCb->sleAudioOperationCallback_ = sleAudioOperationCallback; + ret = audioSleCb->SendUserSelection(device, streamType, result); + EXPECT_NE(-1, ret); + delete audioSleCb; +} + +/** +* @tc.name : Test SleAudioOperationCallbackStubImplUnitTest. +* @tc.number: CallbackStubUnitTest_011 +* @tc.desc : Test GetRenderPosition +*/ +HWTEST(SleAudioOperationCallbackStubImplUnitTest, CallbackStubUnitTest_011, TestSize.Level4) +{ + auto audioSleCb = new (std::nothrow) SleAudioOperationCallbackStubImpl(); + EXPECT_NE(audioSleCb, nullptr); + std::string device = "test"; + uint32_t delayValue = 0; + auto ret = audioSleCb->GetRenderPosition(device, delayValue); + EXPECT_NE(SUCCESS, ret); + std::shared_ptr sleAudioOperationCallback; + audioSleCb->sleAudioOperationCallback_ = sleAudioOperationCallback; + ret = audioSleCb->GetRenderPosition(device, delayValue); + EXPECT_NE(-1, ret); + delete audioSleCb; +} +} // namespace AudioStandard +} // namespace OHOS + +sle_audio_operation_callback_stub_impl_unit_test + + + + + +/* + * 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 SLE_AUDIO_OPERATION_CALLBACK_STUB_UNIT_TEST_H +#define SLE_AUDIO_OPERATION_CALLBACK_STUB_UNIT_TEST_H + +#include "gtest/gtest.h" +#include "audio_policy_interface.h" +#include "standard_sle_audio_operation_callback_stub.h" +#include "sle_audio_operation_callback_stub_impl.h" + +namespace OHOS { +namespace AudioStandard { + +class SleAudioOperationCallbackStubImplUnitTest : 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 // SLE_AUDIO_OPERATION_CALLBACK_STUB_UNIT_TEST_H -- Gitee From a6ad267758ca60a7ff99eeb6a77d41cf56f3e2b2 Mon Sep 17 00:00:00 2001 From: weiyuantian Date: Sat, 23 Aug 2025 10:32:12 +0000 Subject: [PATCH 12/20] update services/audio_service/test/unittest/audio_0820_DT_test. Signed-off-by: weiyuantian --- services/audio_service/test/unittest/audio_0820_DT_test | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/services/audio_service/test/unittest/audio_0820_DT_test b/services/audio_service/test/unittest/audio_0820_DT_test index 02004c07a0..5c6659a26f 100644 --- a/services/audio_service/test/unittest/audio_0820_DT_test +++ b/services/audio_service/test/unittest/audio_0820_DT_test @@ -414,3 +414,7 @@ public: } // namespace AudioStandard } // namespace OHOS #endif // SLE_AUDIO_OPERATION_CALLBACK_STUB_UNIT_TEST_H + + + "../client/stub/test/unittest:audio_zone_client_unit_test", + "../client/stub/test/unittest:sle_audio_operation_callback_stub_impl_unit_test" \ No newline at end of file -- Gitee From 3dc63346396ff168e5abe6a068426fbf7f45ec69 Mon Sep 17 00:00:00 2001 From: weiyuantian Date: Sat, 23 Aug 2025 11:09:36 +0000 Subject: [PATCH 13/20] update services/audio_service/test/unittest/audio_0820_DT_test. Signed-off-by: weiyuantian --- .../test/unittest/audio_0820_DT_test | 423 +----------------- 1 file changed, 5 insertions(+), 418 deletions(-) diff --git a/services/audio_service/test/unittest/audio_0820_DT_test b/services/audio_service/test/unittest/audio_0820_DT_test index 5c6659a26f..aa350aece9 100644 --- a/services/audio_service/test/unittest/audio_0820_DT_test +++ b/services/audio_service/test/unittest/audio_0820_DT_test @@ -1,420 +1,7 @@ - -ohos_unittest("sle_audio_operation_callback_stub_impl_unit_test") { - module_out_path = module_output_path - - include_dirs = [ - "./test/sle_audio_operation_callback_stub_impl_unit_test/include", - "../stub/include", - "../../../audio_policy/server/include", - "../../../audio_policy/server/domain/zone/include", - "../../../audio_policy/server/src", - "../../../audio_policy/server/src/interface", - "../../../audio_policy/server/infra/async_action_handler/include", - "../../../audio_policy/server/domain/interrupt/include", - "../../../audio_policy/server/src/service/service", - "../../../audio_policy/client/include", - "../../../audio_policy/client/src", - "../../../audio_policy/client/proxy", - "../../../audio_policy/common/include", - "../../../../frameworks/native/audiopolicy/include", - ] - - cflags = [ - "-Wall", - "-Werror", - "-Wno-macro-redefined", - ] - - cflags_cc = cflags - cflags_cc += [ "-fno-access-control" ] - - sanitize = { - cfi = true - cfi_cross_dso = true - boundary_sanitize = true - debug = false - integer_overflow = true - ubsan = true - } - - 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", - "pulseaudio:pulse", - "safwk:system_ability_fwk", - "samgr:samgr_proxy", - "accessibility:accessibility_common", - "accessibility:accessibilityconfig", - "ability_runtime:wantagent_innerkits", - ] - - sources = [ - "./test/sle_audio_operation_callback_stub_impl_unit_test/src/sle_audio_operation_callback_stub_impl_unit_test.cpp", - "../stub/src/sle_audio_operation_callback_stub_impl.cpp", - "../../../audio_policy/server/domain/zone/src/audio_zone_service.cpp", - "../service/src/audio_policy_manager.cpp", - "../service/src/audio_policy_manager_zone.cpp", - "./src/audio_policy_client_stub_impl.cpp", - ] - +group("client_stub_unit_test_group") { + testonly = true deps = [ - "../../../../services/audio_service/idl:audio_framework_interface", - "../../../audio_policy:audio_policy_service_static", - ] - - configs = [ - "../../../../services/audio_policy:audio_policy_public_config", - "../../../../services/audio_policy:audio_policy_client_config", + ":audio_zone_client_unit_test", + ":sle_audio_operation_callback_stub_impl_unit_test", ] - - if (bluetooth_part_enable == true) { - deps += - [ "../../../../frameworks/native/bluetoothclient:audio_bluetooth_client" ] - external_deps += [ "bluetooth:btframework" ] - } -} - - - -/* - * 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_operation_callback_stub_impl_unit_test.h" -#include "audio_errors.h" -#include "audio_policy_log.h" -#include "sle_audio_device_manager.h" - -#include -#include -#include -using namespace testing::ext; - -namespace OHOS { -namespace AudioStandard { - -void SleAudioOperationCallbackStubImplUnitTest::SetUpTestCase(void) {} -void SleAudioOperationCallbackStubImplUnitTest::TearDownTestCase(void) {} -void SleAudioOperationCallbackStubImplUnitTest::SetUp(void) {} -void SleAudioOperationCallbackStubImplUnitTest::TearDown(void) {} - -/** -* @tc.name : Test SleAudioOperationCallbackStubImplUnitTest. -* @tc.number: CallbackStubUnitTest_001 -* @tc.desc : Test SleAudioOperationCallbackStubImpl -*/ -HWTEST(SleAudioOperationCallbackStubImplUnitTest, CallbackStubUnitTest_001, TestSize.Level4) -{ - auto audioSleCb = new (std::nothrow) SleAudioOperationCallbackStubImpl(); - EXPECT_NE(audioSleCb, nullptr); - std::shared_ptr sleAudioOperationCallback; - auto ret = audioSleCb->SetSleAudioOperationCallback(sleAudioOperationCallback); - EXPECT_NE(-1, ret); - sleAudioOperationCallback = nullptr; - ret = audioSleCb->SetSleAudioOperationCallback(sleAudioOperationCallback); - EXPECT_NE(SUCCESS, ret); - delete audioSleCb; -} - -/** -* @tc.name : Test SleAudioOperationCallbackStubImplUnitTest. -* @tc.number: CallbackStubUnitTest_002 -* @tc.desc : Test GetSleAudioDeviceList -*/ -HWTEST(SleAudioOperationCallbackStubImplUnitTest, CallbackStubUnitTest_002, TestSize.Level4) -{ - auto audioSleCb = new (std::nothrow) SleAudioOperationCallbackStubImpl(); - std::vector devices; - EXPECT_NE(audioSleCb, nullptr); - auto ret = audioSleCb->GetSleAudioDeviceList(devices); - EXPECT_NE(SUCCESS, ret); - std::shared_ptr sleAudioOperationCallback; - audioSleCb->sleAudioOperationCallback_ = sleAudioOperationCallback; - ret = audioSleCb->GetSleAudioDeviceList(devices); - EXPECT_NE(-1, ret); - delete audioSleCb; -} - -/** -* @tc.name : Test SleAudioOperationCallbackStubImplUnitTest. -* @tc.number: CallbackStubUnitTest_003 -* @tc.desc : Test IsInBandRingOpen -*/ -HWTEST(SleAudioOperationCallbackStubImplUnitTest, CallbackStubUnitTest_003, TestSize.Level4) -{ - auto audioSleCb = new (std::nothrow) SleAudioOperationCallbackStubImpl(); - EXPECT_NE(audioSleCb, nullptr); - std::string device = "test"; - bool result = true; - auto ret = audioSleCb->IsInBandRingOpen(device, result); - EXPECT_EQ(SUCCESS, ret); - std::shared_ptr sleAudioOperationCallback; - audioSleCb->sleAudioOperationCallback_ = sleAudioOperationCallback; - ret = audioSleCb->IsInBandRingOpen(device, result); - EXPECT_NE(-1, ret); - delete audioSleCb; -} - -/** -* @tc.name : Test SleAudioOperationCallbackStubImplUnitTest. -* @tc.number: CallbackStubUnitTest_004 -* @tc.desc : Test GetSupportStreamType -*/ -HWTEST(SleAudioOperationCallbackStubImplUnitTest, CallbackStubUnitTest_004, TestSize.Level4) -{ - auto audioSleCb = new (std::nothrow) SleAudioOperationCallbackStubImpl(); - EXPECT_NE(audioSleCb, nullptr); - std::string device = "test"; - uint32_t retType = 0; - auto ret = audioSleCb->GetSupportStreamType(device, retType); - EXPECT_EQ(SUCCESS, ret); - std::shared_ptr sleAudioOperationCallback; - audioSleCb->sleAudioOperationCallback_ = sleAudioOperationCallback; - ret = audioSleCb->GetSupportStreamType(device, retType); - EXPECT_NE(-1, ret); - delete audioSleCb; -} - -/** -* @tc.name : Test SleAudioOperationCallbackStubImplUnitTest. -* @tc.number: CallbackStubUnitTest_005 -* @tc.desc : Test SetActiveSinkDevice -*/ -HWTEST(SleAudioOperationCallbackStubImplUnitTest, CallbackStubUnitTest_005, TestSize.Level4) -{ - auto audioSleCb = new (std::nothrow) SleAudioOperationCallbackStubImpl(); - EXPECT_NE(audioSleCb, nullptr); - std::string device = "test"; - uint32_t streamType = 0; - int32_t result = 0; - auto ret = audioSleCb->SetActiveSinkDevice(device, streamType, result); - EXPECT_NE(SUCCESS, ret); - std::shared_ptr sleAudioOperationCallback; - audioSleCb->sleAudioOperationCallback_ = sleAudioOperationCallback; - ret = audioSleCb->SetActiveSinkDevice(device, streamType, result); - EXPECT_NE(-1, ret); - delete audioSleCb; -} - -/** -* @tc.name : Test SleAudioOperationCallbackStubImplUnitTest. -* @tc.number: CallbackStubUnitTest_006 -* @tc.desc : Test StartPlaying -*/ -HWTEST(SleAudioOperationCallbackStubImplUnitTest, CallbackStubUnitTest_006, TestSize.Level4) -{ - auto audioSleCb = new (std::nothrow) SleAudioOperationCallbackStubImpl(); - EXPECT_NE(audioSleCb, nullptr); - std::string device = "test"; - uint32_t streamType = 0; - int32_t result = 0; - auto ret = audioSleCb->StartPlaying(device, streamType, result); - EXPECT_NE(SUCCESS, ret); - std::shared_ptr sleAudioOperationCallback; - audioSleCb->sleAudioOperationCallback_ = sleAudioOperationCallback; - ret = audioSleCb->StartPlaying(device, streamType, result); - EXPECT_NE(-1, ret); - delete audioSleCb; -} - -/** -* @tc.name : Test SleAudioOperationCallbackStubImplUnitTest. -* @tc.number: CallbackStubUnitTest_007 -* @tc.desc : Test StopPlaying -*/ -HWTEST(SleAudioOperationCallbackStubImplUnitTest, CallbackStubUnitTest_007, TestSize.Level4) -{ - auto audioSleCb = new (std::nothrow) SleAudioOperationCallbackStubImpl(); - EXPECT_NE(audioSleCb, nullptr); - std::string device = "test"; - uint32_t streamType = 0; - int32_t result = 0; - auto ret = audioSleCb->StopPlaying(device, streamType, result); - EXPECT_NE(SUCCESS, ret); - std::shared_ptr sleAudioOperationCallback; - audioSleCb->sleAudioOperationCallback_ = sleAudioOperationCallback; - ret = audioSleCb->StopPlaying(device, streamType, result); - EXPECT_NE(-1, ret); - delete audioSleCb; -} - -/** -* @tc.name : Test SleAudioOperationCallbackStubImplUnitTest. -* @tc.number: CallbackStubUnitTest_008 -* @tc.desc : Test ConnectAllowedProfiles -*/ -HWTEST(SleAudioOperationCallbackStubImplUnitTest, CallbackStubUnitTest_008, TestSize.Level4) -{ - auto audioSleCb = new (std::nothrow) SleAudioOperationCallbackStubImpl(); - EXPECT_NE(audioSleCb, nullptr); - std::string device = "test"; - int32_t result = 0; - auto ret = audioSleCb->ConnectAllowedProfiles(device, result); - EXPECT_NE(SUCCESS, ret); - std::shared_ptr sleAudioOperationCallback; - audioSleCb->sleAudioOperationCallback_ = sleAudioOperationCallback; - ret = audioSleCb->ConnectAllowedProfiles(device, result); - EXPECT_NE(-1, ret); - delete audioSleCb; -} - -/** -* @tc.name : Test SleAudioOperationCallbackStubImplUnitTest. -* @tc.number: CallbackStubUnitTest_009 -* @tc.desc : Test SetDeviceAbsVolume -*/ -HWTEST(SleAudioOperationCallbackStubImplUnitTest, CallbackStubUnitTest_009, TestSize.Level4) -{ - auto audioSleCb = new (std::nothrow) SleAudioOperationCallbackStubImpl(); - EXPECT_NE(audioSleCb, nullptr); - std::string remoteAddr = "test"; - uint32_t volume = 100; - uint32_t streamType = 0; - int32_t result = 0; - auto ret = audioSleCb->SetDeviceAbsVolume(remoteAddr, volume, streamType, result); - EXPECT_NE(SUCCESS, ret); - std::shared_ptr sleAudioOperationCallback; - audioSleCb->sleAudioOperationCallback_ = sleAudioOperationCallback; - ret = audioSleCb->SetDeviceAbsVolume(remoteAddr, volume, streamType, result); - EXPECT_NE(-1, ret); - delete audioSleCb; -} - -/** -* @tc.name : Test SleAudioOperationCallbackStubImplUnitTest. -* @tc.number: CallbackStubUnitTest_010 -* @tc.desc : Test SendUserSelection -*/ -HWTEST(SleAudioOperationCallbackStubImplUnitTest, CallbackStubUnitTest_010, TestSize.Level4) -{ - auto audioSleCb = new (std::nothrow) SleAudioOperationCallbackStubImpl(); - EXPECT_NE(audioSleCb, nullptr); - std::string device = "test"; - uint32_t streamType = 0; - int32_t result = 0; - auto ret = audioSleCb->SendUserSelection(device, streamType, result); - EXPECT_NE(SUCCESS, ret); - std::shared_ptr sleAudioOperationCallback; - audioSleCb->sleAudioOperationCallback_ = sleAudioOperationCallback; - ret = audioSleCb->SendUserSelection(device, streamType, result); - EXPECT_NE(-1, ret); - delete audioSleCb; -} - -/** -* @tc.name : Test SleAudioOperationCallbackStubImplUnitTest. -* @tc.number: CallbackStubUnitTest_011 -* @tc.desc : Test GetRenderPosition -*/ -HWTEST(SleAudioOperationCallbackStubImplUnitTest, CallbackStubUnitTest_011, TestSize.Level4) -{ - auto audioSleCb = new (std::nothrow) SleAudioOperationCallbackStubImpl(); - EXPECT_NE(audioSleCb, nullptr); - std::string device = "test"; - uint32_t delayValue = 0; - auto ret = audioSleCb->GetRenderPosition(device, delayValue); - EXPECT_NE(SUCCESS, ret); - std::shared_ptr sleAudioOperationCallback; - audioSleCb->sleAudioOperationCallback_ = sleAudioOperationCallback; - ret = audioSleCb->GetRenderPosition(device, delayValue); - EXPECT_NE(-1, ret); - delete audioSleCb; -} -} // namespace AudioStandard -} // namespace OHOS - -sle_audio_operation_callback_stub_impl_unit_test - - - - - -/* - * 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 SLE_AUDIO_OPERATION_CALLBACK_STUB_UNIT_TEST_H -#define SLE_AUDIO_OPERATION_CALLBACK_STUB_UNIT_TEST_H - -#include "gtest/gtest.h" -#include "audio_policy_interface.h" -#include "standard_sle_audio_operation_callback_stub.h" -#include "sle_audio_operation_callback_stub_impl.h" - -namespace OHOS { -namespace AudioStandard { - -class SleAudioOperationCallbackStubImplUnitTest : 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 // SLE_AUDIO_OPERATION_CALLBACK_STUB_UNIT_TEST_H - - - "../client/stub/test/unittest:audio_zone_client_unit_test", - "../client/stub/test/unittest:sle_audio_operation_callback_stub_impl_unit_test" \ No newline at end of file +} \ No newline at end of file -- Gitee From c1885e563037c242f3b42bd0c64eb880686486c9 Mon Sep 17 00:00:00 2001 From: weiyuantian Date: Tue, 26 Aug 2025 07:22:40 +0000 Subject: [PATCH 14/20] update services/audio_service/test/unittest/audio_0820_DT_test. Signed-off-by: weiyuantian --- .../test/unittest/audio_0820_DT_test | 179 +++++++++++++++++- 1 file changed, 172 insertions(+), 7 deletions(-) diff --git a/services/audio_service/test/unittest/audio_0820_DT_test b/services/audio_service/test/unittest/audio_0820_DT_test index aa350aece9..da79e820cd 100644 --- a/services/audio_service/test/unittest/audio_0820_DT_test +++ b/services/audio_service/test/unittest/audio_0820_DT_test @@ -1,7 +1,172 @@ -group("client_stub_unit_test_group") { - testonly = true - deps = [ - ":audio_zone_client_unit_test", - ":sle_audio_operation_callback_stub_impl_unit_test", - ] -} \ No newline at end of file +frameworks/native/audiopolicy/test/unittest/manager_test/src/audio_manager_interrupt_unit_test.cpp +HWTEST(AudioManagerInterruptUnitTest, SetAppConcurrencyMode_001, TestSize.Level1) +{ + int32_t uid = 0; + int32_t mode = 0; + auto ret = AudioSystemManager::GetInstance()->SetAppConcurrencyMode(uid, mode); + EXPECT_EQ(ret, ERR_SYSTEM_PERMISSION_DENIED); +} + +HWTEST(AudioManagerInterruptUnitTest, SetAppSilentOnDisplay_001, TestSize.Level1) +{ + int32_t displayId = 0; + auto ret = AudioSystemManager::GetInstance()->SetAppSilentOnDisplay(displayId); + EXPECT_EQ(ret, ERR_SYSTEM_PERMISSION_DENIED); +} + + + +services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_interrupt_unit_test.cpp +HWTEST(AudioInterruptUnitTest, AudioPolicyServer_001, TestSize.Level1) +{ + auto policyServerTest = GetPolicyServerTest(); + int32_t systemAbilityId = 3009; + bool runOnCreate = false; + sptr server = sptr::MakeSptr(systemAbilityId, runOnCreate); + + AudioInterrupt audioInterrupt; + int32_t zoneID = 456; + pid_t pid = 1; + pid_t uid = 1; + int32_t strategy = 0; + server->interruptService_ = std::make_shared(); + int32_t result = server->DeactivateAudioInterrupt(audioInterrupt, zoneID); + EXPECT_EQ(result, SUCCESS); + EXPECT_EQ(policyServerTest->ActivateAudioSession(strategy), ERR_UNKNOWN); + server->RegisteredStreamListenerClientDied(pid, uid); +} + + + + +services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_policy_server_unit_test.cpp +HWTEST(AudioPolicyUnitTest, AudioPolicyServer_009, TestSize.Level1) +{ + auto policyServerTest = GetPolicyServerUnitTest(); + int32_t systemAbilityId = 3009; + bool runOnCreate = false; + sptr server = sptr::MakeSptr(systemAbilityId, runOnCreate); + + AudioInterrupt audioInterrupt; + int32_t zoneID = 456; + + int32_t result = server->DeactivateAudioInterrupt(audioInterrupt, zoneID); + EXPECT_EQ(result, ERR_UNKNOWN); + server->interruptService_ = std::make_shared(); + result = server->DeactivateAudioInterrupt(audioInterrupt, zoneID); + EXPECT_EQ(result, 0); +} + +HWTEST(AudioPolicyUnitTest, AudioPolicyServer_016, TestSize.Level1) +{ + auto policyServerTest = GetPolicyServerUnitTest(); + AudioInterrupt audioInterrupt; + int32_t zoneID = 456; + int32_t result = 0; + policyServerTest->ActivateAudioInterrupt(audioInterrupt, zoneID, result); + EXPECT_EQ(result, SUCCESS); +} + +HWTEST(AudioPolicyUnitTest, AudioPolicyServer_025, TestSize.Level1) +{ + int32_t systemAbilityId = 3009; + bool runOnCreate = false; + auto ptrAudioPolicyServer = std::make_shared(systemAbilityId, runOnCreate); + + EXPECT_NE(ptrAudioPolicyServer, nullptr); + + int32_t strategy = 0; + ptrAudioPolicyServer->interruptService_ = std::make_shared(); + + auto ret = ptrAudioPolicyServer->ActivateAudioSession(strategy); + + EXPECT_EQ(ret, ERR_UNKNOWN); +} + + + +services/audio_service/test/unittest/audio_server_unit_test/src/audio_server_unit_test.cpp +HWTEST_F(AudioServerUnitTest, OffloadSetVolume_001, TestSize.Level1) +{ + EXPECT_NE(nullptr, audioServer); + int32_t ret = audioServer->OffloadSetVolume(0.5f, "offload", "default"); + EXPECT_EQ(ret, ERR_NOT_SUPPORTED); +} + +HWTEST_F(AudioServerUnitTest, ResetRouteForDisconnect_001, TestSize.Level1) +{ + DeviceType deviceType = DEVICE_TYPE_USB_ARM_HEADSET; + + EXPECT_NE(nullptr, audioServer); + auto ret = audioServer->ResetRouteForDisconnect(deviceType); + EXPECT_EQ(ret, ERR_NOT_SUPPORTED); +} + +HWTEST_F(AudioServerUnitTest, NotifyStreamVolumeChanged_001, TestSize.Level1) +{ + EXPECT_NE(nullptr, audioServer); + AudioStreamType streamType = STREAM_MUSIC; + float volume = 0.5f; + int32_t ret = audioServer->NotifyStreamVolumeChanged(streamType, volume); + EXPECT_EQ(ret, ERR_NOT_SUPPORTED); + + streamType = static_cast(-1); + ret = audioServer->NotifyStreamVolumeChanged(streamType, volume); + EXPECT_EQ(ret, ERR_NOT_SUPPORTED); + + streamType = STREAM_MUSIC; + volume = -1.0f; + ret = audioServer->NotifyStreamVolumeChanged(streamType, volume); + EXPECT_EQ(ret, ERR_NOT_SUPPORTED); +} + +HWTEST_F(AudioServerUnitTest, GetVolumeDataCount_001, TestSize.Level1) +{ + EXPECT_NE(nullptr, audioServer); + std::string testName = "testSink"; + int64_t volueDataCount = 0; + int32_t ret = audioServer->GetVolumeDataCount(testName, volueDataCount); + EXPECT_EQ(ret, ERR_PERMISSION_DENIED); + EXPECT_EQ(volueDataCount, 0); +} + +HWTEST_F(AudioServerUnitTest, ResetRecordConfig_001, TestSize.Level1) +{ + EXPECT_NE(nullptr, audioServer); + + AudioProcessConfig config; + config.capturerInfo.sourceType = SourceType::SOURCE_TYPE_LIVE; + + audioServer->ResetRecordConfig(config); + EXPECT_EQ(config.capturerInfo.sourceType, SOURCE_TYPE_LIVE); +} + +#ifdef TEMP_DISABLE +/** + * @tc.name : Test SetRenderWhitelist API + * @tc.type : FUNC + * @tc.number: AudioServerSetRenderWhitelist_001 + * @tc.desc : Test SetRenderWhitelist interface. + */ +HWTEST_F(AudioServerUnitTest, AudioServerSetRenderWhitelist_001, TestSize.Level2) +{ + EXPECT_NE(nullptr, audioServer); + + std::vector list; + list.push_back("com.test"); + int32_t ret = audioServer->SetRenderWhitelist(list); + EXPECT_EQ(SUCCESS, ret); +} +#endif + + + + + +services/audio_service/test/unittest/audio_service_unit_test.cpp +HWTEST(AudioServiceUnitTest, SaveRenderWhitelist_001, TestSize.Level1) +{ + std::vector list = { "test1", "test2", "test3" }; + AudioService::GetInstance()->SaveRenderWhitelist(list); + EXPECT_EQ(AudioService::GetInstance()->renderWhitelist_.size(), 3); +} -- Gitee From 5b4f2c5a996a8077eae10c4c1e81700068fd59c1 Mon Sep 17 00:00:00 2001 From: weiyuantian Date: Wed, 27 Aug 2025 07:06:00 +0000 Subject: [PATCH 15/20] update services/audio_service/test/unittest/audio_0820_DT_test. Signed-off-by: weiyuantian --- .../test/unittest/audio_0820_DT_test | 63 ------------------- 1 file changed, 63 deletions(-) diff --git a/services/audio_service/test/unittest/audio_0820_DT_test b/services/audio_service/test/unittest/audio_0820_DT_test index da79e820cd..9481d04574 100644 --- a/services/audio_service/test/unittest/audio_0820_DT_test +++ b/services/audio_service/test/unittest/audio_0820_DT_test @@ -3,69 +3,6 @@ HWTEST(AudioManagerInterruptUnitTest, SetAppConcurrencyMode_001, TestSize.Level1 { int32_t uid = 0; int32_t mode = 0; - auto ret = AudioSystemManager::GetInstance()->SetAppConcurrencyMode(uid, mode); - EXPECT_EQ(ret, ERR_SYSTEM_PERMISSION_DENIED); -} - -HWTEST(AudioManagerInterruptUnitTest, SetAppSilentOnDisplay_001, TestSize.Level1) -{ - int32_t displayId = 0; - auto ret = AudioSystemManager::GetInstance()->SetAppSilentOnDisplay(displayId); - EXPECT_EQ(ret, ERR_SYSTEM_PERMISSION_DENIED); -} - - - -services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_interrupt_unit_test.cpp -HWTEST(AudioInterruptUnitTest, AudioPolicyServer_001, TestSize.Level1) -{ - auto policyServerTest = GetPolicyServerTest(); - int32_t systemAbilityId = 3009; - bool runOnCreate = false; - sptr server = sptr::MakeSptr(systemAbilityId, runOnCreate); - - AudioInterrupt audioInterrupt; - int32_t zoneID = 456; - pid_t pid = 1; - pid_t uid = 1; - int32_t strategy = 0; - server->interruptService_ = std::make_shared(); - int32_t result = server->DeactivateAudioInterrupt(audioInterrupt, zoneID); - EXPECT_EQ(result, SUCCESS); - EXPECT_EQ(policyServerTest->ActivateAudioSession(strategy), ERR_UNKNOWN); - server->RegisteredStreamListenerClientDied(pid, uid); -} - - - - -services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_policy_server_unit_test.cpp -HWTEST(AudioPolicyUnitTest, AudioPolicyServer_009, TestSize.Level1) -{ - auto policyServerTest = GetPolicyServerUnitTest(); - int32_t systemAbilityId = 3009; - bool runOnCreate = false; - sptr server = sptr::MakeSptr(systemAbilityId, runOnCreate); - - AudioInterrupt audioInterrupt; - int32_t zoneID = 456; - - int32_t result = server->DeactivateAudioInterrupt(audioInterrupt, zoneID); - EXPECT_EQ(result, ERR_UNKNOWN); - server->interruptService_ = std::make_shared(); - result = server->DeactivateAudioInterrupt(audioInterrupt, zoneID); - EXPECT_EQ(result, 0); -} - -HWTEST(AudioPolicyUnitTest, AudioPolicyServer_016, TestSize.Level1) -{ - auto policyServerTest = GetPolicyServerUnitTest(); - AudioInterrupt audioInterrupt; - int32_t zoneID = 456; - int32_t result = 0; - policyServerTest->ActivateAudioInterrupt(audioInterrupt, zoneID, result); - EXPECT_EQ(result, SUCCESS); -} HWTEST(AudioPolicyUnitTest, AudioPolicyServer_025, TestSize.Level1) { -- Gitee From 6c8cd73bc598cafbda92112d833a3cf894cf75a9 Mon Sep 17 00:00:00 2001 From: weiyuantian Date: Wed, 27 Aug 2025 07:44:47 +0000 Subject: [PATCH 16/20] update services/audio_service/test/unittest/audio_0820_DT_test. Signed-off-by: weiyuantian --- .../test/unittest/audio_0820_DT_test | 162 ++++++++---------- 1 file changed, 70 insertions(+), 92 deletions(-) diff --git a/services/audio_service/test/unittest/audio_0820_DT_test b/services/audio_service/test/unittest/audio_0820_DT_test index 9481d04574..03d1e17791 100644 --- a/services/audio_service/test/unittest/audio_0820_DT_test +++ b/services/audio_service/test/unittest/audio_0820_DT_test @@ -1,109 +1,87 @@ -frameworks/native/audiopolicy/test/unittest/manager_test/src/audio_manager_interrupt_unit_test.cpp -HWTEST(AudioManagerInterruptUnitTest, SetAppConcurrencyMode_001, TestSize.Level1) -{ - int32_t uid = 0; - int32_t mode = 0; + std::string GetRealBundleName(uint32_t uid); + std::string GetBundleName2(uint32_t uid); -HWTEST(AudioPolicyUnitTest, AudioPolicyServer_025, TestSize.Level1) -{ - int32_t systemAbilityId = 3009; - bool runOnCreate = false; - auto ptrAudioPolicyServer = std::make_shared(systemAbilityId, runOnCreate); - - EXPECT_NE(ptrAudioPolicyServer, nullptr); - - int32_t strategy = 0; - ptrAudioPolicyServer->interruptService_ = std::make_shared(); - - auto ret = ptrAudioPolicyServer->ActivateAudioSession(strategy); - - EXPECT_EQ(ret, ERR_UNKNOWN); -} + void UpdateMicFocusStrategy(SourceType existSourceType, SourceType incomingSourceType, + const std::string ¤tBundleName, const std::string &incomingBundleName, AudioFocusEntry &focusEntry); -services/audio_service/test/unittest/audio_server_unit_test/src/audio_server_unit_test.cpp -HWTEST_F(AudioServerUnitTest, OffloadSetVolume_001, TestSize.Level1) -{ - EXPECT_NE(nullptr, audioServer); - int32_t ret = audioServer->OffloadSetVolume(0.5f, "offload", "default"); - EXPECT_EQ(ret, ERR_NOT_SUPPORTED); -} -HWTEST_F(AudioServerUnitTest, ResetRouteForDisconnect_001, TestSize.Level1) -{ - DeviceType deviceType = DEVICE_TYPE_USB_ARM_HEADSET; - - EXPECT_NE(nullptr, audioServer); - auto ret = audioServer->ResetRouteForDisconnect(deviceType); - EXPECT_EQ(ret, ERR_NOT_SUPPORTED); -} -HWTEST_F(AudioServerUnitTest, NotifyStreamVolumeChanged_001, TestSize.Level1) +std::string AudioInterruptService::GetBundleName2(uint32_t uid) { - EXPECT_NE(nullptr, audioServer); - AudioStreamType streamType = STREAM_MUSIC; - float volume = 0.5f; - int32_t ret = audioServer->NotifyStreamVolumeChanged(streamType, volume); - EXPECT_EQ(ret, ERR_NOT_SUPPORTED); - - streamType = static_cast(-1); - ret = audioServer->NotifyStreamVolumeChanged(streamType, volume); - EXPECT_EQ(ret, ERR_NOT_SUPPORTED); - - streamType = STREAM_MUSIC; - volume = -1.0f; - ret = audioServer->NotifyStreamVolumeChanged(streamType, volume); - EXPECT_EQ(ret, ERR_NOT_SUPPORTED); + CHECK_AND_RETURN_RET_LOG(policyServer_ != nullptr, "", "policyServer nullptr"); + auto info = AudioBundleManager::GetBundleInfoFromUid(uid); + return info.name; } -HWTEST_F(AudioServerUnitTest, GetVolumeDataCount_001, TestSize.Level1) -{ - EXPECT_NE(nullptr, audioServer); - std::string testName = "testSink"; - int64_t volueDataCount = 0; - int32_t ret = audioServer->GetVolumeDataCount(testName, volueDataCount); - EXPECT_EQ(ret, ERR_PERMISSION_DENIED); - EXPECT_EQ(volueDataCount, 0); -} -HWTEST_F(AudioServerUnitTest, ResetRecordConfig_001, TestSize.Level1) -{ - EXPECT_NE(nullptr, audioServer); - - AudioProcessConfig config; - config.capturerInfo.sourceType = SourceType::SOURCE_TYPE_LIVE; - - audioServer->ResetRecordConfig(config); - EXPECT_EQ(config.capturerInfo.sourceType, SOURCE_TYPE_LIVE); -} -#ifdef TEMP_DISABLE -/** - * @tc.name : Test SetRenderWhitelist API - * @tc.type : FUNC - * @tc.number: AudioServerSetRenderWhitelist_001 - * @tc.desc : Test SetRenderWhitelist interface. - */ -HWTEST_F(AudioServerUnitTest, AudioServerSetRenderWhitelist_001, TestSize.Level2) -{ - EXPECT_NE(nullptr, audioServer); - - std::vector list; - list.push_back("com.test"); - int32_t ret = audioServer->SetRenderWhitelist(list); - EXPECT_EQ(SUCCESS, ret); -} -#endif + int32_t uid = incomingInterrupt.uid; + int32_t currentUid = currentInterrupt.uid; + std::string bundleName = GetRealBundleName(static_cast(uid)); + std::string currentBundleName = GetBundleName2(static_cast(currentUid)); -services/audio_service/test/unittest/audio_service_unit_test.cpp -HWTEST(AudioServiceUnitTest, SaveRenderWhitelist_001, TestSize.Level1) -{ - std::vector list = { "test1", "test2", "test3" }; - AudioService::GetInstance()->SaveRenderWhitelist(list); - EXPECT_EQ(AudioService::GetInstance()->renderWhitelist_.size(), 3); + "existStreamType:%{public}d incomingStreamType:%{public}d" + "currentPid:%{public}d incomingPid:%{public}d currentBundleName: %{public}s", + focusEntry.hintType, focusEntry.actionOn, existSourceType, incomingSourceType, + existStreamType, incomingStreamType, currentPid, incomingPid, currentBundleName.c_str()); + + + + + UpdateMicFocusByUid(uid, existSourceType, incomingSourceType, currentBundleName, focusEntry); + + + +void AudioInterruptService::UpdateMicFocusStrategy(SourceType existSourceType, + SourceType incomingSourceType, const std::string ¤tBundleName, + const std::string &incomingBundleName, AudioFocusEntry &focusEntry) + + bool isCurrentBundleNameExist = false; + bool isIncomingBundleNameExist = false; + if (queryBundleNameListCallback_ != nullptr) { + queryBundleNameListCallback_->OnQueryBundleNameIsInList(currentBundleName, "audio_micfocus_list", + isCurrentBundleNameExist); + AUDIO_INFO_LOG("isCurrentBundleNameExist: %{public}d", isCurrentBundleNameExist); + } + if (queryBundleNameListCallback_ != nullptr) { + queryBundleNameListCallback_->OnQueryBundleNameIsInList(incomingBundleName, "audio_micfocus_list", + isIncomingBundleNameExist); + AUDIO_INFO_LOG("isIncomingBundleNameExist: %{public}d", isIncomingBundleNameExist); + } + AUDIO_INFO_LOG("%{public}s update mic focus strategy, focusEntry.hintType: %{public}d," + " focusEntry.actionOn: %{public}d" + " existSourceType: %{public}d incomingSourceType: %{public}d" + " isCurrentBundleNameExist: %{public}d isIncomingBundleNameExist: %{public}d" , + currentBundleName.c_str(), focusEntry.hintType, focusEntry.actionOn, existSourceType, incomingSourceType, + isCurrentBundleNameExist, isIncomingBundleNameExist); + if (existSourceType == SOURCE_TYPE_MIC && IsMicSource(incomingSourceType) && isCurrentBundleNameExist) { + focusEntry.hintType = INTERRUPT_HINT_PAUSE; + focusEntry.actionOn = CURRENT; + AUDIO_INFO_LOG("current %{public}s update mic focus strategy", currentBundleName.c_str()); + return; + } + if (IsMicSource(existSourceType) && incomingSourceType == SOURCE_TYPE_MIC && isIncomingBundleNameExist) { + focusEntry.hintType = INTERRUPT_HINT_PAUSE; + focusEntry.actionOn = INCOMING; + AUDIO_INFO_LOG("incoming %{public}s update mic focus strategy", incomingBundleName.c_str()); + return; + } } + + + + + CHECK_AND_RETURN_RET_LOG(processConfig_.capturerInfo.sourceType == SOURCE_TYPE_MIC + + + config.capturerInfo.sourceType == SOURCE_TYPE_MIC) + + + CHECK_AND_RETURN_RET_LOG(processConfig_.capturerInfo.sourceType == SOURCE_TYPE_MIC + -- Gitee From 813442ff0bbd437ac223911fe0cd63aa987d2ed1 Mon Sep 17 00:00:00 2001 From: weiyuantian Date: Wed, 27 Aug 2025 08:08:55 +0000 Subject: [PATCH 17/20] update services/audio_service/test/unittest/audio_0820_DT_test. Signed-off-by: weiyuantian --- .../test/unittest/audio_0820_DT_test | 20 ++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/services/audio_service/test/unittest/audio_0820_DT_test b/services/audio_service/test/unittest/audio_0820_DT_test index 03d1e17791..3da2e0ccfb 100644 --- a/services/audio_service/test/unittest/audio_0820_DT_test +++ b/services/audio_service/test/unittest/audio_0820_DT_test @@ -5,7 +5,9 @@ void UpdateMicFocusStrategy(SourceType existSourceType, SourceType incomingSourceType, const std::string ¤tBundleName, const std::string &incomingBundleName, AudioFocusEntry &focusEntry); - + void UpdateMicFocusByUid(const int32_t uid, const SourceType &existSourceType, + const SourceType &incomingSourceType, const std::string ¤tBundleName, + const std::string &bundleName, AudioFocusEntry &focusEntry); std::string AudioInterruptService::GetBundleName2(uint32_t uid) @@ -38,6 +40,22 @@ std::string AudioInterruptService::GetBundleName2(uint32_t uid) +void AudioInterruptService::UpdateMicFocusByUid(const int32_t uid, const SourceType &existSourceType, + const SourceType &incomingSourceType, const std::string ¤tBundleName, + const std::string &bundleName, AudioFocusEntry &focusEntry) +{ + if (uid == static_cast(AUDIO_ID)) { + AUDIO_INFO_LOG("lake App: %{public}s Access",std::to_string(uid).c_str()); + UpdateMicFocusStrategy(existSourceType, incomingSourceType, std::to_string(uid), bundleName, focusEntry); + } else { + UpdateMicFocusStrategy(existSourceType, incomingSourceType, currentBundleName, bundleName, focusEntry); + } +} + + + + + void AudioInterruptService::UpdateMicFocusStrategy(SourceType existSourceType, SourceType incomingSourceType, const std::string ¤tBundleName, const std::string &incomingBundleName, AudioFocusEntry &focusEntry) -- Gitee From 31cf778a3ec55d387abf131aa3167e7d199756c0 Mon Sep 17 00:00:00 2001 From: weiyuantian Date: Thu, 28 Aug 2025 01:12:27 +0000 Subject: [PATCH 18/20] update services/audio_service/test/unittest/audio_0820_DT_test. Signed-off-by: weiyuantian --- .../test/unittest/audio_0820_DT_test | 101 ++++++------------ 1 file changed, 35 insertions(+), 66 deletions(-) diff --git a/services/audio_service/test/unittest/audio_0820_DT_test b/services/audio_service/test/unittest/audio_0820_DT_test index 3da2e0ccfb..bd9cd620ce 100644 --- a/services/audio_service/test/unittest/audio_0820_DT_test +++ b/services/audio_service/test/unittest/audio_0820_DT_test @@ -1,105 +1,74 @@ - std::string GetRealBundleName(uint32_t uid); - std::string GetBundleName2(uint32_t uid); +std::string GetCurrentBundleName(uint32_t uid); - void UpdateMicFocusStrategy(SourceType existSourceType, SourceType incomingSourceType, + void UpdateMicFocusStrategy(SourceType existSourceType, SourceType incomingSourceType, + const AudioStreamType &existStreamType, const AudioStreamType &incomingStreamType, const std::string ¤tBundleName, const std::string &incomingBundleName, AudioFocusEntry &focusEntry); - void UpdateMicFocusByUid(const int32_t uid, const SourceType &existSourceType, const SourceType &incomingSourceType, const std::string ¤tBundleName, + const AudioStreamType &existStreamType, const AudioStreamType &incomingStreamType, const std::string &bundleName, AudioFocusEntry &focusEntry); -std::string AudioInterruptService::GetBundleName2(uint32_t uid) -{ - CHECK_AND_RETURN_RET_LOG(policyServer_ != nullptr, "", "policyServer nullptr"); - auto info = AudioBundleManager::GetBundleInfoFromUid(uid); - return info.name; -} - - - - int32_t uid = incomingInterrupt.uid; - int32_t currentUid = currentInterrupt.uid; - - - std::string bundleName = GetRealBundleName(static_cast(uid)); - std::string currentBundleName = GetBundleName2(static_cast(currentUid)); - - - "existStreamType:%{public}d incomingStreamType:%{public}d" - "currentPid:%{public}d incomingPid:%{public}d currentBundleName: %{public}s", - focusEntry.hintType, focusEntry.actionOn, existSourceType, incomingSourceType, - existStreamType, incomingStreamType, currentPid, incomingPid, currentBundleName.c_str()); - - - UpdateMicFocusByUid(uid, existSourceType, incomingSourceType, currentBundleName, focusEntry); - - - -void AudioInterruptService::UpdateMicFocusByUid(const int32_t uid, const SourceType &existSourceType, - const SourceType &incomingSourceType, const std::string ¤tBundleName, - const std::string &bundleName, AudioFocusEntry &focusEntry) +void AudioInterruptService::UpdateMicFocusStrategy(SourceType existSourceType, SourceType incomingSourceType, + const AudioStreamType &existStreamType, const AudioStreamType &incomingStreamType, + const std::string ¤tBundleName, const std::string &incomingBundleName, AudioFocusEntry &focusEntry) { - if (uid == static_cast(AUDIO_ID)) { - AUDIO_INFO_LOG("lake App: %{public}s Access",std::to_string(uid).c_str()); - UpdateMicFocusStrategy(existSourceType, incomingSourceType, std::to_string(uid), bundleName, focusEntry); - } else { - UpdateMicFocusStrategy(existSourceType, incomingSourceType, currentBundleName, bundleName, focusEntry); + if (queryBundleNameListCallback_ == nullptr) { + + AUDIO_INFO_LOG("Not a recording stream access"); + return; } -} - - - - - -void AudioInterruptService::UpdateMicFocusStrategy(SourceType existSourceType, - SourceType incomingSourceType, const std::string ¤tBundleName, - const std::string &incomingBundleName, AudioFocusEntry &focusEntry) - bool isCurrentBundleNameExist = false; bool isIncomingBundleNameExist = false; - if (queryBundleNameListCallback_ != nullptr) { - queryBundleNameListCallback_->OnQueryBundleNameIsInList(currentBundleName, "audio_micfocus_list", - isCurrentBundleNameExist); - AUDIO_INFO_LOG("isCurrentBundleNameExist: %{public}d", isCurrentBundleNameExist); - } - if (queryBundleNameListCallback_ != nullptr) { - queryBundleNameListCallback_->OnQueryBundleNameIsInList(incomingBundleName, "audio_micfocus_list", - isIncomingBundleNameExist); - AUDIO_INFO_LOG("isIncomingBundleNameExist: %{public}d", isIncomingBundleNameExist); - } + queryBundleNameListCallback_->OnQueryBundleNameIsInList(currentBundleName, "audio_micfocus_list", + isCurrentBundleNameExist); + queryBundleNameListCallback_->OnQueryBundleNameIsInList(incomingBundleName, "audio_micfocus_list", + isIncomingBundleNameExist); AUDIO_INFO_LOG("%{public}s update mic focus strategy, focusEntry.hintType: %{public}d," " focusEntry.actionOn: %{public}d" " existSourceType: %{public}d incomingSourceType: %{public}d" - " isCurrentBundleNameExist: %{public}d isIncomingBundleNameExist: %{public}d" , + " existStreamType: %{public}d incomingStreamType: %{public}d" + " isCurrentBundleNameExist: %{public}d isIncomingBundleNameExist: %{public}d", currentBundleName.c_str(), focusEntry.hintType, focusEntry.actionOn, existSourceType, incomingSourceType, + existStreamType, incomingStreamType, isCurrentBundleNameExist, isIncomingBundleNameExist); - if (existSourceType == SOURCE_TYPE_MIC && IsMicSource(incomingSourceType) && isCurrentBundleNameExist) { + if (existSourceType == SOURCE_TYPE_MIC && + (IsMicSource(incomingSourceType) || incomingStreamType == STREAM_VOICE_CALL) && + isCurrentBundleNameExist) { focusEntry.hintType = INTERRUPT_HINT_PAUSE; focusEntry.actionOn = CURRENT; AUDIO_INFO_LOG("current %{public}s update mic focus strategy", currentBundleName.c_str()); return; } - if (IsMicSource(existSourceType) && incomingSourceType == SOURCE_TYPE_MIC && isIncomingBundleNameExist) { + if ((IsMicSource(existSourceType) || existStreamType == STREAM_VOICE_CALL) && + incomingSourceType == SOURCE_TYPE_MIC && + isIncomingBundleNameExist) { focusEntry.hintType = INTERRUPT_HINT_PAUSE; focusEntry.actionOn = INCOMING; AUDIO_INFO_LOG("incoming %{public}s update mic focus strategy", incomingBundleName.c_str()); return; } } - - CHECK_AND_RETURN_RET_LOG(processConfig_.capturerInfo.sourceType == SOURCE_TYPE_MIC - config.capturerInfo.sourceType == SOURCE_TYPE_MIC) - CHECK_AND_RETURN_RET_LOG(processConfig_.capturerInfo.sourceType == SOURCE_TYPE_MIC + + + + + + + + + + + -- Gitee From 54f42d7eaadb4365eb5c747ac81dc2d58a7b0f4e Mon Sep 17 00:00:00 2001 From: weiyuantian Date: Thu, 28 Aug 2025 01:54:05 +0000 Subject: [PATCH 19/20] update services/audio_service/test/unittest/audio_0820_DT_test. Signed-off-by: weiyuantian --- .../test/unittest/audio_0820_DT_test | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/services/audio_service/test/unittest/audio_0820_DT_test b/services/audio_service/test/unittest/audio_0820_DT_test index bd9cd620ce..bace2db142 100644 --- a/services/audio_service/test/unittest/audio_0820_DT_test +++ b/services/audio_service/test/unittest/audio_0820_DT_test @@ -61,7 +61,23 @@ void AudioInterruptService::UpdateMicFocusStrategy(SourceType existSourceType, S - + AudioStreamType existStreamType = STREAM_ALARM; + AudioStreamType incomingStreamType = STREAM_ALARM; + string bundleName = "test"; + string currentBundleName = "currentTest"; + AudioFocusEntry focusEntry; + audioInterruptService->UpdateMicFocusStrategy(existSourceType, incomingSourceType, existStreamType, + incomingStreamType, currentBundleName, bundleName, focusEntry); + incomingSourceType = SOURCE_TYPE_VOICE_CALL; + audioInterruptService->UpdateMicFocusStrategy(existSourceType, incomingSourceType, existStreamType, + incomingStreamType, currentBundleName, bundleName, focusEntry); + existSourceType = SOURCE_TYPE_MIC; + audioInterruptService->UpdateMicFocusStrategy(existSourceType, incomingSourceType, existStreamType, + incomingStreamType, currentBundleName, bundleName, focusEntry); + sptr listener(new IStandardAudioPolicyManagerListenerStub()); + audioInterruptService->queryBundleNameListCallback_ = listener; + audioInterruptService->UpdateMicFocusStrategy(existSourceType, incomingSourceType, existStreamType, + incomingStreamType, currentBundleName, bundleName, focusEntry); -- Gitee From bf4ff3763048e752463093c1902236516b37c8cd Mon Sep 17 00:00:00 2001 From: weiyuantian Date: Thu, 28 Aug 2025 03:04:14 +0000 Subject: [PATCH 20/20] update services/audio_service/test/unittest/audio_0820_DT_test. Signed-off-by: weiyuantian --- .../test/unittest/audio_0820_DT_test | 90 ++----------------- 1 file changed, 6 insertions(+), 84 deletions(-) diff --git a/services/audio_service/test/unittest/audio_0820_DT_test b/services/audio_service/test/unittest/audio_0820_DT_test index bace2db142..5b0e349a66 100644 --- a/services/audio_service/test/unittest/audio_0820_DT_test +++ b/services/audio_service/test/unittest/audio_0820_DT_test @@ -1,90 +1,12 @@ -std::string GetCurrentBundleName(uint32_t uid); - - - void UpdateMicFocusStrategy(SourceType existSourceType, SourceType incomingSourceType, - const AudioStreamType &existStreamType, const AudioStreamType &incomingStreamType, - const std::string ¤tBundleName, const std::string &incomingBundleName, AudioFocusEntry &focusEntry); - void UpdateMicFocusByUid(const int32_t uid, const SourceType &existSourceType, - const SourceType &incomingSourceType, const std::string ¤tBundleName, - const AudioStreamType &existStreamType, const AudioStreamType &incomingStreamType, - const std::string &bundleName, AudioFocusEntry &focusEntry); - - - - - -void AudioInterruptService::UpdateMicFocusStrategy(SourceType existSourceType, SourceType incomingSourceType, - const AudioStreamType &existStreamType, const AudioStreamType &incomingStreamType, - const std::string ¤tBundleName, const std::string &incomingBundleName, AudioFocusEntry &focusEntry) -{ - if (queryBundleNameListCallback_ == nullptr) { - - AUDIO_INFO_LOG("Not a recording stream access"); - return; - } - bool isCurrentBundleNameExist = false; - bool isIncomingBundleNameExist = false; - queryBundleNameListCallback_->OnQueryBundleNameIsInList(currentBundleName, "audio_micfocus_list", - isCurrentBundleNameExist); - queryBundleNameListCallback_->OnQueryBundleNameIsInList(incomingBundleName, "audio_micfocus_list", - isIncomingBundleNameExist); - AUDIO_INFO_LOG("%{public}s update mic focus strategy, focusEntry.hintType: %{public}d," - " focusEntry.actionOn: %{public}d" - " existSourceType: %{public}d incomingSourceType: %{public}d" - " existStreamType: %{public}d incomingStreamType: %{public}d" - " isCurrentBundleNameExist: %{public}d isIncomingBundleNameExist: %{public}d", - currentBundleName.c_str(), focusEntry.hintType, focusEntry.actionOn, existSourceType, incomingSourceType, - existStreamType, incomingStreamType, - isCurrentBundleNameExist, isIncomingBundleNameExist); - if (existSourceType == SOURCE_TYPE_MIC && - (IsMicSource(incomingSourceType) || incomingStreamType == STREAM_VOICE_CALL) && - isCurrentBundleNameExist) { - focusEntry.hintType = INTERRUPT_HINT_PAUSE; - focusEntry.actionOn = CURRENT; - AUDIO_INFO_LOG("current %{public}s update mic focus strategy", currentBundleName.c_str()); - return; - } - if ((IsMicSource(existSourceType) || existStreamType == STREAM_VOICE_CALL) && - incomingSourceType == SOURCE_TYPE_MIC && - isIncomingBundleNameExist) { - focusEntry.hintType = INTERRUPT_HINT_PAUSE; - focusEntry.actionOn = INCOMING; - AUDIO_INFO_LOG("incoming %{public}s update mic focus strategy", incomingBundleName.c_str()); - return; - } -} - - - - - - - - - AudioStreamType existStreamType = STREAM_ALARM; - AudioStreamType incomingStreamType = STREAM_ALARM; - string bundleName = "test"; - string currentBundleName = "currentTest"; - AudioFocusEntry focusEntry; - audioInterruptService->UpdateMicFocusStrategy(existSourceType, incomingSourceType, existStreamType, - incomingStreamType, currentBundleName, bundleName, focusEntry); - incomingSourceType = SOURCE_TYPE_VOICE_CALL; - audioInterruptService->UpdateMicFocusStrategy(existSourceType, incomingSourceType, existStreamType, - incomingStreamType, currentBundleName, bundleName, focusEntry); - existSourceType = SOURCE_TYPE_MIC; - audioInterruptService->UpdateMicFocusStrategy(existSourceType, incomingSourceType, existStreamType, - incomingStreamType, currentBundleName, bundleName, focusEntry); - sptr listener(new IStandardAudioPolicyManagerListenerStub()); - audioInterruptService->queryBundleNameListCallback_ = listener; - audioInterruptService->UpdateMicFocusStrategy(existSourceType, incomingSourceType, existStreamType, - incomingStreamType, currentBundleName, bundleName, focusEntry); - - - - + UpdateMicFocusStrategy(existSourceType, incomingSourceType, existStreamType, + incomingStreamType, std::to_string(uid), bundleName, focusEntry); + } else { + UpdateMicFocusStrategy(existSourceType, incomingSourceType, existStreamType, + incomingStreamType, currentBundleName, bundleName, focusEntry); + } \ No newline at end of file -- Gitee