From f6464f35615f550e60939fb2eec9baf097b82da2 Mon Sep 17 00:00:00 2001 From: Jvgang Date: Tue, 19 Aug 2025 19:17:15 +0000 Subject: [PATCH 1/7] Add UT Signed-off-by: Jvgang --- .../server/src/audio_service.cpp | 4 +- .../test/unittest/audio_service_unit_test.cpp | 50 ++++++++++++++++++- 2 files changed, 51 insertions(+), 3 deletions(-) diff --git a/services/audio_service/server/src/audio_service.cpp b/services/audio_service/server/src/audio_service.cpp index a349968867..619132a17e 100644 --- a/services/audio_service/server/src/audio_service.cpp +++ b/services/audio_service/server/src/audio_service.cpp @@ -420,7 +420,7 @@ bool AudioService::RemovePauseInterruptEventMap(const uint32_t sessionId) if (iter == pauseInterruptEventMap_.end()) { return false; } - resumeInterruptEventMap_.erase(sessionId); + pauseInterruptEventMap_.erase(sessionId); return true; } @@ -504,7 +504,7 @@ void AudioService::RemoveBackgroundCaptureMap(uint32_t sessionId) std::lock_guard lock(backgroundCaptureMutex_); auto iter = backgroundCaptureMap_.find(sessionId); if (iter != backgroundCaptureMap_.end()) { - audioSwitchStreamMap_.erase(sessionId); + backgroundCaptureMap_.erase(sessionId); } } diff --git a/services/audio_service/test/unittest/audio_service_unit_test.cpp b/services/audio_service/test/unittest/audio_service_unit_test.cpp index e94e8dd5fe..f15ab64c1e 100644 --- a/services/audio_service/test/unittest/audio_service_unit_test.cpp +++ b/services/audio_service/test/unittest/audio_service_unit_test.cpp @@ -3204,5 +3204,53 @@ HWTEST(AudioServiceUnitTest, ConfigCoreServiceProvider_003, TestSize.Level1) EXPECT_EQ(ret, ERR_INVALID_OPERATION); } +/** + * @tc.name : Test SendInterruptEventToAudioService API + * @tc.type : FUNC + * @tc.number: SendInterruptEventToAudioService_001, + * @tc.desc : Test SendInterruptEventToAudioService interface. + */ +HWTEST(AudioServiceUnitTest, SendInterruptEventToAudioService_001, TestSize.Level1) +{ + InterruptEventInternal interruptEvent = { }; + interruptEvent.hintType = INTERRUPT_HINT_RESUME; + int32_t sessionId = 13579; + AudioService::GetInstance()->SendInterruptEventToAudioService(sessionId, interruptEvent); + std::lock_guard lock(resumeInterruptEventMutex_); + auto iter = resumeInterruptEventMap_.find(sessionId); + EXPECT_NE(iter != resumeInterruptEventMap_.end(), true); + resumeInterruptEventMap_.erase[sessionId]; +} +/** + * @tc.name : Test SendInterruptEventToAudioService API + * @tc.type : FUNC + * @tc.number: SendInterruptEventToAudioService_002, + * @tc.desc : Test SendInterruptEventToAudioService interface. + */ +HWTEST(AudioServiceUnitTest, SendInterruptEventToAudioService_002, TestSize.Level1) +{ + InterruptEventInternal interruptEvent = { }; + interruptEvent.hintType = INTERRUPT_HINT_PAUSE; + int32_t sessionId = 24678; + AudioService::GetInstance()->SendInterruptEventToAudioService(sessionId, interruptEvent); + std::lock_guard lock(pasueInterruptEventMutex_); + auto iter = pauseInterruptEventMap_.find(sessionId); + EXPECT_NE(iter != pauseInterruptEventMap_.end(), true); + resumeInterruptEventMap_.erase[sessionId]; +} + } // namespace AudioStandard -} // namespace OHOS \ No newline at end of file +} // namespace OHOS + +void AudioService::SendInterruptEventToAudioService(uint32_t sessionId, + InterruptEventInternal interruptEvent) +{ + interruptEvent.eventTimestamp = ClockTime::GetCurNano(); + AUDIO_INFO_LOG("Recive InterruptEvent:[%{public}d] from InterruptService", interruptEvent.hintType); + if (interruptEvent.hintType == INTERRUPT_HINT_RESUME) { + UpdateResumeInterruptEventMap(sessionId, interruptEvent); + } + if (interruptEvent.hintType == INTERRUPT_HINT_PAUSE) { + UpdatePauseInterruptEventMap(sessionId, interruptEvent); + } +} \ No newline at end of file -- Gitee From 9da86b94d3d8248cd681742075aaac32cd91eb6c Mon Sep 17 00:00:00 2001 From: Jvgang Date: Wed, 20 Aug 2025 01:42:41 +0000 Subject: [PATCH 2/7] Add UT Signed-off-by: Jvgang --- .../test/unittest/audio_service_unit_test.cpp | 28 +++++++++++++++++-- 1 file changed, 26 insertions(+), 2 deletions(-) diff --git a/services/audio_service/test/unittest/audio_service_unit_test.cpp b/services/audio_service/test/unittest/audio_service_unit_test.cpp index f15ab64c1e..6304550ece 100644 --- a/services/audio_service/test/unittest/audio_service_unit_test.cpp +++ b/services/audio_service/test/unittest/audio_service_unit_test.cpp @@ -3218,7 +3218,7 @@ HWTEST(AudioServiceUnitTest, SendInterruptEventToAudioService_001, TestSize.Leve AudioService::GetInstance()->SendInterruptEventToAudioService(sessionId, interruptEvent); std::lock_guard lock(resumeInterruptEventMutex_); auto iter = resumeInterruptEventMap_.find(sessionId); - EXPECT_NE(iter != resumeInterruptEventMap_.end(), true); + EXPECT_EQ(iter != resumeInterruptEventMap_.end(), true); resumeInterruptEventMap_.erase[sessionId]; } /** @@ -3235,10 +3235,34 @@ HWTEST(AudioServiceUnitTest, SendInterruptEventToAudioService_002, TestSize.Leve AudioService::GetInstance()->SendInterruptEventToAudioService(sessionId, interruptEvent); std::lock_guard lock(pasueInterruptEventMutex_); auto iter = pauseInterruptEventMap_.find(sessionId); - EXPECT_NE(iter != pauseInterruptEventMap_.end(), true); + EXPECT_EQ(iter != pauseInterruptEventMap_.end(), true); resumeInterruptEventMap_.erase[sessionId]; } +/** + * @tc.name : Test resumeInterruptEventMap_ API + * @tc.type : FUNC + * @tc.number: resumeInterruptEventMap_001, + * @tc.desc : Test resumeInterruptEventMap_001 interface. + */ +HWTEST(AudioServiceUnitTest, resumeInterruptEventMap_001, TestSize.Level1) +{ + InterruptEventInternal interruptEvent = { }; + interruptEvent.hintType = INTERRUPT_HINT_RESUME; + int32_t sessionId = 123456; + + std::lock_guard lock(pasueInterruptEventMutex_); + auto iter = resumeInterruptEventMap_.find(sessionId); + EXPECT_EQ(iter == resumeInterruptEventMap_.end(), true); + lock.unlock(); + + AudioService::GetInstance()->UpdateResumeInterruptEventMap(sessionId, interruptEvent); + std::lock_guard lock(pasueInterruptEventMutex_); + auto iter = resumeInterruptEventMap_.find(sessionId); + EXPECT_NE(iter != pauseInterruptEventMap_.end(), true); + lock.unlock(); +} + } // namespace AudioStandard } // namespace OHOS -- Gitee From 043d4044ee7cf1ddf5ce5576eb22a049ec723362 Mon Sep 17 00:00:00 2001 From: Jvgang Date: Wed, 20 Aug 2025 01:57:14 +0000 Subject: [PATCH 3/7] Add UT Signed-off-by: Jvgang --- .../test/unittest/audio_service_unit_test.cpp | 44 +++++++++++-------- 1 file changed, 26 insertions(+), 18 deletions(-) diff --git a/services/audio_service/test/unittest/audio_service_unit_test.cpp b/services/audio_service/test/unittest/audio_service_unit_test.cpp index 6304550ece..b09847edb1 100644 --- a/services/audio_service/test/unittest/audio_service_unit_test.cpp +++ b/services/audio_service/test/unittest/audio_service_unit_test.cpp @@ -3251,30 +3251,38 @@ HWTEST(AudioServiceUnitTest, resumeInterruptEventMap_001, TestSize.Level1) interruptEvent.hintType = INTERRUPT_HINT_RESUME; int32_t sessionId = 123456; - std::lock_guard lock(pasueInterruptEventMutex_); + std::lock_guard lock(resumeInterruptEventMutex_); auto iter = resumeInterruptEventMap_.find(sessionId); EXPECT_EQ(iter == resumeInterruptEventMap_.end(), true); lock.unlock(); - + // test Remove when sessionId not in map AudioService::GetInstance()->UpdateResumeInterruptEventMap(sessionId, interruptEvent); - std::lock_guard lock(pasueInterruptEventMutex_); + std::lock_guard lock1(resumeInterruptEventMutex_); auto iter = resumeInterruptEventMap_.find(sessionId); - EXPECT_NE(iter != pauseInterruptEventMap_.end(), true); - lock.unlock(); + EXPECT_EQ(iter != resumeInterruptEventMap_.end(), true); + lock1.unlock(); + // test Update when sessionId in map + interruptEvent.hintType = INTERRUPT_HINT_MUTE; + AudioService::GetInstance()->UpdateResumeInterruptEventMap(sessionId, interruptEvent); + std::lock_guard lock2(resumeInterruptEventMutex_); + auto iter = resumeInterruptEventMap_.find(sessionId); + EXPECT_EQ(iter != resumeInterruptEventMap_.end(), true); + EXPECT_EQ(iter->second.hintType, INTERRUPT_HINT_MUTE); + lock2.unlock(); + + // test Remove when sessionId in map + AudioService::GetInstance()->RemoveResumeInterruptEventMap(sessionId); + std::lock_guard lock3(resumeInterruptEventMutex_); + auto iter = resumeInterruptEventMap_.find(sessionId); + EXPECT_EQ(iter == resumeInterruptEventMap_.end(), true); + lock3.unlock(); + // test Remove when sessionId not in map + AudioService::GetInstance()->RemoveResumeInterruptEventMap(sessionId); + std::lock_guard lock4(resumeInterruptEventMutex_); + auto iter = resumeInterruptEventMap_.find(sessionId); + EXPECT_EQ(iter == resumeInterruptEventMap_.end(), false); + lock4.unlock(); } } // namespace AudioStandard } // namespace OHOS - -void AudioService::SendInterruptEventToAudioService(uint32_t sessionId, - InterruptEventInternal interruptEvent) -{ - interruptEvent.eventTimestamp = ClockTime::GetCurNano(); - AUDIO_INFO_LOG("Recive InterruptEvent:[%{public}d] from InterruptService", interruptEvent.hintType); - if (interruptEvent.hintType == INTERRUPT_HINT_RESUME) { - UpdateResumeInterruptEventMap(sessionId, interruptEvent); - } - if (interruptEvent.hintType == INTERRUPT_HINT_PAUSE) { - UpdatePauseInterruptEventMap(sessionId, interruptEvent); - } -} \ No newline at end of file -- Gitee From ca182f96c9de3b9261e3398cfe8de189c0ab8c01 Mon Sep 17 00:00:00 2001 From: Jvgang Date: Wed, 20 Aug 2025 01:58:12 +0000 Subject: [PATCH 4/7] Add UT Signed-off-by: Jvgang --- .../audio_service/test/unittest/audio_service_unit_test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/services/audio_service/test/unittest/audio_service_unit_test.cpp b/services/audio_service/test/unittest/audio_service_unit_test.cpp index b09847edb1..62c9bc2126 100644 --- a/services/audio_service/test/unittest/audio_service_unit_test.cpp +++ b/services/audio_service/test/unittest/audio_service_unit_test.cpp @@ -3255,7 +3255,7 @@ HWTEST(AudioServiceUnitTest, resumeInterruptEventMap_001, TestSize.Level1) auto iter = resumeInterruptEventMap_.find(sessionId); EXPECT_EQ(iter == resumeInterruptEventMap_.end(), true); lock.unlock(); - // test Remove when sessionId not in map + // test Update when sessionId not in map AudioService::GetInstance()->UpdateResumeInterruptEventMap(sessionId, interruptEvent); std::lock_guard lock1(resumeInterruptEventMutex_); auto iter = resumeInterruptEventMap_.find(sessionId); -- Gitee From aef8c99fa39b79eae37956ad2922dc245ae7bb67 Mon Sep 17 00:00:00 2001 From: Jvgang Date: Wed, 20 Aug 2025 07:19:05 +0000 Subject: [PATCH 5/7] Add UT Signed-off-by: Jvgang --- .../test/unittest/audio_service_unit_test.cpp | 107 +++++++++++++----- 1 file changed, 76 insertions(+), 31 deletions(-) diff --git a/services/audio_service/test/unittest/audio_service_unit_test.cpp b/services/audio_service/test/unittest/audio_service_unit_test.cpp index 62c9bc2126..c410eaaaa0 100644 --- a/services/audio_service/test/unittest/audio_service_unit_test.cpp +++ b/services/audio_service/test/unittest/audio_service_unit_test.cpp @@ -3212,14 +3212,17 @@ HWTEST(AudioServiceUnitTest, ConfigCoreServiceProvider_003, TestSize.Level1) */ HWTEST(AudioServiceUnitTest, SendInterruptEventToAudioService_001, TestSize.Level1) { + AudioService *audioService = AudioService::GetInstance(); + EXPECT_NE(audioService, nullptr); + InterruptEventInternal interruptEvent = { }; interruptEvent.hintType = INTERRUPT_HINT_RESUME; int32_t sessionId = 13579; - AudioService::GetInstance()->SendInterruptEventToAudioService(sessionId, interruptEvent); - std::lock_guard lock(resumeInterruptEventMutex_); - auto iter = resumeInterruptEventMap_.find(sessionId); - EXPECT_EQ(iter != resumeInterruptEventMap_.end(), true); - resumeInterruptEventMap_.erase[sessionId]; + audioService->SendInterruptEventToAudioService(sessionId, interruptEvent); + std::lock_guard lock(audioService->resumeInterruptEventMutex_); + auto iter = audioService->resumeInterruptEventMap_.find(sessionId); + EXPECT_EQ(iter != audioService->resumeInterruptEventMap_.end(), true); + audioService->resumeInterruptEventMap_.erase[sessionId]; } /** * @tc.name : Test SendInterruptEventToAudioService API @@ -3229,14 +3232,17 @@ HWTEST(AudioServiceUnitTest, SendInterruptEventToAudioService_001, TestSize.Leve */ HWTEST(AudioServiceUnitTest, SendInterruptEventToAudioService_002, TestSize.Level1) { + AudioService *audioService = AudioService::GetInstance(); + EXPECT_NE(audioService, nullptr); + InterruptEventInternal interruptEvent = { }; interruptEvent.hintType = INTERRUPT_HINT_PAUSE; int32_t sessionId = 24678; - AudioService::GetInstance()->SendInterruptEventToAudioService(sessionId, interruptEvent); - std::lock_guard lock(pasueInterruptEventMutex_); - auto iter = pauseInterruptEventMap_.find(sessionId); - EXPECT_EQ(iter != pauseInterruptEventMap_.end(), true); - resumeInterruptEventMap_.erase[sessionId]; + audioService->SendInterruptEventToAudioService(sessionId, interruptEvent); + std::lock_guard lock(audioService->pasueInterruptEventMutex_); + auto iter = audioService->pauseInterruptEventMap_.find(sessionId); + EXPECT_EQ(iter != audioService->pauseInterruptEventMap_.end(), true); + audioService->resumeInterruptEventMap_.erase[sessionId]; } /** @@ -3247,41 +3253,80 @@ HWTEST(AudioServiceUnitTest, SendInterruptEventToAudioService_002, TestSize.Leve */ HWTEST(AudioServiceUnitTest, resumeInterruptEventMap_001, TestSize.Level1) { + AudioService *audioService = AudioService::GetInstance(); + EXPECT_NE(audioService, nullptr); + InterruptEventInternal interruptEvent = { }; interruptEvent.hintType = INTERRUPT_HINT_RESUME; int32_t sessionId = 123456; - std::lock_guard lock(resumeInterruptEventMutex_); - auto iter = resumeInterruptEventMap_.find(sessionId); - EXPECT_EQ(iter == resumeInterruptEventMap_.end(), true); + std::lock_guard lock(audioService->resumeInterruptEventMutex_); + auto iter = audioService->resumeInterruptEventMap_.find(sessionId); + EXPECT_EQ(iter == audioService->resumeInterruptEventMap_.end(), true); + lock.unlock(); + // test Update when sessionId not in map + audioService->UpdateResumeInterruptEventMap(sessionId, interruptEvent); + std::lock_guard lock1(audioService->resumeInterruptEventMutex_); + auto iter = audioService->resumeInterruptEventMap_.find(sessionId); + EXPECT_EQ(iter != audioService->resumeInterruptEventMap_.end(), true); + lock1.unlock(); + // test Update when sessionId in map + interruptEvent.hintType = INTERRUPT_HINT_MUTE; + audioService->UpdateResumeInterruptEventMap(sessionId, interruptEvent); + std::lock_guard lock2(audioService->resumeInterruptEventMutex_); + auto iter = audioService->resumeInterruptEventMap_.find(sessionId); + EXPECT_EQ(iter != audioService->resumeInterruptEventMap_.end(), true); + EXPECT_EQ(iter->second.hintType, INTERRUPT_HINT_MUTE); + lock2.unlock(); + + // test Remove when sessionId in map + bool res = audioService->RemoveResumeInterruptEventMap(sessionId); + EXPECT_EQ(res, true); + // test Remove when sessionId not in map + res = audioService->RemoveResumeInterruptEventMap(sessionId); + EXPECT_EQ(res, false); +} + +/** + * @tc.name : Test pauseInterruptEventMap_ API + * @tc.type : FUNC + * @tc.number: pauseInterruptEventMap_001, + * @tc.desc : Test pauseInterruptEventMap_001 interface. + */ +HWTEST(AudioServiceUnitTest, pauseInterruptEventMap_001, TestSize.Level1) +{ + AudioService *audioService = AudioService::GetInstance(); + EXPECT_NE(audioService, nullptr); + + InterruptEventInternal interruptEvent = { }; + interruptEvent.hintType = INTERRUPT_HINT_PAUSE; + int32_t sessionId = 246810; + + std::lock_guard lock(audioService->pauseInterruptEventMutex_); + auto iter = audioService->pauseInterruptEventMap_.find(sessionId); + EXPECT_EQ(iter == audioService->pauseInterruptEventMap_.end(), true); lock.unlock(); // test Update when sessionId not in map - AudioService::GetInstance()->UpdateResumeInterruptEventMap(sessionId, interruptEvent); - std::lock_guard lock1(resumeInterruptEventMutex_); - auto iter = resumeInterruptEventMap_.find(sessionId); - EXPECT_EQ(iter != resumeInterruptEventMap_.end(), true); + audioService->UpdatePauseInterruptEventMap(sessionId, interruptEvent); + std::lock_guard lock1(audioService->pauseInterruptEventMutex_); + auto iter = audioService->pauseInterruptEventMap_.find(sessionId); + EXPECT_EQ(iter != audioService->pauseInterruptEventMap_.end(), true); lock1.unlock(); // test Update when sessionId in map interruptEvent.hintType = INTERRUPT_HINT_MUTE; - AudioService::GetInstance()->UpdateResumeInterruptEventMap(sessionId, interruptEvent); - std::lock_guard lock2(resumeInterruptEventMutex_); - auto iter = resumeInterruptEventMap_.find(sessionId); - EXPECT_EQ(iter != resumeInterruptEventMap_.end(), true); + audioService->UpdatePauseInterruptEventMap(sessionId, interruptEvent); + std::lock_guard lock2(audioService->pauseInterruptEventMutex_); + auto iter = audioService->pauseInterruptEventMap_.find(sessionId); + EXPECT_EQ(iter != audioService->pauseInterruptEventMap_.end(), true); EXPECT_EQ(iter->second.hintType, INTERRUPT_HINT_MUTE); lock2.unlock(); // test Remove when sessionId in map - AudioService::GetInstance()->RemoveResumeInterruptEventMap(sessionId); - std::lock_guard lock3(resumeInterruptEventMutex_); - auto iter = resumeInterruptEventMap_.find(sessionId); - EXPECT_EQ(iter == resumeInterruptEventMap_.end(), true); - lock3.unlock(); + bool res = audioService->RemovePauseInterruptEventMap(sessionId); + EXPECT_EQ(res, true); // test Remove when sessionId not in map - AudioService::GetInstance()->RemoveResumeInterruptEventMap(sessionId); - std::lock_guard lock4(resumeInterruptEventMutex_); - auto iter = resumeInterruptEventMap_.find(sessionId); - EXPECT_EQ(iter == resumeInterruptEventMap_.end(), false); - lock4.unlock(); + res = audioService->RemovePauseInterruptEventMap(sessionId); + EXPECT_EQ(res, false); } } // namespace AudioStandard -- Gitee From 5fa6b6addd0f7e5642af2240f3b7486fb77f0f23 Mon Sep 17 00:00:00 2001 From: Jvgang Date: Wed, 20 Aug 2025 07:32:32 +0000 Subject: [PATCH 6/7] Add UT Signed-off-by: Jvgang --- .../audio_service_common_unit_test.cpp | 125 +++++++++++++++++ .../test/unittest/audio_service_unit_test.cpp | 126 ------------------ 2 files changed, 125 insertions(+), 126 deletions(-) diff --git a/services/audio_service/test/unittest/audio_service_common_unit_test.cpp b/services/audio_service/test/unittest/audio_service_common_unit_test.cpp index a07c4e0d4b..d2b2328101 100644 --- a/services/audio_service/test/unittest/audio_service_common_unit_test.cpp +++ b/services/audio_service/test/unittest/audio_service_common_unit_test.cpp @@ -1781,5 +1781,130 @@ HWTEST(AudioServiceCommonUnitTest, OHAudioBufferBase_GetDuckFactor_002, TestSize float result = ohAudioBuffer->GetDuckFactor(); EXPECT_FLOAT_EQ(result, MIN_FLOAT_VOLUME); } + +/** + * @tc.name : Test SendInterruptEventToAudioService API + * @tc.type : FUNC + * @tc.number: SendInterruptEventToAudioService_001, + * @tc.desc : Test SendInterruptEventToAudioService interface. + */ +HWTEST(AudioServiceCommonUnitTest, SendInterruptEventToAudioService_001, TestSize.Level1) +{ + AudioService *audioService = AudioService::GetInstance(); + EXPECT_NE(audioService, nullptr); + + InterruptEventInternal interruptEvent = { }; + interruptEvent.hintType = INTERRUPT_HINT_RESUME; + int32_t sessionId = 13579; + audioService->SendInterruptEventToAudioService(sessionId, interruptEvent); + std::lock_guard lock(audioService->resumeInterruptEventMutex_); + auto iter = audioService->resumeInterruptEventMap_.find(sessionId); + EXPECT_EQ(iter != audioService->resumeInterruptEventMap_.end(), true); + audioService->resumeInterruptEventMap_.erase[sessionId]; +} +/** + * @tc.name : Test SendInterruptEventToAudioService API + * @tc.type : FUNC + * @tc.number: SendInterruptEventToAudioService_002, + * @tc.desc : Test SendInterruptEventToAudioService interface. + */ +HWTEST(AudioServiceCommonUnitTest, SendInterruptEventToAudioService_002, TestSize.Level1) +{ + AudioService *audioService = AudioService::GetInstance(); + EXPECT_NE(audioService, nullptr); + + InterruptEventInternal interruptEvent = { }; + interruptEvent.hintType = INTERRUPT_HINT_PAUSE; + int32_t sessionId = 24678; + audioService->SendInterruptEventToAudioService(sessionId, interruptEvent); + std::lock_guard lock(audioService->pasueInterruptEventMutex_); + auto iter = audioService->pauseInterruptEventMap_.find(sessionId); + EXPECT_EQ(iter != audioService->pauseInterruptEventMap_.end(), true); + audioService->resumeInterruptEventMap_.erase[sessionId]; +} + +/** + * @tc.name : Test resumeInterruptEventMap_ API + * @tc.type : FUNC + * @tc.number: resumeInterruptEventMap_001, + * @tc.desc : Test resumeInterruptEventMap_001 interface. + */ +HWTEST(AudioServiceCommonUnitTest, resumeInterruptEventMap_001, TestSize.Level1) +{ + AudioService *audioService = AudioService::GetInstance(); + EXPECT_NE(audioService, nullptr); + + InterruptEventInternal interruptEvent = { }; + interruptEvent.hintType = INTERRUPT_HINT_RESUME; + int32_t sessionId = 123456; + + std::lock_guard lock(audioService->resumeInterruptEventMutex_); + auto iter = audioService->resumeInterruptEventMap_.find(sessionId); + EXPECT_EQ(iter == audioService->resumeInterruptEventMap_.end(), true); + lock.unlock(); + // test Update when sessionId not in map + audioService->UpdateResumeInterruptEventMap(sessionId, interruptEvent); + std::lock_guard lock1(audioService->resumeInterruptEventMutex_); + auto iter = audioService->resumeInterruptEventMap_.find(sessionId); + EXPECT_EQ(iter != audioService->resumeInterruptEventMap_.end(), true); + lock1.unlock(); + // test Update when sessionId in map + interruptEvent.hintType = INTERRUPT_HINT_MUTE; + audioService->UpdateResumeInterruptEventMap(sessionId, interruptEvent); + std::lock_guard lock2(audioService->resumeInterruptEventMutex_); + auto iter = audioService->resumeInterruptEventMap_.find(sessionId); + EXPECT_EQ(iter != audioService->resumeInterruptEventMap_.end(), true); + EXPECT_EQ(iter->second.hintType, INTERRUPT_HINT_MUTE); + lock2.unlock(); + + // test Remove when sessionId in map + bool res = audioService->RemoveResumeInterruptEventMap(sessionId); + EXPECT_EQ(res, true); + // test Remove when sessionId not in map + res = audioService->RemoveResumeInterruptEventMap(sessionId); + EXPECT_EQ(res, false); +} + +/** + * @tc.name : Test pauseInterruptEventMap_ API + * @tc.type : FUNC + * @tc.number: pauseInterruptEventMap_001, + * @tc.desc : Test pauseInterruptEventMap_001 interface. + */ +HWTEST(AudioServiceCommonUnitTest, pauseInterruptEventMap_001, TestSize.Level1) +{ + AudioService *audioService = AudioService::GetInstance(); + EXPECT_NE(audioService, nullptr); + + InterruptEventInternal interruptEvent = { }; + interruptEvent.hintType = INTERRUPT_HINT_PAUSE; + int32_t sessionId = 246810; + + std::lock_guard lock(audioService->pauseInterruptEventMutex_); + auto iter = audioService->pauseInterruptEventMap_.find(sessionId); + EXPECT_EQ(iter == audioService->pauseInterruptEventMap_.end(), true); + lock.unlock(); + // test Update when sessionId not in map + audioService->UpdatePauseInterruptEventMap(sessionId, interruptEvent); + std::lock_guard lock1(audioService->pauseInterruptEventMutex_); + auto iter = audioService->pauseInterruptEventMap_.find(sessionId); + EXPECT_EQ(iter != audioService->pauseInterruptEventMap_.end(), true); + lock1.unlock(); + // test Update when sessionId in map + interruptEvent.hintType = INTERRUPT_HINT_MUTE; + audioService->UpdatePauseInterruptEventMap(sessionId, interruptEvent); + std::lock_guard lock2(audioService->pauseInterruptEventMutex_); + auto iter = audioService->pauseInterruptEventMap_.find(sessionId); + EXPECT_EQ(iter != audioService->pauseInterruptEventMap_.end(), true); + EXPECT_EQ(iter->second.hintType, INTERRUPT_HINT_MUTE); + lock2.unlock(); + + // test Remove when sessionId in map + bool res = audioService->RemovePauseInterruptEventMap(sessionId); + EXPECT_EQ(res, true); + // test Remove when sessionId not in map + res = audioService->RemovePauseInterruptEventMap(sessionId); + EXPECT_EQ(res, false); +} } // namespace AudioStandard } // namespace OHOS \ No newline at end of file diff --git a/services/audio_service/test/unittest/audio_service_unit_test.cpp b/services/audio_service/test/unittest/audio_service_unit_test.cpp index c410eaaaa0..5f5c74ee8a 100644 --- a/services/audio_service/test/unittest/audio_service_unit_test.cpp +++ b/services/audio_service/test/unittest/audio_service_unit_test.cpp @@ -3203,131 +3203,5 @@ HWTEST(AudioServiceUnitTest, ConfigCoreServiceProvider_003, TestSize.Level1) int32_t ret = coreServiceHandler.ConfigCoreServiceProvider(coreServiceProvider); EXPECT_EQ(ret, ERR_INVALID_OPERATION); } - -/** - * @tc.name : Test SendInterruptEventToAudioService API - * @tc.type : FUNC - * @tc.number: SendInterruptEventToAudioService_001, - * @tc.desc : Test SendInterruptEventToAudioService interface. - */ -HWTEST(AudioServiceUnitTest, SendInterruptEventToAudioService_001, TestSize.Level1) -{ - AudioService *audioService = AudioService::GetInstance(); - EXPECT_NE(audioService, nullptr); - - InterruptEventInternal interruptEvent = { }; - interruptEvent.hintType = INTERRUPT_HINT_RESUME; - int32_t sessionId = 13579; - audioService->SendInterruptEventToAudioService(sessionId, interruptEvent); - std::lock_guard lock(audioService->resumeInterruptEventMutex_); - auto iter = audioService->resumeInterruptEventMap_.find(sessionId); - EXPECT_EQ(iter != audioService->resumeInterruptEventMap_.end(), true); - audioService->resumeInterruptEventMap_.erase[sessionId]; -} -/** - * @tc.name : Test SendInterruptEventToAudioService API - * @tc.type : FUNC - * @tc.number: SendInterruptEventToAudioService_002, - * @tc.desc : Test SendInterruptEventToAudioService interface. - */ -HWTEST(AudioServiceUnitTest, SendInterruptEventToAudioService_002, TestSize.Level1) -{ - AudioService *audioService = AudioService::GetInstance(); - EXPECT_NE(audioService, nullptr); - - InterruptEventInternal interruptEvent = { }; - interruptEvent.hintType = INTERRUPT_HINT_PAUSE; - int32_t sessionId = 24678; - audioService->SendInterruptEventToAudioService(sessionId, interruptEvent); - std::lock_guard lock(audioService->pasueInterruptEventMutex_); - auto iter = audioService->pauseInterruptEventMap_.find(sessionId); - EXPECT_EQ(iter != audioService->pauseInterruptEventMap_.end(), true); - audioService->resumeInterruptEventMap_.erase[sessionId]; -} - -/** - * @tc.name : Test resumeInterruptEventMap_ API - * @tc.type : FUNC - * @tc.number: resumeInterruptEventMap_001, - * @tc.desc : Test resumeInterruptEventMap_001 interface. - */ -HWTEST(AudioServiceUnitTest, resumeInterruptEventMap_001, TestSize.Level1) -{ - AudioService *audioService = AudioService::GetInstance(); - EXPECT_NE(audioService, nullptr); - - InterruptEventInternal interruptEvent = { }; - interruptEvent.hintType = INTERRUPT_HINT_RESUME; - int32_t sessionId = 123456; - - std::lock_guard lock(audioService->resumeInterruptEventMutex_); - auto iter = audioService->resumeInterruptEventMap_.find(sessionId); - EXPECT_EQ(iter == audioService->resumeInterruptEventMap_.end(), true); - lock.unlock(); - // test Update when sessionId not in map - audioService->UpdateResumeInterruptEventMap(sessionId, interruptEvent); - std::lock_guard lock1(audioService->resumeInterruptEventMutex_); - auto iter = audioService->resumeInterruptEventMap_.find(sessionId); - EXPECT_EQ(iter != audioService->resumeInterruptEventMap_.end(), true); - lock1.unlock(); - // test Update when sessionId in map - interruptEvent.hintType = INTERRUPT_HINT_MUTE; - audioService->UpdateResumeInterruptEventMap(sessionId, interruptEvent); - std::lock_guard lock2(audioService->resumeInterruptEventMutex_); - auto iter = audioService->resumeInterruptEventMap_.find(sessionId); - EXPECT_EQ(iter != audioService->resumeInterruptEventMap_.end(), true); - EXPECT_EQ(iter->second.hintType, INTERRUPT_HINT_MUTE); - lock2.unlock(); - - // test Remove when sessionId in map - bool res = audioService->RemoveResumeInterruptEventMap(sessionId); - EXPECT_EQ(res, true); - // test Remove when sessionId not in map - res = audioService->RemoveResumeInterruptEventMap(sessionId); - EXPECT_EQ(res, false); -} - -/** - * @tc.name : Test pauseInterruptEventMap_ API - * @tc.type : FUNC - * @tc.number: pauseInterruptEventMap_001, - * @tc.desc : Test pauseInterruptEventMap_001 interface. - */ -HWTEST(AudioServiceUnitTest, pauseInterruptEventMap_001, TestSize.Level1) -{ - AudioService *audioService = AudioService::GetInstance(); - EXPECT_NE(audioService, nullptr); - - InterruptEventInternal interruptEvent = { }; - interruptEvent.hintType = INTERRUPT_HINT_PAUSE; - int32_t sessionId = 246810; - - std::lock_guard lock(audioService->pauseInterruptEventMutex_); - auto iter = audioService->pauseInterruptEventMap_.find(sessionId); - EXPECT_EQ(iter == audioService->pauseInterruptEventMap_.end(), true); - lock.unlock(); - // test Update when sessionId not in map - audioService->UpdatePauseInterruptEventMap(sessionId, interruptEvent); - std::lock_guard lock1(audioService->pauseInterruptEventMutex_); - auto iter = audioService->pauseInterruptEventMap_.find(sessionId); - EXPECT_EQ(iter != audioService->pauseInterruptEventMap_.end(), true); - lock1.unlock(); - // test Update when sessionId in map - interruptEvent.hintType = INTERRUPT_HINT_MUTE; - audioService->UpdatePauseInterruptEventMap(sessionId, interruptEvent); - std::lock_guard lock2(audioService->pauseInterruptEventMutex_); - auto iter = audioService->pauseInterruptEventMap_.find(sessionId); - EXPECT_EQ(iter != audioService->pauseInterruptEventMap_.end(), true); - EXPECT_EQ(iter->second.hintType, INTERRUPT_HINT_MUTE); - lock2.unlock(); - - // test Remove when sessionId in map - bool res = audioService->RemovePauseInterruptEventMap(sessionId); - EXPECT_EQ(res, true); - // test Remove when sessionId not in map - res = audioService->RemovePauseInterruptEventMap(sessionId); - EXPECT_EQ(res, false); -} - } // namespace AudioStandard } // namespace OHOS -- Gitee From 2883fa34e9865cd9ac458054ca55da046a350fc0 Mon Sep 17 00:00:00 2001 From: Jvgang Date: Wed, 20 Aug 2025 09:49:11 +0000 Subject: [PATCH 7/7] Add UT Signed-off-by: Jvgang --- .../test/unittest/audio_service_common_unit_test.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/services/audio_service/test/unittest/audio_service_common_unit_test.cpp b/services/audio_service/test/unittest/audio_service_common_unit_test.cpp index d2b2328101..8dcf307184 100644 --- a/services/audio_service/test/unittest/audio_service_common_unit_test.cpp +++ b/services/audio_service/test/unittest/audio_service_common_unit_test.cpp @@ -19,6 +19,7 @@ #include "audio_ring_cache.h" #include "audio_process_config.h" #include "linear_pos_time_model.h" +#include "audio_service.h" #include "oh_audio_buffer.h" #include #include -- Gitee