1 /* 2 * Copyright (c) 2025 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "audio_policy_server_unit_test.h" 17 #include "media_monitor_manager.h" 18 #include "input_manager.h" 19 #include "privacy_kit.h" 20 #include "tokenid_kit.h" 21 #include "common_event_manager.h" 22 #include "audio_policy_log.h" 23 #include "client_type_manager.h" 24 #include "dfx_msg_manager.h" 25 using namespace testing::ext; 26 27 namespace OHOS { 28 namespace AudioStandard { 29 /** 30 * @tc.name : Test AudioPolicyServer. 31 * @tc.number: AudioPolicyServer_169 32 * @tc.desc : Test DeactivatePreemptMode. 33 */ 34 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_169, TestSize.Level1) 35 { 36 int32_t systemAbilityId = 0; 37 auto audioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId); 38 ASSERT_NE(audioPolicyServer, nullptr); 39 40 int32_t result = audioPolicyServer->DeactivatePreemptMode(); 41 EXPECT_EQ(result, ERROR); 42 } 43 44 /** 45 * @tc.name : Test AudioPolicyServer. 46 * @tc.number: AudioPolicyServer_170 47 * @tc.desc : Test SubscribeBackgroundTask. 48 */ 49 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_170, TestSize.Level1) 50 { 51 int32_t systemAbilityId = 0; 52 auto audioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId); 53 ASSERT_NE(audioPolicyServer, nullptr);; 54 55 audioPolicyServer->SubscribeBackgroundTask(); 56 } 57 58 /** 59 * @tc.name : Test AudioPolicyServer. 60 * @tc.number: AudioPolicyServer_200 61 * @tc.desc : Test AudioPolicyServer::ProcessVolumeKeyEvents 62 */ 63 HWTEST(AudioPolicyUnitTestSecond, AudioPolicyServer_200, TestSize.Level1) 64 { 65 int32_t systemAbilityId = 0; 66 auto audioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId); 67 ASSERT_NE(audioPolicyServer, nullptr); 68 69 int32_t keyType = OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP; 70 audioPolicyServer->volumeApplyToAll_ = true; 71 audioPolicyServer->isScreenOffOrLock_ = true; 72 VolumeUtils::SetPCVolumeEnable(true); 73 auto ret = audioPolicyServer->ProcessVolumeKeyEvents(keyType); 74 EXPECT_EQ(ret, SUCCESS); 75 } 76 77 /** 78 * @tc.name : Test AudioPolicyServer. 79 * @tc.number: AudioPolicyServer_201 80 * @tc.desc : Test AudioPolicyServer::ProcessVolumeKeyEvents 81 */ 82 HWTEST(AudioPolicyUnitTestSecond, AudioPolicyServer_201, TestSize.Level1) 83 { 84 int32_t systemAbilityId = 0; 85 auto audioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId); 86 ASSERT_NE(audioPolicyServer, nullptr); 87 88 int32_t keyType = OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP; 89 audioPolicyServer->volumeApplyToAll_ = false; 90 audioPolicyServer->isScreenOffOrLock_ = true; 91 VolumeUtils::SetPCVolumeEnable(true); 92 auto ret = audioPolicyServer->ProcessVolumeKeyEvents(keyType); 93 EXPECT_EQ(ret, SUCCESS); 94 } 95 96 /** 97 * @tc.name : Test AudioPolicyServer. 98 * @tc.number: AudioPolicyServer_202 99 * @tc.desc : Test AudioPolicyServer::ProcessVolumeKeyEvents 100 */ 101 HWTEST(AudioPolicyUnitTestSecond, AudioPolicyServer_202, TestSize.Level1) 102 { 103 int32_t systemAbilityId = 0; 104 auto audioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId); 105 ASSERT_NE(audioPolicyServer, nullptr); 106 107 int32_t keyType = OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP; 108 audioPolicyServer->volumeApplyToAll_ = true; 109 audioPolicyServer->isScreenOffOrLock_ = false; 110 VolumeUtils::SetPCVolumeEnable(true); 111 auto ret = audioPolicyServer->ProcessVolumeKeyEvents(keyType); 112 EXPECT_EQ(ret, SUCCESS); 113 } 114 115 /** 116 * @tc.name : Test AudioPolicyServer. 117 * @tc.number: AudioPolicyServer_203 118 * @tc.desc : Test AudioPolicyServer::ProcessVolumeKeyEvents 119 */ 120 HWTEST(AudioPolicyUnitTestSecond, AudioPolicyServer_203, TestSize.Level1) 121 { 122 int32_t systemAbilityId = 0; 123 auto audioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId); 124 ASSERT_NE(audioPolicyServer, nullptr); 125 126 int32_t keyType = OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP; 127 audioPolicyServer->volumeApplyToAll_ = true; 128 audioPolicyServer->isScreenOffOrLock_ = true; 129 VolumeUtils::SetPCVolumeEnable(false); 130 auto ret = audioPolicyServer->ProcessVolumeKeyEvents(keyType); 131 EXPECT_EQ(ret, SUCCESS); 132 } 133 134 /** 135 * @tc.name : Test AudioPolicyServer. 136 * @tc.number: AudioPolicyServer_204 137 * @tc.desc : Test AudioPolicyServer::ProcessVolumeKeyEvents 138 */ 139 HWTEST(AudioPolicyUnitTestSecond, AudioPolicyServer_204, TestSize.Level1) 140 { 141 int32_t systemAbilityId = 0; 142 auto audioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId); 143 ASSERT_NE(audioPolicyServer, nullptr); 144 145 int32_t keyType = OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP; 146 audioPolicyServer->volumeApplyToAll_ = false; 147 audioPolicyServer->isScreenOffOrLock_ = false; 148 VolumeUtils::SetPCVolumeEnable(true); 149 auto ret = audioPolicyServer->ProcessVolumeKeyEvents(keyType); 150 EXPECT_EQ(ret, SUCCESS); 151 } 152 153 /** 154 * @tc.name : Test AudioPolicyServer. 155 * @tc.number: AudioPolicyServer_205 156 * @tc.desc : Test AudioPolicyServer::ProcessVolumeKeyEvents 157 */ 158 HWTEST(AudioPolicyUnitTestSecond, AudioPolicyServer_205, TestSize.Level1) 159 { 160 int32_t systemAbilityId = 0; 161 auto audioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId); 162 ASSERT_NE(audioPolicyServer, nullptr); 163 164 int32_t keyType = OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP; 165 audioPolicyServer->volumeApplyToAll_ = false; 166 audioPolicyServer->isScreenOffOrLock_ = false; 167 VolumeUtils::SetPCVolumeEnable(false); 168 auto ret = audioPolicyServer->ProcessVolumeKeyEvents(keyType); 169 EXPECT_EQ(ret, SUCCESS); 170 } 171 172 /** 173 * @tc.name : Test AudioPolicyServer. 174 * @tc.number: AudioPolicyServer_206 175 * @tc.desc : Test AudioPolicyServer::ProcessVolumeKeyEvents 176 */ 177 HWTEST(AudioPolicyUnitTestSecond, AudioPolicyServer_206, TestSize.Level1) 178 { 179 int32_t systemAbilityId = 0; 180 auto audioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId); 181 ASSERT_NE(audioPolicyServer, nullptr); 182 183 int32_t keyType = OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP; 184 audioPolicyServer->volumeApplyToAll_ = true; 185 audioPolicyServer->isScreenOffOrLock_ = false; 186 VolumeUtils::SetPCVolumeEnable(false); 187 auto ret = audioPolicyServer->ProcessVolumeKeyEvents(keyType); 188 EXPECT_EQ(ret, SUCCESS); 189 } 190 191 /** 192 * @tc.name : Test AudioPolicyServer. 193 * @tc.number: AudioPolicyServer_207 194 * @tc.desc : Test AudioPolicyServer::SetStreamMute 195 */ 196 HWTEST(AudioPolicyUnitTestSecond, AudioPolicyServer_207, TestSize.Level1) 197 { 198 int32_t systemAbilityId = 0; 199 auto audioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId); 200 ASSERT_NE(audioPolicyServer, nullptr); 201 202 AudioStreamType streamType = STREAM_VOICE_CALL; 203 bool mute = true; 204 DeviceType deviceType = DEVICE_TYPE_INVALID; 205 auto ret = audioPolicyServer->SetStreamMute(streamType, mute, deviceType); 206 EXPECT_EQ(ret, SUCCESS); 207 } 208 209 /** 210 * @tc.name : Test AudioPolicyServer. 211 * @tc.number: AudioPolicyServer_208 212 * @tc.desc : Test AudioPolicyServer::UpdateSystemMuteStateAccordingMusicState 213 */ 214 HWTEST(AudioPolicyUnitTestSecond, AudioPolicyServer_208, TestSize.Level1) 215 { 216 int32_t systemAbilityId = 0; 217 auto audioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId); 218 ASSERT_NE(audioPolicyServer, nullptr); 219 220 AudioStreamType streamType = STREAM_VOICE_CALL; 221 bool mute = true; 222 bool isUpdateUi = true; 223 VolumeUtils::SetPCVolumeEnable(true); 224 audioPolicyServer->UpdateSystemMuteStateAccordingMusicState(streamType, mute, isUpdateUi); 225 EXPECT_EQ(VolumeUtils::GetVolumeTypeFromStreamType(STREAM_VOICE_CALL), AudioStreamType::STREAM_MUSIC); 226 EXPECT_EQ(VolumeUtils::IsPCVolumeEnable(), true); 227 } 228 229 /** 230 * @tc.name : Test AudioPolicyServer. 231 * @tc.number: AudioPolicyServer_209 232 * @tc.desc : Test AudioPolicyServer::UpdateSystemMuteStateAccordingMusicState 233 */ 234 HWTEST(AudioPolicyUnitTestSecond, AudioPolicyServer_209, TestSize.Level1) 235 { 236 int32_t systemAbilityId = 0; 237 auto audioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId); 238 ASSERT_NE(audioPolicyServer, nullptr); 239 240 AudioStreamType streamType = STREAM_VOICE_CALL; 241 bool mute = false; 242 bool isUpdateUi = true; 243 VolumeUtils::SetPCVolumeEnable(true); 244 audioPolicyServer->UpdateSystemMuteStateAccordingMusicState(streamType, mute, isUpdateUi); 245 EXPECT_EQ(VolumeUtils::GetVolumeTypeFromStreamType(STREAM_VOICE_CALL), AudioStreamType::STREAM_MUSIC); 246 EXPECT_EQ(VolumeUtils::IsPCVolumeEnable(), true); 247 } 248 249 /** 250 * @tc.name : Test AudioPolicyServer. 251 * @tc.number: AudioPolicyServer_210 252 * @tc.desc : Test AudioPolicyServer::UpdateSystemMuteStateAccordingMusicState 253 */ 254 HWTEST(AudioPolicyUnitTestSecond, AudioPolicyServer_210, TestSize.Level1) 255 { 256 int32_t systemAbilityId = 0; 257 auto audioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId); 258 ASSERT_NE(audioPolicyServer, nullptr); 259 260 AudioStreamType streamType = STREAM_ALL; 261 bool mute = false; 262 bool isUpdateUi = true; 263 VolumeUtils::SetPCVolumeEnable(true); 264 audioPolicyServer->UpdateSystemMuteStateAccordingMusicState(streamType, mute, isUpdateUi); 265 EXPECT_EQ(VolumeUtils::GetVolumeTypeFromStreamType(STREAM_ALL), AudioStreamType::STREAM_ALL); 266 EXPECT_EQ(VolumeUtils::IsPCVolumeEnable(), true); 267 } 268 269 /** 270 * @tc.name : Test AudioPolicyServer. 271 * @tc.number: AudioPolicyServer_211 272 * @tc.desc : Test AudioPolicyServer::UpdateSystemMuteStateAccordingMusicState 273 */ 274 HWTEST(AudioPolicyUnitTestSecond, AudioPolicyServer_211, TestSize.Level1) 275 { 276 int32_t systemAbilityId = 0; 277 auto audioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId); 278 ASSERT_NE(audioPolicyServer, nullptr); 279 280 AudioStreamType streamType = STREAM_MUSIC; 281 bool mute = false; 282 bool isUpdateUi = true; 283 VolumeUtils::SetPCVolumeEnable(false); 284 audioPolicyServer->UpdateSystemMuteStateAccordingMusicState(streamType, mute, isUpdateUi); 285 EXPECT_EQ(VolumeUtils::GetVolumeTypeFromStreamType(STREAM_MUSIC), AudioStreamType::STREAM_MUSIC); 286 EXPECT_EQ(VolumeUtils::IsPCVolumeEnable(), false); 287 EXPECT_EQ(audioPolicyServer->GetStreamMuteInternal(STREAM_SYSTEM), false); 288 } 289 290 /** 291 * @tc.name : Test AudioPolicyServer. 292 * @tc.number: AudioPolicyServer_212 293 * @tc.desc : Test AudioPolicyServer::GetPreferredInputDeviceDescriptors 294 */ 295 HWTEST(AudioPolicyUnitTestSecond, AudioPolicyServer_212, TestSize.Level1) 296 { 297 int32_t systemAbilityId = 0; 298 auto audioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId); 299 ASSERT_NE(audioPolicyServer, nullptr); 300 301 auto audioCoreService = std::make_shared<AudioCoreService>(); 302 EXPECT_NE(audioCoreService, nullptr); 303 audioPolicyServer->eventEntry_ = std::make_shared<AudioCoreService::EventEntry>(audioCoreService); 304 EXPECT_NE(audioPolicyServer->eventEntry_, nullptr); 305 306 AudioCapturerInfo captureInfo; 307 std::vector<std::shared_ptr<AudioDeviceDescriptor>> ret; 308 audioPolicyServer->GetPreferredInputDeviceDescriptors(captureInfo, ret); 309 EXPECT_NE(ret.size(), 0); 310 } 311 312 /** 313 * @tc.name : Test AudioPolicyServer. 314 * @tc.number: AudioPolicyServer_213 315 * @tc.desc : Test AudioPolicyServer::SetMicrophoneMutePersistent 316 */ 317 HWTEST(AudioPolicyUnitTestSecond, AudioPolicyServer_213, TestSize.Level1) 318 { 319 int32_t systemAbilityId = 0; 320 auto audioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId); 321 ASSERT_NE(audioPolicyServer, nullptr); 322 323 bool isMute = true; 324 PolicyType type = EDM_POLICY_TYPE; 325 326 auto ret = audioPolicyServer->SetMicrophoneMutePersistent(isMute, type); 327 EXPECT_NE(ret, 0); 328 } 329 330 /** 331 * @tc.name : Test AudioPolicyServer. 332 * @tc.number: AudioPolicyServer_214 333 * @tc.desc : Test AudioPolicyServer::DeactivateAudioInterrupt 334 */ 335 HWTEST(AudioPolicyUnitTestSecond, AudioPolicyServer_214, TestSize.Level1) 336 { 337 int32_t systemAbilityId = 0; 338 auto audioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId); 339 ASSERT_NE(audioPolicyServer, nullptr); 340 341 AudioInterrupt audioInterrupt; 342 int32_t zoneID = 0; 343 audioPolicyServer->interruptService_ = nullptr; 344 345 auto ret = audioPolicyServer->DeactivateAudioInterrupt(audioInterrupt, zoneID); 346 EXPECT_EQ(ret, ERR_UNKNOWN); 347 } 348 349 /** 350 * @tc.name : Test AudioPolicyServer. 351 * @tc.number: AudioPolicyServer_215 352 * @tc.desc : Test AudioPolicyServer::ActivatePreemptMode 353 */ 354 HWTEST(AudioPolicyUnitTestSecond, AudioPolicyServer_215, TestSize.Level1) 355 { 356 int32_t systemAbilityId = 0; 357 auto audioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId); 358 ASSERT_NE(audioPolicyServer, nullptr); 359 360 EXPECT_NE(static_cast<uid_t>(IPCSkeleton::GetCallingUid()), audioPolicyServer->PREEMPT_UID); 361 362 auto ret = audioPolicyServer->ActivatePreemptMode(); 363 EXPECT_EQ(ret, ERROR); 364 } 365 366 /** 367 * @tc.name : Test AudioPolicyServer. 368 * @tc.number: AudioPolicyServer_216 369 * @tc.desc : Test AudioPolicyServer::DeactivatePreemptMode 370 */ 371 HWTEST(AudioPolicyUnitTestSecond, AudioPolicyServer_216, TestSize.Level1) 372 { 373 int32_t systemAbilityId = 0; 374 auto audioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId); 375 ASSERT_NE(audioPolicyServer, nullptr); 376 377 EXPECT_NE(static_cast<uid_t>(IPCSkeleton::GetCallingUid()), audioPolicyServer->PREEMPT_UID); 378 379 auto ret = audioPolicyServer->DeactivatePreemptMode(); 380 EXPECT_EQ(ret, ERROR); 381 } 382 383 /** 384 * @tc.name : Test AudioPolicyServer. 385 * @tc.number: AudioPolicyServer_217 386 * @tc.desc : Test CallRingtoneLibrary. 387 */ 388 HWTEST(AudioPolicyUnitTestSecond, AudioPolicyServer_217, TestSize.Level1) 389 { 390 int32_t systemAbilityId = 0; 391 auto audioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId); 392 ASSERT_NE(audioPolicyServer, nullptr); 393 394 int32_t result = audioPolicyServer->CallRingtoneLibrary(); 395 EXPECT_EQ(result, SUCCESS); 396 } 397 398 /** 399 * @tc.name : Test AudioPolicyServer. 400 * @tc.number: AudioPolicyServer_218 401 * @tc.desc : Test OnReceiveEvent. 402 */ 403 HWTEST(AudioPolicyUnitTestSecond, AudioPolicyServer_218, TestSize.Level4) 404 { 405 int32_t systemAbilityId = 0; 406 auto audioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId); 407 ASSERT_NE(audioPolicyServer, nullptr); 408 409 EventFwk::CommonEventData eventData; 410 OHOS::EventFwk::Want want; 411 want.SetAction("usual.event.LOCALE_CHANGED"); 412 eventData.SetWant(want); 413 audioPolicyServer->OnReceiveEvent(eventData); 414 int32_t result = audioPolicyServer->CallRingtoneLibrary(); 415 EXPECT_EQ(result, SUCCESS); 416 } 417 418 /** 419 * @tc.name : Test AudioPolicyServer. 420 * @tc.number: AudioPolicyServer_219 421 * @tc.desc : Test OnReceiveEvent. 422 */ 423 HWTEST(AudioPolicyUnitTestSecond, AudioPolicyServer_219, TestSize.Level4) 424 { 425 int32_t systemAbilityId = 0; 426 auto audioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId); 427 ASSERT_NE(audioPolicyServer, nullptr); 428 429 EventFwk::CommonEventData eventData; 430 OHOS::EventFwk::Want want; 431 want.SetAction("usual.event.DATA_SHARE_READY"); 432 eventData.SetWant(want); 433 audioPolicyServer->OnReceiveEvent(eventData); 434 EXPECT_EQ(audioPolicyServer->isInitRingtoneReady_, true); 435 // branch testing 436 audioPolicyServer->OnReceiveEvent(eventData); 437 EXPECT_EQ(audioPolicyServer->isInitRingtoneReady_, true); 438 } 439 440 /** 441 * @tc.name : IsContinueAddVolTest_001 442 * @tc.number: IsContinueAddVolTest_001 443 * @tc.desc : test false case with call once 444 */ 445 HWTEST(AudioPolicyUnitTest, IsContinueAddVolTest_001, TestSize.Level1) 446 { 447 int32_t systemAbilityId = 3009; 448 bool runOnCreate = false; 449 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate); 450 EXPECT_NE(ptrAudioPolicyServer, nullptr); 451 ptrAudioPolicyServer->volUpHistory_ = {}; 452 bool result = ptrAudioPolicyServer->IsContinueAddVol(); 453 EXPECT_FALSE(result); 454 } 455 456 /** 457 * @tc.name : IsContinueAddVolTest_002 458 * @tc.number: IsContinueAddVolTest_002 459 * @tc.desc : test false case with call twice 460 */ 461 HWTEST(AudioPolicyUnitTest, IsContinueAddVolTest_002, TestSize.Level1) 462 { 463 int32_t systemAbilityId = 3009; 464 bool runOnCreate = false; 465 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate); 466 EXPECT_NE(ptrAudioPolicyServer, nullptr); 467 ptrAudioPolicyServer->volUpHistory_ = {}; 468 ptrAudioPolicyServer->IsContinueAddVol(); // first 469 bool result = ptrAudioPolicyServer->IsContinueAddVol(); //second 470 EXPECT_FALSE(result); 471 } 472 473 /** 474 * @tc.name : IsContinueAddVolTest_003 475 * @tc.number: IsContinueAddVolTest_003 476 * @tc.desc : test true case 477 */ 478 HWTEST(AudioPolicyUnitTest, IsContinueAddVolTest_003, TestSize.Level1) 479 { 480 int32_t systemAbilityId = 3009; 481 bool runOnCreate = false; 482 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate); 483 EXPECT_NE(ptrAudioPolicyServer, nullptr); 484 ptrAudioPolicyServer->volUpHistory_ = {}; 485 ptrAudioPolicyServer->IsContinueAddVol(); // first 486 ptrAudioPolicyServer->IsContinueAddVol(); // second 487 bool result = ptrAudioPolicyServer->IsContinueAddVol(); //third 488 EXPECT_TRUE(result); 489 } 490 491 /** 492 * @tc.name : IsContinueAddVolTest_004 493 * @tc.number: IsContinueAddVolTest_004 494 * @tc.desc : test true case 495 */ 496 HWTEST(AudioPolicyUnitTest, IsContinueAddVolTest_004, TestSize.Level1) 497 { 498 int32_t systemAbilityId = 3009; 499 bool runOnCreate = false; 500 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate); 501 EXPECT_NE(ptrAudioPolicyServer, nullptr); 502 ptrAudioPolicyServer->volUpHistory_ = {}; 503 ptrAudioPolicyServer->IsContinueAddVol(); // first 504 ptrAudioPolicyServer->IsContinueAddVol(); // second 505 uint32_t sleepTime = 1; 506 sleep(sleepTime); // sleep for false 507 bool result = ptrAudioPolicyServer->IsContinueAddVol(); //third 508 EXPECT_FALSE(result); 509 } 510 511 /** 512 * @tc.name : Test TriggerMuteCheck. 513 * @tc.number: TriggerMuteCheck_001 514 * @tc.desc : Test AudioPolicyServer::TriggerMuteCheck 515 */ 516 HWTEST(AudioPolicyUnitTest, TriggerMuteCheck_001, TestSize.Level1) 517 { 518 int32_t systemAbilityId = 3009; 519 bool runOnCreate = false; 520 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate); 521 EXPECT_NE(ptrAudioPolicyServer, nullptr); 522 ptrAudioPolicyServer->TriggerMuteCheck(); 523 } 524 525 /** 526 * @tc.name : Test TriggerMuteCheck. 527 * @tc.number: TriggerMuteCheck_002 528 * @tc.desc : Test AudioPolicyServer::TriggerMuteCheck 529 */ 530 HWTEST(AudioPolicyUnitTest, TriggerMuteCheck_002, TestSize.Level1) 531 { 532 int32_t systemAbilityId = 3009; 533 bool runOnCreate = false; 534 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate); 535 EXPECT_NE(ptrAudioPolicyServer, nullptr); 536 std::shared_ptr<AudioRendererChangeInfo> info = std::make_shared<AudioRendererChangeInfo>(); 537 EXPECT_NE(info, nullptr); 538 info->rendererState = RENDERER_RUNNING; 539 AudioStreamCollector::GetAudioStreamCollector().audioRendererChangeInfos_.push_back(info); 540 ptrAudioPolicyServer->TriggerMuteCheck(); 541 info->outputDeviceInfo.networkId_ = LOCAL_NETWORK_ID; 542 ptrAudioPolicyServer->TriggerMuteCheck(); 543 } 544 545 /** 546 * @tc.name : Test ProcessVolumeKeyEvents. 547 * @tc.number: ProcessVolumeKeyEvents_001 548 * @tc.desc : Test AudioPolicyServer::ProcessVolumeKeyEvents 549 */ 550 HWTEST(AudioPolicyUnitTest, ProcessVolumeKeyEvents_001, TestSize.Level1) 551 { 552 int32_t systemAbilityId = 3009; 553 bool runOnCreate = false; 554 int32_t keyType = OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP; 555 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate); 556 EXPECT_NE(ptrAudioPolicyServer, nullptr); 557 ptrAudioPolicyServer->ProcessVolumeKeyEvents(keyType); 558 } 559 } // AudioStandard 560 } // OHOS 561