1 /*
2 * Copyright (c) 2024-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 "audio_policy_server.h"
18 #include "audio_interrupt_unit_test.h"
19 #include "audio_info.h"
20 #include "securec.h"
21 #include "audio_interrupt_service.h"
22 #include "audio_device_descriptor.h"
23
24 #ifdef FEATURE_MULTIMODALINPUT_INPUT
25 #include "input_manager.h"
26 #endif
27
28 #include <thread>
29 #include <memory>
30 #include <vector>
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace AudioStandard {
35
36 bool g_hasServerInit = false;
GetPolicyServerUnitTest()37 sptr<AudioPolicyServer> GetPolicyServerUnitTest()
38 {
39 static int32_t systemAbilityId = 3009;
40 static bool runOnCreate = false;
41 static sptr<AudioPolicyServer> server =
42 sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
43 if (!g_hasServerInit) {
44 server->OnStart();
45 server->OnAddSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID, "");
46 #ifdef FEATURE_MULTIMODALINPUT_INPUT
47 server->OnAddSystemAbility(MULTIMODAL_INPUT_SERVICE_ID, "");
48 #endif
49 server->OnAddSystemAbility(BLUETOOTH_HOST_SYS_ABILITY_ID, "");
50 server->OnAddSystemAbility(POWER_MANAGER_SERVICE_ID, "");
51 server->OnAddSystemAbility(SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN, "");
52 server->audioPolicyService_.SetDefaultDeviceLoadFlag(true);
53 g_hasServerInit = true;
54 }
55 return server;
56 }
57
ReleaseServer()58 void ReleaseServer()
59 {
60 GetPolicyServerUnitTest()->OnStop();
61 g_hasServerInit = false;
62 }
63
SetUpTestCase(void)64 void AudioPolicyUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)65 void AudioPolicyUnitTest::TearDownTestCase(void) {}
SetUp(void)66 void AudioPolicyUnitTest::SetUp(void) {}
67
TearDown(void)68 void AudioPolicyUnitTest::TearDown(void)
69 {
70 ReleaseServer();
71 }
72
73 class RemoteObjectTestStub : public IRemoteObject {
74 public:
RemoteObjectTestStub()75 RemoteObjectTestStub() : IRemoteObject(u"IRemoteObject") {}
GetObjectRefCount()76 int32_t GetObjectRefCount() { return 0; };
SendRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)77 int SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) { return 0; };
AddDeathRecipient(const sptr<DeathRecipient> & recipient)78 bool AddDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
RemoveDeathRecipient(const sptr<DeathRecipient> & recipient)79 bool RemoveDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
Dump(int fd,const std::vector<std::u16string> & args)80 int Dump(int fd, const std::vector<std::u16string> &args) { return 0; };
81
82 DECLARE_INTERFACE_DESCRIPTOR(u"RemoteObjectTestStub");
83 };
84
85 #define PRINT_LINE printf("debug __LINE__:%d\n", __LINE__)
86
87 /**
88 * @tc.name : Test AudioPolicyServer.
89 * @tc.number: AudioPolicyServer_001
90 * @tc.desc : Test CheckAudioSessionStrategy.
91 */
92 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_001, TestSize.Level1)
93 {
94 AudioSessionStrategy strategy;
95 auto policyServerTest = GetPolicyServerUnitTest();
96 int32_t systemAbilityId = 3009;
97 bool runOnCreate = false;
98 sptr<AudioPolicyServer> server = sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
99
100 strategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
101 EXPECT_TRUE(server->CheckAudioSessionStrategy(strategy));
102 strategy.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
103 EXPECT_TRUE(server->CheckAudioSessionStrategy(strategy));
104 strategy.concurrencyMode = AudioConcurrencyMode::DUCK_OTHERS;
105 EXPECT_TRUE(server->CheckAudioSessionStrategy(strategy));
106 strategy.concurrencyMode = AudioConcurrencyMode::PAUSE_OTHERS;
107 EXPECT_TRUE(server->CheckAudioSessionStrategy(strategy));
108 }
109
110 /**
111 * @tc.name : Test AudioPolicyServer.
112 * @tc.number: AudioPolicyServer_002
113 * @tc.desc : Test CheckAudioSessionStrategy.
114 */
115 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_002, TestSize.Level1)
116 {
117 AudioSessionStrategy strategy;
118 auto policyServerTest = GetPolicyServerUnitTest();
119 int32_t systemAbilityId = 3009;
120 bool runOnCreate = false;
121 sptr<AudioPolicyServer> server = sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
122
123 strategy.concurrencyMode = static_cast<AudioConcurrencyMode>(999); // Invalid mode
124 EXPECT_FALSE(server->CheckAudioSessionStrategy(strategy));
125 }
126
127 /**
128 * @tc.name : Test AudioPolicyServer.
129 * @tc.number: AudioPolicyServer_003
130 * @tc.desc : Test SetAudioManagerInterruptCallback.
131 */
132 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_003, TestSize.Level1)
133 {
134 auto policyServerTest = GetPolicyServerUnitTest();
135 int32_t systemAbilityId = 3009;
136 bool runOnCreate = false;
137 sptr<AudioPolicyServer> server = sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
138
139 server->interruptService_ = nullptr;
140 int32_t result = server->SetAudioManagerInterruptCallback(0, sptr<RemoteObjectTestStub>::MakeSptr());
141 EXPECT_EQ(result, ERR_UNKNOWN);
142 }
143
144 /**
145 * @tc.name : Test AudioPolicyServer.
146 * @tc.number: AudioPolicyServer_004
147 * @tc.desc : Test UnsetAudioManagerInterruptCallback.
148 */
149 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_004, TestSize.Level1)
150 {
151 auto policyServerTest = GetPolicyServerUnitTest();
152 int32_t systemAbilityId = 3009;
153 bool runOnCreate = false;
154 sptr<AudioPolicyServer> server = sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
155
156 server->interruptService_ = nullptr;
157 int32_t result = server->UnsetAudioManagerInterruptCallback(0);
158 EXPECT_EQ(result, ERR_UNKNOWN);
159 }
160
161 /**
162 * @tc.name : Test AudioPolicyServer.
163 * @tc.number: AudioPolicyServer_005
164 * @tc.desc : Test OnAudioParameterChange.
165 */
166 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_005, TestSize.Level1)
167 {
168 auto policyServerTest = GetPolicyServerUnitTest();
169 int32_t systemAbilityId = 3009;
170 bool runOnCreate = false;
171 sptr<AudioPolicyServer> server = sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
172
173 std::string networkId;
174 AudioParamKey key = static_cast<AudioParamKey>(100);
175 std::string condition;
176 std::string value;
177 auto callback = std::make_shared<AudioPolicyServer::RemoteParameterCallback>(server);
178 callback->OnAudioParameterChange(networkId, key, condition, value);
179 }
180
181 /**
182 * @tc.name : Test AudioPolicyServer.
183 * @tc.number: AudioPolicyServer_006
184 * @tc.desc : Test OnAudioParameterChange.
185 */
186 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_006, TestSize.Level1)
187 {
188 auto policyServerTest = GetPolicyServerUnitTest();
189 int32_t systemAbilityId = 3009;
190 bool runOnCreate = false;
191 sptr<AudioPolicyServer> server = sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
192
193 std::string networkId;
194 AudioParamKey key = PARAM_KEY_STATE;
195 std::string condition;
196 std::string value;
197 auto callback = std::make_shared<AudioPolicyServer::RemoteParameterCallback>(server);
198 callback->OnAudioParameterChange(networkId, key, condition, value);
199 }
200
201 /**
202 * @tc.name : Test AudioPolicyServer.
203 * @tc.number: AudioPolicyServer_007
204 * @tc.desc : Test ReconfigureAudioChannel.
205 */
206 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_007, TestSize.Level1)
207 {
208 #ifdef AUDIO_BUILD_VARIANT_ROOT
209 #undef AUDIO_BUILD_VARIANT_ROOT
210 #endif
211 auto policyServerTest = GetPolicyServerUnitTest();
212 int32_t systemAbilityId = 3009;
213 bool runOnCreate = false;
214 sptr<AudioPolicyServer> server = sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
215 uint32_t count = 2;
216 DeviceType deviceType = DeviceType::DEVICE_TYPE_DEFAULT;
217 int32_t result = server->ReconfigureAudioChannel(count, deviceType);
218 EXPECT_NE(result, ERR_PERMISSION_DENIED);
219 }
220
221 /**
222 * @tc.name : Test AudioPolicyServer.
223 * @tc.number: AudioPolicyServer_008
224 * @tc.desc : Test ArgInfoDump.
225 */
226 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_008, TestSize.Level1)
227 {
228 auto policyServerTest = GetPolicyServerUnitTest();
229 int32_t systemAbilityId = 3009;
230 bool runOnCreate = false;
231 sptr<AudioPolicyServer> server = sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
232
233 std::string dumpString;
234 std::queue<std::u16string> argQue;
235 argQue.push(u"invalidParam");
236 server->ArgInfoDump(dumpString, argQue);
237 EXPECT_EQ(dumpString.find("Please input correct param:\n"), 0);
238 }
239
240 /**
241 * @tc.name : Test AudioPolicyServer.
242 * @tc.number: AudioPolicyServer_009
243 * @tc.desc : Test DeactivateAudioInterrupt.
244 */
245 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_009, TestSize.Level1)
246 {
247 auto policyServerTest = GetPolicyServerUnitTest();
248 int32_t systemAbilityId = 3009;
249 bool runOnCreate = false;
250 sptr<AudioPolicyServer> server = sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
251
252 AudioInterrupt audioInterrupt;
253 int32_t zoneID = 456;
254 int32_t result = server->DeactivateAudioInterrupt(audioInterrupt, zoneID);
255 EXPECT_EQ(result, ERR_UNKNOWN);
256 }
257
258 /**
259 * @tc.name : Test AudioPolicyServer.
260 * @tc.number: AudioPolicyServer_010
261 * @tc.desc : Test OnAudioParameterChange.
262 */
263 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_010, TestSize.Level1)
264 {
265 auto policyServerTest = GetPolicyServerUnitTest();
266 int32_t systemAbilityId = 3009;
267 bool runOnCreate = false;
268 sptr<AudioPolicyServer> server = sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
269
270 std::string networkId;
271 AudioParamKey key = VOLUME;
272 std::string condition;
273 std::string value;
274
275 auto callback = std::make_shared<AudioPolicyServer::RemoteParameterCallback>(server);
276 callback->OnAudioParameterChange(networkId, key, condition, value);
277 }
278
279 /**
280 * @tc.name : Test AudioPolicyServer.
281 * @tc.number: AudioPolicyServer_011
282 * @tc.desc : Test OnAudioParameterChange.
283 */
284 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_011, TestSize.Level1)
285 {
286 auto policyServerTest = GetPolicyServerUnitTest();
287 int32_t systemAbilityId = 3009;
288 bool runOnCreate = false;
289 sptr<AudioPolicyServer> server = sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
290
291 std::string networkId;
292 AudioParamKey key = INTERRUPT;
293 std::string condition;
294 std::string value;
295
296 auto callback = std::make_shared<AudioPolicyServer::RemoteParameterCallback>(server);
297 callback->OnAudioParameterChange(networkId, key, condition, value);
298 }
299
300 /**
301 * @tc.name : Test AudioPolicyServer.
302 * @tc.number: AudioPolicyServer_012
303 * @tc.desc : Test ActivateAudioSession.
304 */
305 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_012, TestSize.Level1)
306 {
307 AudioSessionStrategy strategy;
308 auto policyServerTest = GetPolicyServerUnitTest();
309 EXPECT_EQ(policyServerTest->ActivateAudioSession(strategy), SUCCESS);
310 }
311
312 /**
313 * @tc.name : Test AudioPolicyServer.
314 * @tc.number: AudioPolicyServer_013
315 * @tc.desc : Test GetStreamInFocus.
316 */
317 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_013, TestSize.Level1)
318 {
319 auto policyServerTest = GetPolicyServerUnitTest();
320 int32_t zoneID = 456;
321 AudioStreamType result = policyServerTest->GetStreamInFocus(zoneID);
322 EXPECT_EQ(result, STREAM_MUSIC);
323 }
324
325 /**
326 * @tc.name : Test AudioPolicyServer.
327 * @tc.number: AudioPolicyServer_014
328 * @tc.desc : Test OnRemoveSystemAbility.
329 */
330 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_014, TestSize.Level1)
331 {
332 auto policyServerTest = GetPolicyServerUnitTest();
333 int32_t systemAbilityId = AVSESSION_SERVICE_ID;
334 std::string deviceId = "132456";
335 policyServerTest->OnRemoveSystemAbility(systemAbilityId, deviceId);
336 }
337
338 /**
339 * @tc.name : Test AudioPolicyServer.
340 * @tc.number: AudioPolicyServer_015
341 * @tc.desc : Test InitMicrophoneMute.
342 */
343 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_015, TestSize.Level1)
344 {
345 auto policyServerTest = GetPolicyServerUnitTest();
346 policyServerTest->isInitMuteState_ = true;
347 policyServerTest->InitMicrophoneMute();
348 }
349
350 /**
351 * @tc.name : Test AudioPolicyServer.
352 * @tc.number: AudioPolicyServer_016
353 * @tc.desc : Test ActivateAudioInterrupt.
354 */
355 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_016, TestSize.Level1)
356 {
357 auto policyServerTest = GetPolicyServerUnitTest();
358 AudioInterrupt audioInterrupt;
359 int32_t zoneID = 456;
360 int32_t result = policyServerTest->ActivateAudioInterrupt(audioInterrupt, zoneID);
361 EXPECT_EQ(result, ERR_FOCUS_DENIED);
362 }
363
364 /**
365 * @tc.name : Test AudioPolicyServer.
366 * @tc.number: AudioPolicyServer_017
367 * @tc.desc : Test SetRingerModeLegacy.
368 */
369 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_017, TestSize.Level1)
370 {
371 auto policyServerTest = GetPolicyServerUnitTest();
372
373 AudioRingerMode audioRingerMode = AudioRingerMode::RINGER_MODE_NORMAL;
374 int32_t result = policyServerTest->SetRingerModeLegacy(audioRingerMode);
375 EXPECT_EQ(result, 0);
376 }
377
378 /**
379 * @tc.name : Test AudioPolicyServer.
380 * @tc.number: AudioPolicyServer_018
381 * @tc.desc : Test AudioPolicyServer::LoadSplitModule.
382 */
383 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_018, TestSize.Level1)
384 {
385 int32_t systemAbilityId = 3009;
386 bool runOnCreate = false;
387 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
388
389 EXPECT_NE(ptrAudioPolicyServer, nullptr);
390
391 const std::string splitArgs = "";
392 const std::string networkId = "";
393 ptrAudioPolicyServer->LoadSplitModule(splitArgs, networkId);
394 }
395
396 /**
397 * @tc.name : Test AudioPolicyServer.
398 * @tc.number: AudioPolicyServer_019
399 * @tc.desc : Test AudioPolicyServer::IsAudioSessionActivated
400 */
401 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_019, TestSize.Level1)
402 {
403 int32_t systemAbilityId = 3009;
404 bool runOnCreate = false;
405 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
406
407 EXPECT_NE(ptrAudioPolicyServer, nullptr);
408
409 ptrAudioPolicyServer->interruptService_ = std::make_shared<AudioInterruptService>();
410 ptrAudioPolicyServer->IsAudioSessionActivated();
411 }
412
413 /**
414 * @tc.name : Test AudioPolicyServer.
415 * @tc.number: AudioPolicyServer_020
416 * @tc.desc : Test AudioPolicyServer::IsAudioSessionActivated
417 */
418 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_020, TestSize.Level1)
419 {
420 int32_t systemAbilityId = 3009;
421 bool runOnCreate = false;
422 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
423
424 EXPECT_NE(ptrAudioPolicyServer, nullptr);
425
426 ptrAudioPolicyServer->interruptService_ = nullptr;
427 ptrAudioPolicyServer->IsAudioSessionActivated();
428 }
429
430 /**
431 * @tc.name : Test AudioPolicyServer.
432 * @tc.number: AudioPolicyServer_021
433 * @tc.desc : Test AudioPolicyServer::DeactivateAudioSession
434 */
435 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_021, TestSize.Level1)
436 {
437 int32_t systemAbilityId = 3009;
438 bool runOnCreate = false;
439 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
440
441 EXPECT_NE(ptrAudioPolicyServer, nullptr);
442
443 ptrAudioPolicyServer->interruptService_ = nullptr;
444 ptrAudioPolicyServer->DeactivateAudioSession();
445 }
446
447 /**
448 * @tc.name : Test AudioPolicyServer.
449 * @tc.number: AudioPolicyServer_022
450 * @tc.desc : Test AudioPolicyServer::DeactivateAudioSession
451 */
452 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_022, TestSize.Level1)
453 {
454 int32_t systemAbilityId = 3009;
455 bool runOnCreate = false;
456 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
457
458 EXPECT_NE(ptrAudioPolicyServer, nullptr);
459
460 ptrAudioPolicyServer->interruptService_ = std::make_shared<AudioInterruptService>();
461 ptrAudioPolicyServer->DeactivateAudioSession();
462 }
463
464 /**
465 * @tc.name : Test AudioPolicyServer.
466 * @tc.number: AudioPolicyServer_023
467 * @tc.desc : Test AudioPolicyServer::ActivateAudioSession
468 */
469 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_023, TestSize.Level1)
470 {
471 int32_t systemAbilityId = 3009;
472 bool runOnCreate = false;
473 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
474
475 EXPECT_NE(ptrAudioPolicyServer, nullptr);
476
477 const AudioSessionStrategy strategy;
478 ptrAudioPolicyServer->interruptService_ = std::make_shared<AudioInterruptService>();
479 auto ret = ptrAudioPolicyServer->ActivateAudioSession(strategy);
480
481 EXPECT_EQ(ret, ERR_UNKNOWN);
482 }
483
484 /**
485 * @tc.name : Test AudioPolicyServer.
486 * @tc.number: AudioPolicyServer_024
487 * @tc.desc : Test AudioPolicyServer::ActivateAudioSession
488 */
489 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_024, TestSize.Level1)
490 {
491 int32_t systemAbilityId = 3009;
492 bool runOnCreate = false;
493 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
494
495 EXPECT_NE(ptrAudioPolicyServer, nullptr);
496
497 const AudioSessionStrategy strategy;
498 ptrAudioPolicyServer->interruptService_ = nullptr;
499 auto ret = ptrAudioPolicyServer->ActivateAudioSession(strategy);
500
501 EXPECT_EQ(ret, ERR_UNKNOWN);
502 }
503
504 /**
505 * @tc.name : Test AudioPolicyServer.
506 * @tc.number: AudioPolicyServer_025
507 * @tc.desc : Test AudioPolicyServer::ActivateAudioSession
508 */
509 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_025, TestSize.Level1)
510 {
511 int32_t systemAbilityId = 3009;
512 bool runOnCreate = false;
513 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
514
515 EXPECT_NE(ptrAudioPolicyServer, nullptr);
516
517 const AudioSessionStrategy strategy = {AudioConcurrencyMode::SILENT};
518 ptrAudioPolicyServer->interruptService_ = std::make_shared<AudioInterruptService>();
519
520 auto ret = ptrAudioPolicyServer->ActivateAudioSession(strategy);
521
522 EXPECT_EQ(ret, ERR_INVALID_PARAM);
523 }
524
525 /**
526 * @tc.name : Test AudioPolicyServer.
527 * @tc.number: AudioPolicyServer_026
528 * @tc.desc : Test AudioPolicyServer::ActivateAudioSession
529 */
530 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_026, TestSize.Level1)
531 {
532 int32_t systemAbilityId = 3009;
533 bool runOnCreate = false;
534 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
535
536 EXPECT_NE(ptrAudioPolicyServer, nullptr);
537
538 const AudioSessionStrategy strategy = {AudioConcurrencyMode::DEFAULT};
539 ptrAudioPolicyServer->interruptService_ = std::make_shared<AudioInterruptService>();
540
541 auto ret = ptrAudioPolicyServer->ActivateAudioSession(strategy);
542
543 EXPECT_EQ(ret, ERR_UNKNOWN);
544 }
545
546 /**
547 * @tc.name : Test AudioPolicyServer.
548 * @tc.number: AudioPolicyServer_027
549 * @tc.desc : Test AudioPolicyServer::InjectInterruption
550 */
551 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_027, TestSize.Level1)
552 {
553 int32_t systemAbilityId = 3009;
554 bool runOnCreate = false;
555 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
556
557 EXPECT_NE(ptrAudioPolicyServer, nullptr);
558
559 const std::string networkId = "";
560 InterruptEvent event;
561
562 auto ret = ptrAudioPolicyServer->InjectInterruption(networkId, event);
563
564 EXPECT_EQ(ret, ERROR);
565 }
566
567 /**
568 * @tc.name : Test AudioPolicyServer.
569 * @tc.number: AudioPolicyServer_028
570 * @tc.desc : Test AudioPolicyServer::UnsetAudioDeviceAnahsCallback
571 */
572 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_028, TestSize.Level1)
573 {
574 int32_t systemAbilityId = 3009;
575 bool runOnCreate = false;
576 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
577
578 EXPECT_NE(ptrAudioPolicyServer, nullptr);
579
580 auto ret = ptrAudioPolicyServer->UnsetAudioDeviceAnahsCallback();
581
582 EXPECT_EQ(ret, ERROR);
583 }
584
585 /**
586 * @tc.name : Test AudioPolicyServer.
587 * @tc.number: AudioPolicyServer_029
588 * @tc.desc : Test AudioPolicyServer::TriggerFetchDevice
589 */
590 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_029, TestSize.Level1)
591 {
592 int32_t systemAbilityId = 3009;
593 bool runOnCreate = false;
594 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
595
596 EXPECT_NE(ptrAudioPolicyServer, nullptr);
597
598 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::NEW_DEVICE_AVAILABLE;
599 auto ret = ptrAudioPolicyServer->TriggerFetchDevice(reason);
600
601 EXPECT_EQ(ret, ERROR);
602 }
603
604 /**
605 * @tc.name : Test AudioPolicyServer.
606 * @tc.number: AudioPolicyServer_030
607 * @tc.desc : Test AudioPolicyServer::UnsetAudioDeviceRefinerCallback
608 */
609 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_030, TestSize.Level1)
610 {
611 int32_t systemAbilityId = 3009;
612 bool runOnCreate = false;
613 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
614
615 EXPECT_NE(ptrAudioPolicyServer, nullptr);
616
617 auto ret = ptrAudioPolicyServer->UnsetAudioDeviceRefinerCallback();
618
619 EXPECT_EQ(ret, ERROR);
620 }
621
622 /**
623 * @tc.name : Test AudioPolicyServer.
624 * @tc.number: AudioPolicyServer_031
625 * @tc.desc : Test AudioPolicyServer::SetHighResolutionExist
626 */
627 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_031, TestSize.Level1)
628 {
629 int32_t systemAbilityId = 3009;
630 bool runOnCreate = false;
631 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
632
633 EXPECT_NE(ptrAudioPolicyServer, nullptr);
634
635 bool highResExist = true;
636 auto ret = ptrAudioPolicyServer->SetHighResolutionExist(highResExist);
637
638 EXPECT_EQ(ret, SUCCESS);
639 }
640
641 /**
642 * @tc.name : Test AudioPolicyServer.
643 * @tc.number: AudioPolicyServer_032
644 * @tc.desc : Test AudioPolicyServer::IsHighResolutionExist
645 */
646 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_032, TestSize.Level1)
647 {
648 int32_t systemAbilityId = 3009;
649 bool runOnCreate = false;
650 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
651
652 EXPECT_NE(ptrAudioPolicyServer, nullptr);
653
654 auto ret = ptrAudioPolicyServer->IsHighResolutionExist();
655
656 EXPECT_EQ(ret, false);
657 }
658
659 /**
660 * @tc.name : Test AudioPolicyServer.
661 * @tc.number: AudioPolicyServer_033
662 * @tc.desc : Test AudioPolicyServer::DisableSafeMediaVolume
663 */
664 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_033, TestSize.Level1)
665 {
666 int32_t systemAbilityId = 3009;
667 bool runOnCreate = false;
668 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
669
670 EXPECT_NE(ptrAudioPolicyServer, nullptr);
671
672 auto ret = ptrAudioPolicyServer->DisableSafeMediaVolume();
673
674 EXPECT_EQ(ret, SUCCESS);
675 }
676
677 /**
678 * @tc.name : Test AudioPolicyServer.
679 * @tc.number: AudioPolicyServer_034
680 * @tc.desc : Test AudioPolicyServer::SetSpatializationSceneType
681 */
682 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_034, TestSize.Level1)
683 {
684 int32_t systemAbilityId = 3009;
685 bool runOnCreate = false;
686 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
687
688 EXPECT_NE(ptrAudioPolicyServer, nullptr);
689
690 const AudioSpatializationSceneType spatializationSceneType =
691 AudioSpatializationSceneType::SPATIALIZATION_SCENE_TYPE_DEFAULT;
692 auto ret = ptrAudioPolicyServer->SetSpatializationSceneType(spatializationSceneType);
693
694 EXPECT_EQ(ret, OPEN_PORT_FAILURE);
695 }
696
697 /**
698 * @tc.name : Test AudioPolicyServer.
699 * @tc.number: AudioPolicyServer_035
700 * @tc.desc : Test AudioPolicyServer::GetSpatializationSceneType
701 */
702 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_035, TestSize.Level1)
703 {
704 int32_t systemAbilityId = 3009;
705 bool runOnCreate = false;
706 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
707
708 EXPECT_NE(ptrAudioPolicyServer, nullptr);
709
710 auto ret = ptrAudioPolicyServer->GetSpatializationSceneType();
711
712 EXPECT_EQ(ret, SUCCESS);
713 }
714
715 /**
716 * @tc.name : Test AudioPolicyServer.
717 * @tc.number: AudioPolicyServer_036
718 * @tc.desc : Test AudioPolicyServer::GetSpatializationSceneType
719 */
720 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_036, TestSize.Level1)
721 {
722 auto ptrAudioPolicyServer = GetPolicyServerUnitTest();
723
724 EXPECT_NE(ptrAudioPolicyServer, nullptr);
725
726 ptrAudioPolicyServer->GetActiveBluetoothDevice();
727 }
728
729 /**
730 * @tc.name : Test AudioPolicyServer.
731 * @tc.number: AudioPolicyServer_037
732 * @tc.desc : Test AudioPolicyServer::SetCallDeviceActive
733 */
734 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_037, TestSize.Level1)
735 {
736 int32_t systemAbilityId = 3009;
737 bool runOnCreate = false;
738 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
739
740 EXPECT_NE(ptrAudioPolicyServer, nullptr);
741
742 InternalDeviceType deviceType = DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP_IN;
743 bool active = true;
744 std::string address = "";
745 auto ret = ptrAudioPolicyServer->SetCallDeviceActive(deviceType, active, address);
746
747 EXPECT_EQ(ret, ERR_NOT_SUPPORTED);
748 }
749
750 /**
751 * @tc.name : Test AudioPolicyServer.
752 * @tc.number: AudioPolicyServer_038
753 * @tc.desc : Test AudioPolicyServer::SetCallDeviceActive
754 */
755 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_038, TestSize.Level1)
756 {
757 int32_t systemAbilityId = 3009;
758 bool runOnCreate = false;
759 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
760
761 EXPECT_NE(ptrAudioPolicyServer, nullptr);
762
763 InternalDeviceType deviceType = DeviceType::DEVICE_TYPE_EARPIECE;
764 bool active = true;
765 std::string address = "";
766 auto ret = ptrAudioPolicyServer->SetCallDeviceActive(deviceType, active, address);
767
768 EXPECT_NE(ret, ERR_SYSTEM_PERMISSION_DENIED);
769 }
770
771 /**
772 * @tc.name : Test AudioPolicyServer.
773 * @tc.number: AudioPolicyServer_039
774 * @tc.desc : Test AudioPolicyServer::ReleaseAudioInterruptZone
775 */
776 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_039, TestSize.Level1)
777 {
778 int32_t systemAbilityId = 3009;
779 bool runOnCreate = false;
780 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
781
782 EXPECT_NE(ptrAudioPolicyServer, nullptr);
783
784 const int32_t zoneID = 0;
785 ptrAudioPolicyServer->interruptService_ = std::make_shared<AudioInterruptService>();
786 auto ret = ptrAudioPolicyServer->ReleaseAudioInterruptZone(zoneID);
787
788 EXPECT_NE(ret, ERR_INVALID_PARAM);
789 }
790
791 /**
792 * @tc.name : Test AudioPolicyServer.
793 * @tc.number: AudioPolicyServer_040
794 * @tc.desc : Test AudioPolicyServer::ReleaseAudioInterruptZone
795 */
796 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_040, TestSize.Level1)
797 {
798 int32_t systemAbilityId = 3009;
799 bool runOnCreate = false;
800 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
801
802 EXPECT_NE(ptrAudioPolicyServer, nullptr);
803
804 const int32_t zoneID = 0;
805 ptrAudioPolicyServer->interruptService_ = nullptr;
806 auto ret = ptrAudioPolicyServer->ReleaseAudioInterruptZone(zoneID);
807
808 EXPECT_EQ(ret, ERR_UNKNOWN);
809 }
810
811 /**
812 * @tc.name : Test AudioPolicyServer.
813 * @tc.number: SetSystemVolumeLevelInternal_001
814 * @tc.desc : Test AudioPolicyServer::SetSystemVolumeLevelInternal
815 */
816 HWTEST(AudioPolicyUnitTest, SetSystemVolumeLevelInternal_001, TestSize.Level1)
817 {
818 AUDIO_INFO_LOG("SetSystemVolumeLevelInternal_001 start");
819 int32_t systemAbilityId = 3009;
820 bool runOnCreate = false;
821 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
822 ASSERT_NE(ptrAudioPolicyServer, nullptr);
823
824 int32_t volumeLevel = 5;
825 bool isUpdateUi = true;
826 auto ret = ptrAudioPolicyServer->SetSystemVolumeLevelInternal(STREAM_VOICE_CALL, volumeLevel, isUpdateUi);
827 EXPECT_EQ(ret, SUCCESS);
828 }
829
830 /**
831 * @tc.name : Test AudioPolicyServer.
832 * @tc.number: SetSystemVolumeLevelInternal_002
833 * @tc.desc : Test AudioPolicyServer::SetSystemVolumeLevelInternal
834 */
835 HWTEST(AudioPolicyUnitTest, SetSystemVolumeLevelInternal_002, TestSize.Level1)
836 {
837 AUDIO_INFO_LOG("SetSystemVolumeLevelInternal_002 start");
838 int32_t systemAbilityId = 3009;
839 bool runOnCreate = false;
840 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
841 ASSERT_NE(ptrAudioPolicyServer, nullptr);
842
843 int32_t volumeLevel = 5;
844 bool isUpdateUi = true;
845 VolumeUtils::SetPCVolumeEnable(true);
846 auto ret = ptrAudioPolicyServer->SetSystemVolumeLevelInternal(STREAM_VOICE_CALL, volumeLevel, isUpdateUi);
847 VolumeUtils::SetPCVolumeEnable(false);
848 EXPECT_EQ(ret, SUCCESS);
849 }
850
851 /**
852 * @tc.name : Test AudioPolicyServer.
853 * @tc.number: AudioPolicyServer_041
854 * @tc.desc : Test AudioPolicyServer::GetSystemActiveVolumeType
855 */
856 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_041, TestSize.Level1)
857 {
858 int32_t systemAbilityId = 3009;
859 bool runOnCreate = false;
860 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
861
862 EXPECT_NE(ptrAudioPolicyServer, nullptr);
863
864 AudioStreamType streamType;
865 int32_t clientUid = 0;
866 streamType = ptrAudioPolicyServer->GetSystemActiveVolumeType(clientUid);
867 EXPECT_EQ(streamType, STREAM_MUSIC);
868 clientUid = 1;
869 streamType = ptrAudioPolicyServer->GetSystemActiveVolumeType(clientUid);
870 EXPECT_EQ(streamType, STREAM_MUSIC);
871 }
872
873 /**
874 * @tc.name : Test AudioPolicyServer.
875 * @tc.number: AudioPolicyServer_042
876 * @tc.desc : Test AudioPolicyServer::GetSystemVolumeLevelNoMuteState
877 */
878 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_042, TestSize.Level1)
879 {
880 int32_t systemAbilityId = 3009;
881 bool runOnCreate = false;
882 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
883
884 EXPECT_NE(ptrAudioPolicyServer, nullptr);
885
886 AudioStreamType streamType = STREAM_ALL;
887 int res = ptrAudioPolicyServer->GetSystemVolumeLevelNoMuteState(streamType);
888 EXPECT_EQ(res, 5);
889 streamType = STREAM_MUSIC;
890 res = ptrAudioPolicyServer->GetSystemVolumeLevelNoMuteState(streamType);
891 EXPECT_EQ(res, 5);
892 }
893
894 /**
895 * @tc.name : Test AudioPolicyServer.
896 * @tc.number: AudioPolicyServer_043
897 * @tc.desc : Test AudioPolicyServer::GetStreamMute
898 */
899 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_043, TestSize.Level1)
900 {
901 int32_t systemAbilityId = 3009;
902 bool runOnCreate = false;
903 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
904
905 EXPECT_NE(ptrAudioPolicyServer, nullptr);
906
907 AudioStreamType streamType = STREAM_RING;
908 bool ret = ptrAudioPolicyServer->GetStreamMute(streamType);
909 EXPECT_EQ(ret, false);
910 streamType = STREAM_VOICE_RING;
911 ret = ptrAudioPolicyServer->GetStreamMute(streamType);
912 EXPECT_EQ(ret, false);
913 streamType = STREAM_MUSIC;
914 ret = ptrAudioPolicyServer->GetStreamMute(streamType);
915 EXPECT_EQ(ret, false);
916 }
917
918 /**
919 * @tc.name : Test AudioPolicyServer.
920 * @tc.number: AudioPolicyServer_044
921 * @tc.desc : Test AudioPolicyServer::GetPreferredOutputStreamType
922 */
923 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_044, TestSize.Level1)
924 {
925 auto ptrAudioPolicyServer = GetPolicyServerUnitTest();
926
927 EXPECT_NE(ptrAudioPolicyServer, nullptr);
928
929 AudioRendererInfo rendererInfo;
930 int32_t ret = ptrAudioPolicyServer->GetPreferredOutputStreamType(rendererInfo);
931 EXPECT_EQ(ret, 0);
932 ptrAudioPolicyServer->audioPolicyService_.isFastControlled_ = true;
933 ret = ptrAudioPolicyServer->GetPreferredOutputStreamType(rendererInfo);
934 EXPECT_EQ(ret, 0);
935 rendererInfo.rendererFlags = AUDIO_FLAG_MMAP;
936 ret = ptrAudioPolicyServer->GetPreferredOutputStreamType(rendererInfo);
937 EXPECT_EQ(ret, 0);
938 }
939
940 /**
941 * @tc.name : Test AudioPolicyServer.
942 * @tc.number: AudioPolicyServer_045
943 * @tc.desc : Test AudioPolicyServer::IsAllowedPlayback
944 */
945 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_045, TestSize.Level1)
946 {
947 int32_t systemAbilityId = 3009;
948 bool runOnCreate = false;
949 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
950
951 EXPECT_NE(ptrAudioPolicyServer, nullptr);
952
953 int32_t uid = 0;
954 int32_t pid = 0;
955 bool ret = ptrAudioPolicyServer->IsAllowedPlayback(uid, pid);
956 EXPECT_EQ(ret, false);
957 }
958
959 /**
960 * @tc.name : Test TranslateErrorCodeer.
961 * @tc.number: TranslateErrorCode_001
962 * @tc.desc : Test TranslateErrorCodeer.
963 */
964 HWTEST(AudioPolicyUnitTest, TranslateErrorCode_001, TestSize.Level1)
965 {
966 int32_t systemAbilityId = 3009;
967 bool runOnCreate = false;
968 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
969 EXPECT_NE(ptrAudioPolicyServer, nullptr);
970
971 int32_t result = ERR_INVALID_PARAM;
972 uint32_t resultForMonitor = ERR_SUBSCRIBE_INVALID_PARAM;
973 uint32_t actual = ptrAudioPolicyServer->TranslateErrorCode(result);
974 EXPECT_EQ(resultForMonitor, actual);
975
976 result = ERR_NULL_POINTER;
977 resultForMonitor = ERR_SUBSCRIBE_KEY_OPTION_NULL;
978 actual = ptrAudioPolicyServer->TranslateErrorCode(result);
979 EXPECT_EQ(resultForMonitor, actual);
980
981 result = ERR_MMI_CREATION;
982 resultForMonitor = ERR_SUBSCRIBE_MMI_NULL;
983 actual = ptrAudioPolicyServer->TranslateErrorCode(result);
984 EXPECT_EQ(resultForMonitor, actual);
985
986 result = ERR_MMI_SUBSCRIBE;
987 resultForMonitor = ERR_MODE_SUBSCRIBE;
988 actual = ptrAudioPolicyServer->TranslateErrorCode(result);
989 EXPECT_EQ(resultForMonitor, actual);
990
991 result = 99999;
992 resultForMonitor = 0;
993 actual = ptrAudioPolicyServer->TranslateErrorCode(result);
994 EXPECT_EQ(resultForMonitor, actual);
995 }
996
997 /**
998 * @tc.name : Test IsVolumeTypeValid.
999 * @tc.number: IsVolumeTypeValid_001
1000 * @tc.desc : Test AudioPolicyServer::IsVolumeTypeValid
1001 */
1002 HWTEST(AudioPolicyUnitTest, IsVolumeTypeValid_001, TestSize.Level1)
1003 {
1004 int32_t systemAbilityId = 3009;
1005 bool runOnCreate = false;
1006 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1007
1008 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1009 bool result = ptrAudioPolicyServer->IsVolumeTypeValid(static_cast<AudioStreamType>(-1));
1010 EXPECT_FALSE(result);
1011 }
1012
1013 /**
1014 * @tc.name : Test UpdateMuteStateAccordingToVolLevel.
1015 * @tc.number: UpdateMuteStateAccordingToVolLevel_001
1016 * @tc.desc : Test AudioPolicyServer::UpdateMuteStateAccordingToVolLevel
1017 */
1018 HWTEST(AudioPolicyUnitTest, UpdateMuteStateAccordingToVolLevel_001, TestSize.Level1)
1019 {
1020 int32_t systemAbilityId = 3009;
1021 bool runOnCreate = false;
1022 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1023
1024 AudioStreamType streamType = AudioStreamType::STREAM_MUSIC;
1025 int32_t volumeLevel = 1;
1026 bool mute = true;
1027 ptrAudioPolicyServer->UpdateMuteStateAccordingToVolLevel(streamType, volumeLevel, mute);
1028 }
1029
1030 /**
1031 * @tc.name : Test UpdateMuteStateAccordingToVolLevel.
1032 * @tc.number: UpdateMuteStateAccordingToVolLevel_002
1033 * @tc.desc : Test AudioPolicyServer::UpdateMuteStateAccordingToVolLevel
1034 */
1035 HWTEST(AudioPolicyUnitTest, UpdateMuteStateAccordingToVolLevel_002, TestSize.Level1)
1036 {
1037 int32_t systemAbilityId = 3009;
1038 bool runOnCreate = false;
1039 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1040
1041 AudioStreamType streamType = AudioStreamType::STREAM_MUSIC;
1042 int32_t volumeLevel = 0;
1043 bool mute = false;
1044 ptrAudioPolicyServer->UpdateMuteStateAccordingToVolLevel(streamType, volumeLevel, mute);
1045 }
1046
1047 /**
1048 * @tc.name : Test UpdateMuteStateAccordingToVolLevel.
1049 * @tc.number: UpdateMuteStateAccordingToVolLevel_003
1050 * @tc.desc : Test AudioPolicyServer::UpdateMuteStateAccordingToVolLevel
1051 */
1052 HWTEST(AudioPolicyUnitTest, UpdateMuteStateAccordingToVolLevel_003, TestSize.Level1)
1053 {
1054 int32_t systemAbilityId = 3009;
1055 bool runOnCreate = false;
1056 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1057
1058 AudioStreamType streamType = AudioStreamType::STREAM_SYSTEM;
1059 int32_t volumeLevel = 1;
1060 bool mute = false;
1061 ptrAudioPolicyServer->UpdateMuteStateAccordingToVolLevel(streamType, volumeLevel, mute);
1062 }
1063
1064 /**
1065 * @tc.name : Test ChangeVolumeOnVoiceAssistant.
1066 * @tc.number: ChangeVolumeOnVoiceAssistant_001
1067 * @tc.desc : Test AudioPolicyServer::ChangeVolumeOnVoiceAssistant
1068 */
1069 HWTEST(AudioPolicyUnitTest, ChangeVolumeOnVoiceAssistant_001, TestSize.Level1)
1070 {
1071 int32_t systemAbilityId = 3009;
1072 bool runOnCreate = false;
1073 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1074 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1075 AudioStreamType streamInFocus = AudioStreamType::STREAM_VOICE_ASSISTANT;
1076 ptrAudioPolicyServer->ChangeVolumeOnVoiceAssistant(streamInFocus);
1077 }
1078
1079 /**
1080 * @tc.name : Test MaxOrMinVolumeOption.
1081 * @tc.number: MaxOrMinVolumeOption_001
1082 * @tc.desc : Test AudioPolicyServer::MaxOrMinVolumeOption
1083 */
1084 #ifdef FEATURE_MULTIMODALINPUT_INPUT
1085 HWTEST(AudioPolicyUnitTest, MaxOrMinVolumeOption_001, TestSize.Level1)
1086 {
1087 int32_t systemAbilityId = 3009;
1088 bool runOnCreate = false;
1089 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1090 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1091 int32_t volLevel = 20;
1092 int32_t keyType = OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP;
1093 AudioStreamType streamInFocus = AudioStreamType::STREAM_MUSIC;
1094 bool result = ptrAudioPolicyServer->MaxOrMinVolumeOption(volLevel, keyType, streamInFocus);
1095 EXPECT_FALSE(result);
1096 }
1097
1098 /**
1099 * @tc.name : Test MaxOrMinVolumeOption.
1100 * @tc.number: MaxOrMinVolumeOption_002
1101 * @tc.desc : Test AudioPolicyServer::MaxOrMinVolumeOption
1102 */
1103 HWTEST(AudioPolicyUnitTest, MaxOrMinVolumeOption_002, TestSize.Level1)
1104 {
1105 int32_t systemAbilityId = 3009;
1106 bool runOnCreate = false;
1107 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1108 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1109 int32_t volLevel = 0;
1110 int32_t keyType = OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP;
1111 AudioStreamType streamInFocus = AudioStreamType::STREAM_MUSIC;
1112 bool result = ptrAudioPolicyServer->MaxOrMinVolumeOption(volLevel, keyType, streamInFocus);
1113 EXPECT_FALSE(result);
1114 }
1115 #endif
1116
1117 /**
1118 * @tc.name : Test IsVolumeLevelValid.
1119 * @tc.number: IsVolumeLevelValid_001
1120 * @tc.desc : Test AudioPolicyServer::IsVolumeLevelValid
1121 */
1122 HWTEST(AudioPolicyUnitTest, IsVolumeLevelValid_001, TestSize.Level1)
1123 {
1124 int32_t systemAbilityId = 3009;
1125 bool runOnCreate = false;
1126 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1127 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1128 AudioStreamType streamType = AudioStreamType::STREAM_MUSIC;
1129 int32_t volumeLevel = 20;
1130 bool result = ptrAudioPolicyServer->IsVolumeLevelValid(streamType, volumeLevel);
1131 EXPECT_FALSE(result);
1132 }
1133
1134 /**
1135 * @tc.name : Test GetSystemVolumeInDb.
1136 * @tc.number: GetSystemVolumeInDb_001
1137 * @tc.desc : Test AudioPolicyServer::GetSystemVolumeInDb
1138 */
1139 HWTEST(AudioPolicyUnitTest, GetSystemVolumeInDb_001, TestSize.Level1)
1140 {
1141 int32_t systemAbilityId = 3009;
1142 bool runOnCreate = false;
1143 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1144 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1145 AudioVolumeType volumeType = AudioStreamType::STREAM_MUSIC;
1146 int32_t volumeLevel = 20;
1147 DeviceType deviceType = DeviceType::DEVICE_TYPE_DEFAULT;
1148 float actual = ptrAudioPolicyServer->GetSystemVolumeInDb(volumeType, volumeLevel, deviceType);
1149 float result = static_cast<float>(ERR_INVALID_PARAM);
1150 EXPECT_EQ(actual, result);
1151 }
1152
1153 /**
1154 * @tc.name : Test IsArmUsbDevice.
1155 * @tc.number: IsArmUsbDevice_001
1156 * @tc.desc : Test AudioPolicyServer::IsArmUsbDevice
1157 */
1158 HWTEST(AudioPolicyUnitTest, IsArmUsbDevice_001, TestSize.Level1)
1159 {
1160 int32_t systemAbilityId = 3009;
1161 bool runOnCreate = false;
1162 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1163 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1164 AudioDeviceDescriptor desc;
1165 desc.deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET;
1166 bool result = ptrAudioPolicyServer->IsArmUsbDevice(desc);
1167 EXPECT_TRUE(result);
1168 }
1169
1170 /**
1171 * @tc.name : Test IsArmUsbDevice.
1172 * @tc.number: IsArmUsbDevice_002
1173 * @tc.desc : Test AudioPolicyServer::IsArmUsbDevice
1174 */
1175 HWTEST(AudioPolicyUnitTest, IsArmUsbDevice_002, TestSize.Level1)
1176 {
1177 auto ptrAudioPolicyServer = GetPolicyServerUnitTest();
1178 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1179 AudioDeviceDescriptor desc;
1180 desc.deviceType_ = DEVICE_TYPE_USB_HEADSET;
1181 bool result = ptrAudioPolicyServer->IsArmUsbDevice(desc);
1182 EXPECT_FALSE(result);
1183 }
1184
1185 /**
1186 * @tc.name : Test MapExternalToInternalDeviceType.
1187 * @tc.number: MapExternalToInternalDeviceType_001
1188 * @tc.desc : Test AudioPolicyServer::MapExternalToInternalDeviceType
1189 */
1190 HWTEST(AudioPolicyUnitTest, MapExternalToInternalDeviceType_001, TestSize.Level1)
1191 {
1192 int32_t systemAbilityId = 3009;
1193 bool runOnCreate = false;
1194 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1195 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1196 AudioDeviceDescriptor desc;
1197 desc.deviceType_ = DEVICE_TYPE_USB_HEADSET;
1198 desc.deviceId_ = 0;
1199 auto ptrAudioDeviceDescriptor = std::make_shared<AudioDeviceDescriptor>(desc);
1200 EXPECT_NE(ptrAudioDeviceDescriptor, nullptr);
1201 ptrAudioPolicyServer->audioDeviceManager_.connectedDevices_.push_back(ptrAudioDeviceDescriptor);
1202 ptrAudioPolicyServer->MapExternalToInternalDeviceType(desc);
1203 }
1204
1205 /**
1206 * @tc.name : Test MapExternalToInternalDeviceType.
1207 * @tc.number: MapExternalToInternalDeviceType_002
1208 * @tc.desc : Test AudioPolicyServer::MapExternalToInternalDeviceType
1209 */
1210 HWTEST(AudioPolicyUnitTest, MapExternalToInternalDeviceType_002, TestSize.Level1)
1211 {
1212 int32_t systemAbilityId = 3009;
1213 bool runOnCreate = false;
1214 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1215 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1216 AudioDeviceDescriptor desc;
1217 desc.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP;
1218 desc.deviceRole_ == INPUT_DEVICE;
1219 auto ptrAudioDeviceDescriptor = std::make_shared<AudioDeviceDescriptor>(desc);
1220 EXPECT_NE(ptrAudioDeviceDescriptor, nullptr);
1221 ptrAudioPolicyServer->audioDeviceManager_.connectedDevices_.push_back(ptrAudioDeviceDescriptor);
1222 ptrAudioPolicyServer->MapExternalToInternalDeviceType(desc);
1223 }
1224
1225 /**
1226 * @tc.name : Test SetCallbackCapturerInfo.
1227 * @tc.number: SetCallbackCapturerInfo_001
1228 * @tc.desc : Test AudioPolicyServer::SetCallbackCapturerInfo
1229 */
1230 HWTEST(AudioPolicyUnitTest, SetCallbackCapturerInfo_001, TestSize.Level1)
1231 {
1232 int32_t systemAbilityId = 3009;
1233 bool runOnCreate = false;
1234 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1235 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1236 SourceType sourceType = SOURCE_TYPE_INVALID;
1237 int32_t capturerFlags = 0;
1238 AudioCapturerInfo audioCapturerInfo(sourceType, capturerFlags);
1239 int32_t result = ptrAudioPolicyServer->SetCallbackCapturerInfo(audioCapturerInfo);
1240 EXPECT_EQ(result, SUCCESS);
1241 }
1242
1243 /**
1244 * @tc.name : Test SetAudioScene.
1245 * @tc.number: SetAudioScene_001
1246 * @tc.desc : Test AudioPolicyServer::SetAudioScene
1247 */
1248 HWTEST(AudioPolicyUnitTest, SetAudioScene_001, TestSize.Level1)
1249 {
1250 int32_t systemAbilityId = 3009;
1251 bool runOnCreate = false;
1252 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1253 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1254 AudioScene audioScene = AUDIO_SCENE_CALL_START;
1255 int32_t result = ptrAudioPolicyServer->SetAudioScene(audioScene);
1256 EXPECT_EQ(result, ERR_INVALID_PARAM);
1257 }
1258
1259 /**
1260 * @tc.name : Test SetAudioInterruptCallback.
1261 * @tc.number: SetAudioInterruptCallback_001
1262 * @tc.desc : Test AudioPolicyServer::SetAudioInterruptCallback
1263 */
1264 HWTEST(AudioPolicyUnitTest, SetAudioInterruptCallback_001, TestSize.Level1)
1265 {
1266 int32_t systemAbilityId = 3009;
1267 bool runOnCreate = false;
1268 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1269 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1270 uint32_t sessionID = 0;
1271 sptr<IRemoteObject> object = nullptr;
1272 uint32_t clientUid = 0;
1273 int32_t zoneID = 0;
1274 int32_t result = ptrAudioPolicyServer->SetAudioInterruptCallback(sessionID, object, clientUid, zoneID);
1275 EXPECT_EQ(result, ERR_UNKNOWN);
1276 }
1277
1278 /**
1279 * @tc.name : Test ProcessSessionRemoved.
1280 * @tc.number: ProcessSessionRemoved_001
1281 * @tc.desc : Test AudioPolicyServer::ProcessSessionRemoved
1282 */
1283 HWTEST(AudioPolicyUnitTest, ProcessSessionRemoved_001, TestSize.Level1)
1284 {
1285 int32_t systemAbilityId = 3009;
1286 bool runOnCreate = false;
1287 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1288 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1289 uint64_t sessionID = 0;
1290 int32_t zoneID = 0;
1291 ptrAudioPolicyServer->ProcessSessionRemoved(sessionID, zoneID);
1292 }
1293
1294 /**
1295 * @tc.name : Test ProcessSessionAdded.
1296 * @tc.number: ProcessSessionAdded_001
1297 * @tc.desc : Test AudioPolicyServer::ProcessSessionAdded
1298 */
1299 HWTEST(AudioPolicyUnitTest, ProcessSessionAdded_001, TestSize.Level1)
1300 {
1301 int32_t systemAbilityId = 3009;
1302 bool runOnCreate = false;
1303 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1304 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1305 SessionEvent sessionEvent = {SessionEvent::Type::ADD, 12345};
1306 ptrAudioPolicyServer->ProcessSessionAdded(sessionEvent);
1307 }
1308
1309 /**
1310 * @tc.name : Test ProcessorCloseWakeupSource.
1311 * @tc.number: ProcessorCloseWakeupSource_001
1312 * @tc.desc : Test AudioPolicyServer::ProcessorCloseWakeupSource
1313 */
1314 HWTEST(AudioPolicyUnitTest, ProcessorCloseWakeupSource_001, TestSize.Level1)
1315 {
1316 int32_t systemAbilityId = 3009;
1317 bool runOnCreate = false;
1318 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1319 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1320 uint64_t sessionID = 0;
1321 ptrAudioPolicyServer->ProcessorCloseWakeupSource(sessionID);
1322 }
1323
1324 /**
1325 * @tc.name : Test GetStreamVolumeInfoMap.
1326 * @tc.number: GetStreamVolumeInfoMap_001
1327 * @tc.desc : Test AudioPolicyServer::GetStreamVolumeInfoMap
1328 */
1329 HWTEST(AudioPolicyUnitTest, GetStreamVolumeInfoMap_001, TestSize.Level1)
1330 {
1331 int32_t systemAbilityId = 3009;
1332 bool runOnCreate = false;
1333 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1334 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1335 StreamVolumeInfoMap streamVolumeInfos;
1336 ptrAudioPolicyServer->GetStreamVolumeInfoMap(streamVolumeInfos);
1337 }
1338
1339 /**
1340 * @tc.name : Test InitPolicyDumpMap.
1341 * @tc.number: InitPolicyDumpMap_001
1342 * @tc.desc : Test AudioPolicyServer::InitPolicyDumpMap
1343 */
1344 HWTEST(AudioPolicyUnitTest, InitPolicyDumpMap_001, TestSize.Level1)
1345 {
1346 int32_t systemAbilityId = 3009;
1347 bool runOnCreate = false;
1348 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1349 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1350 ptrAudioPolicyServer->InitPolicyDumpMap();
1351 }
1352
1353 /**
1354 * @tc.name : Test AudioDevicesDump.
1355 * @tc.number: AudioDevicesDump_001
1356 * @tc.desc : Test AudioPolicyServer::AudioDevicesDump
1357 */
1358 HWTEST(AudioPolicyUnitTest, AudioDevicesDump_001, TestSize.Level1)
1359 {
1360 int32_t systemAbilityId = 3009;
1361 bool runOnCreate = false;
1362 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1363 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1364 std::string dumpString = "";
1365 ptrAudioPolicyServer->AudioDevicesDump(dumpString);
1366 }
1367
1368 /**
1369 * @tc.name : Test AudioModeDump.
1370 * @tc.number: AudioModeDump_001
1371 * @tc.desc : Test AudioPolicyServer::AudioModeDump
1372 */
1373 HWTEST(AudioPolicyUnitTest, AudioModeDump_001, TestSize.Level1)
1374 {
1375 int32_t systemAbilityId = 3009;
1376 bool runOnCreate = false;
1377 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1378 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1379 std::string dumpString = "";
1380 ptrAudioPolicyServer->AudioModeDump(dumpString);
1381 }
1382
1383 /**
1384 * @tc.name : Test AudioVolumeDump.
1385 * @tc.number: AudioVolumeDump_001
1386 * @tc.desc : Test AudioPolicyServer::AudioVolumeDump
1387 */
1388 HWTEST(AudioPolicyUnitTest, AudioVolumeDump_001, TestSize.Level1)
1389 {
1390 int32_t systemAbilityId = 3009;
1391 bool runOnCreate = false;
1392 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1393 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1394 std::string dumpString = "";
1395 ptrAudioPolicyServer->AudioVolumeDump(dumpString);
1396 }
1397
1398 /**
1399 * @tc.name : Test AudioPolicyParserDump.
1400 * @tc.number: AudioPolicyParserDump_001
1401 * @tc.desc : Test AudioPolicyServer::AudioPolicyParserDump
1402 */
1403 HWTEST(AudioPolicyUnitTest, AudioPolicyParserDump_001, TestSize.Level1)
1404 {
1405 int32_t systemAbilityId = 3009;
1406 bool runOnCreate = false;
1407 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1408 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1409 std::string dumpString = "";
1410 ptrAudioPolicyServer->AudioPolicyParserDump(dumpString);
1411 }
1412
1413 /**
1414 * @tc.name : Test AudioStreamDump.
1415 * @tc.number: AudioStreamDump_001
1416 * @tc.desc : Test AudioPolicyServer::AudioStreamDump
1417 */
1418 HWTEST(AudioPolicyUnitTest, AudioStreamDump_001, TestSize.Level1)
1419 {
1420 int32_t systemAbilityId = 3009;
1421 bool runOnCreate = false;
1422 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1423 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1424 std::string dumpString = "";
1425 ptrAudioPolicyServer->AudioStreamDump(dumpString);
1426 }
1427
1428 /**
1429 * @tc.name : Test XmlParsedDataMapDump.
1430 * @tc.number: XmlParsedDataMapDump_001
1431 * @tc.desc : Test AudioPolicyServer::XmlParsedDataMapDump
1432 */
1433 HWTEST(AudioPolicyUnitTest, XmlParsedDataMapDump_001, TestSize.Level1)
1434 {
1435 int32_t systemAbilityId = 3009;
1436 bool runOnCreate = false;
1437 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1438 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1439 std::string dumpString = "";
1440 ptrAudioPolicyServer->XmlParsedDataMapDump(dumpString);
1441 }
1442
1443 /**
1444 * @tc.name : Test EffectManagerInfoDump.
1445 * @tc.number: EffectManagerInfoDump_001
1446 * @tc.desc : Test AudioPolicyServer::EffectManagerInfoDump
1447 */
1448 HWTEST(AudioPolicyUnitTest, EffectManagerInfoDump_001, TestSize.Level1)
1449 {
1450 int32_t systemAbilityId = 3009;
1451 bool runOnCreate = false;
1452 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1453 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1454 std::string dumpString = "";
1455 ptrAudioPolicyServer->EffectManagerInfoDump(dumpString);
1456 }
1457
1458 /**
1459 * @tc.name : Test MicrophoneMuteInfoDump.
1460 * @tc.number: MicrophoneMuteInfoDump_001
1461 * @tc.desc : Test AudioPolicyServer::MicrophoneMuteInfoDump
1462 */
1463 HWTEST(AudioPolicyUnitTest, MicrophoneMuteInfoDump_001, TestSize.Level1)
1464 {
1465 int32_t systemAbilityId = 3009;
1466 bool runOnCreate = false;
1467 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1468 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1469 std::string dumpString = "";
1470 ptrAudioPolicyServer->MicrophoneMuteInfoDump(dumpString);
1471 }
1472 } // AudioStandard
1473 } // OHOS
1474