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 #include "i_hpae_manager.h"
24 #include "manager/hdi_adapter_manager.h"
25 #include "util/id_handler.h"
26 #include "accesstoken_kit.h"
27 #include "nativetoken_kit.h"
28 #include "token_setproc.h"
29
30 #ifdef FEATURE_MULTIMODALINPUT_INPUT
31 #include "input_manager.h"
32 #endif
33
34 #include <thread>
35 #include <memory>
36 #include <vector>
37 using namespace testing::ext;
38
39 namespace OHOS {
40 namespace AudioStandard {
41
42 bool g_hasPermission = false;
43 bool g_hasServerInit = false;
GetPolicyServerUnitTest()44 sptr<AudioPolicyServer> GetPolicyServerUnitTest()
45 {
46 static int32_t systemAbilityId = 3009;
47 static bool runOnCreate = false;
48 static sptr<AudioPolicyServer> server =
49 sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
50 if (!g_hasServerInit) {
51 IdHandler::GetInstance();
52 HdiAdapterManager::GetInstance();
53 HPAE::IHpaeManager::GetHpaeManager().Init();
54 server->OnStart();
55 server->OnAddSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID, "");
56 #ifdef FEATURE_MULTIMODALINPUT_INPUT
57 server->OnAddSystemAbility(MULTIMODAL_INPUT_SERVICE_ID, "");
58 #endif
59 server->OnAddSystemAbility(BLUETOOTH_HOST_SYS_ABILITY_ID, "");
60 server->OnAddSystemAbility(POWER_MANAGER_SERVICE_ID, "");
61 server->OnAddSystemAbility(SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN, "");
62 server->audioPolicyService_.SetDefaultDeviceLoadFlag(true);
63 g_hasServerInit = true;
64 }
65 return server;
66 }
67
GetPermission()68 void GetPermission()
69 {
70 if (!g_hasPermission) {
71 uint64_t tokenId;
72 constexpr int perNum = 10;
73 const char *perms[perNum] = {
74 "ohos.permission.MICROPHONE",
75 "ohos.permission.MANAGE_INTELLIGENT_VOICE",
76 "ohos.permission.MANAGE_AUDIO_CONFIG",
77 "ohos.permission.MICROPHONE_CONTROL",
78 "ohos.permission.MODIFY_AUDIO_SETTINGS",
79 "ohos.permission.ACCESS_NOTIFICATION_POLICY",
80 "ohos.permission.USE_BLUETOOTH",
81 "ohos.permission.CAPTURE_VOICE_DOWNLINK_AUDIO",
82 "ohos.permission.RECORD_VOICE_CALL",
83 "ohos.permission.MANAGE_SYSTEM_AUDIO_EFFECTS",
84 };
85
86 NativeTokenInfoParams infoInstance = {
87 .dcapsNum = 0,
88 .permsNum = 10,
89 .aclsNum = 0,
90 .dcaps = nullptr,
91 .perms = perms,
92 .acls = nullptr,
93 .processName = "audiofuzztest",
94 .aplStr = "system_basic",
95 };
96 tokenId = GetAccessTokenId(&infoInstance);
97 SetSelfTokenID(tokenId);
98 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
99 g_hasPermission = true;
100 }
101 }
102
ReleaseServer()103 void ReleaseServer()
104 {
105 GetPolicyServerUnitTest()->OnStop();
106 g_hasServerInit = false;
107 }
108
SetUpTestCase(void)109 void AudioPolicyUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)110 void AudioPolicyUnitTest::TearDownTestCase(void)
111 {
112 ReleaseServer();
113 }
114
SetUp(void)115 void AudioPolicyUnitTest::SetUp(void)
116 {
117 GetPermission();
118 }
119
TearDown(void)120 void AudioPolicyUnitTest::TearDown(void) {}
121
122 class RemoteObjectTestStub : public IRemoteObject {
123 public:
RemoteObjectTestStub()124 RemoteObjectTestStub() : IRemoteObject(u"IRemoteObject") {}
GetObjectRefCount()125 int32_t GetObjectRefCount() { return 0; };
SendRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)126 int SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) { return 0; };
AddDeathRecipient(const sptr<DeathRecipient> & recipient)127 bool AddDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
RemoveDeathRecipient(const sptr<DeathRecipient> & recipient)128 bool RemoveDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
Dump(int fd,const std::vector<std::u16string> & args)129 int Dump(int fd, const std::vector<std::u16string> &args) { return 0; };
130
131 DECLARE_INTERFACE_DESCRIPTOR(u"RemoteObjectTestStub");
132 };
133
134 #define PRINT_LINE printf("debug __LINE__:%d\n", __LINE__)
135
136 /**
137 * @tc.name : Test AudioPolicyServer.
138 * @tc.number: AudioPolicyServer_001
139 * @tc.desc : Test CheckAudioSessionStrategy.
140 */
141 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_001, TestSize.Level1)
142 {
143 AudioSessionStrategy strategy;
144 auto policyServerTest = GetPolicyServerUnitTest();
145 int32_t systemAbilityId = 3009;
146 bool runOnCreate = false;
147 sptr<AudioPolicyServer> server = sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
148
149 strategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
150 EXPECT_TRUE(server->CheckAudioSessionStrategy(strategy));
151 strategy.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
152 EXPECT_TRUE(server->CheckAudioSessionStrategy(strategy));
153 strategy.concurrencyMode = AudioConcurrencyMode::DUCK_OTHERS;
154 EXPECT_TRUE(server->CheckAudioSessionStrategy(strategy));
155 strategy.concurrencyMode = AudioConcurrencyMode::PAUSE_OTHERS;
156 EXPECT_TRUE(server->CheckAudioSessionStrategy(strategy));
157 }
158
159 /**
160 * @tc.name : Test AudioPolicyServer.
161 * @tc.number: AudioPolicyServer_002
162 * @tc.desc : Test CheckAudioSessionStrategy.
163 */
164 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_002, TestSize.Level1)
165 {
166 AudioSessionStrategy strategy;
167 auto policyServerTest = GetPolicyServerUnitTest();
168 int32_t systemAbilityId = 3009;
169 bool runOnCreate = false;
170 sptr<AudioPolicyServer> server = sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
171
172 strategy.concurrencyMode = static_cast<AudioConcurrencyMode>(999); // Invalid mode
173 EXPECT_FALSE(server->CheckAudioSessionStrategy(strategy));
174 }
175
176 /**
177 * @tc.name : Test AudioPolicyServer.
178 * @tc.number: AudioPolicyServer_003
179 * @tc.desc : Test SetAudioManagerInterruptCallback.
180 */
181 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_003, TestSize.Level1)
182 {
183 auto policyServerTest = GetPolicyServerUnitTest();
184 int32_t systemAbilityId = 3009;
185 bool runOnCreate = false;
186 sptr<AudioPolicyServer> server = sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
187
188 server->interruptService_ = nullptr;
189 int32_t result = server->SetAudioManagerInterruptCallback(0, sptr<RemoteObjectTestStub>::MakeSptr());
190 EXPECT_EQ(result, ERR_UNKNOWN);
191 }
192
193 /**
194 * @tc.name : Test AudioPolicyServer.
195 * @tc.number: AudioPolicyServer_004
196 * @tc.desc : Test UnsetAudioManagerInterruptCallback.
197 */
198 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_004, TestSize.Level1)
199 {
200 auto policyServerTest = GetPolicyServerUnitTest();
201 int32_t systemAbilityId = 3009;
202 bool runOnCreate = false;
203 sptr<AudioPolicyServer> server = sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
204
205 server->interruptService_ = nullptr;
206 int32_t result = server->UnsetAudioManagerInterruptCallback(0);
207 EXPECT_EQ(result, ERR_UNKNOWN);
208 }
209
210 /**
211 * @tc.name : Test AudioPolicyServer.
212 * @tc.number: AudioPolicyServer_005
213 * @tc.desc : Test OnAudioParameterChange.
214 */
215 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_005, TestSize.Level1)
216 {
217 auto policyServerTest = GetPolicyServerUnitTest();
218 int32_t systemAbilityId = 3009;
219 bool runOnCreate = false;
220 sptr<AudioPolicyServer> server = sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
221
222 std::string networkId;
223 AudioParamKey key = static_cast<AudioParamKey>(100);
224 std::string condition;
225 std::string value;
226 auto callback = std::make_shared<AudioPolicyServer::RemoteParameterCallback>(server);
227 callback->OnAudioParameterChange(networkId, key, condition, value);
228 }
229
230 /**
231 * @tc.name : Test AudioPolicyServer.
232 * @tc.number: AudioPolicyServer_006
233 * @tc.desc : Test OnAudioParameterChange.
234 */
235 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_006, TestSize.Level1)
236 {
237 auto policyServerTest = GetPolicyServerUnitTest();
238 int32_t systemAbilityId = 3009;
239 bool runOnCreate = false;
240 sptr<AudioPolicyServer> server = sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
241
242 std::string networkId;
243 AudioParamKey key = PARAM_KEY_STATE;
244 std::string condition;
245 std::string value;
246 auto callback = std::make_shared<AudioPolicyServer::RemoteParameterCallback>(server);
247 callback->OnAudioParameterChange(networkId, key, condition, value);
248 }
249
250 /**
251 * @tc.name : Test AudioPolicyServer.
252 * @tc.number: AudioPolicyServer_008
253 * @tc.desc : Test ArgInfoDump.
254 */
255 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_008, TestSize.Level1)
256 {
257 auto policyServerTest = GetPolicyServerUnitTest();
258 int32_t systemAbilityId = 3009;
259 bool runOnCreate = false;
260 sptr<AudioPolicyServer> server = sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
261
262 std::string dumpString;
263 std::queue<std::u16string> argQue;
264 argQue.push(u"invalidParam");
265 server->ArgInfoDump(dumpString, argQue);
266 EXPECT_EQ(dumpString.find("Please input correct param:\n"), 0);
267 }
268
269 /**
270 * @tc.name : Test AudioPolicyServer.
271 * @tc.number: AudioPolicyServer_009
272 * @tc.desc : Test DeactivateAudioInterrupt.
273 */
274 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_009, TestSize.Level1)
275 {
276 auto policyServerTest = GetPolicyServerUnitTest();
277 int32_t systemAbilityId = 3009;
278 bool runOnCreate = false;
279 sptr<AudioPolicyServer> server = sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
280
281 AudioInterrupt audioInterrupt;
282 int32_t zoneID = 456;
283 int32_t result = server->DeactivateAudioInterrupt(audioInterrupt, zoneID);
284 EXPECT_EQ(result, ERR_UNKNOWN);
285 }
286
287 /**
288 * @tc.name : Test AudioPolicyServer.
289 * @tc.number: AudioPolicyServer_010
290 * @tc.desc : Test OnAudioParameterChange.
291 */
292 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_010, TestSize.Level1)
293 {
294 auto policyServerTest = GetPolicyServerUnitTest();
295 int32_t systemAbilityId = 3009;
296 bool runOnCreate = false;
297 sptr<AudioPolicyServer> server = sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
298
299 std::string networkId;
300 AudioParamKey key = VOLUME;
301 std::string condition;
302 std::string value;
303
304 auto callback = std::make_shared<AudioPolicyServer::RemoteParameterCallback>(server);
305 callback->OnAudioParameterChange(networkId, key, condition, value);
306 }
307
308 /**
309 * @tc.name : Test AudioPolicyServer.
310 * @tc.number: AudioPolicyServer_011
311 * @tc.desc : Test OnAudioParameterChange.
312 */
313 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_011, TestSize.Level1)
314 {
315 auto policyServerTest = GetPolicyServerUnitTest();
316 int32_t systemAbilityId = 3009;
317 bool runOnCreate = false;
318 sptr<AudioPolicyServer> server = sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
319
320 std::string networkId;
321 AudioParamKey key = INTERRUPT;
322 std::string condition;
323 std::string value;
324
325 auto callback = std::make_shared<AudioPolicyServer::RemoteParameterCallback>(server);
326 callback->OnAudioParameterChange(networkId, key, condition, value);
327 }
328
329 /**
330 * @tc.name : Test AudioPolicyServer.
331 * @tc.number: AudioPolicyServer_012
332 * @tc.desc : Test ActivateAudioSession.
333 */
334 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_012, TestSize.Level1)
335 {
336 int32_t strategy = 0;
337 auto policyServerTest = GetPolicyServerUnitTest();
338 EXPECT_EQ(policyServerTest->ActivateAudioSession(strategy), SUCCESS);
339 }
340
341 /**
342 * @tc.name : Test AudioPolicyServer.
343 * @tc.number: AudioPolicyServer_013
344 * @tc.desc : Test GetStreamInFocus.
345 */
346 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_013, TestSize.Level1)
347 {
348 auto policyServerTest = GetPolicyServerUnitTest();
349 int32_t zoneID = 456;
350 int32_t result = 0;
351 policyServerTest->GetStreamInFocus(zoneID, result);
352 EXPECT_EQ(result, STREAM_MUSIC);
353 }
354
355 /**
356 * @tc.name : Test AudioPolicyServer.
357 * @tc.number: AudioPolicyServer_014
358 * @tc.desc : Test OnRemoveSystemAbility.
359 */
360 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_014, TestSize.Level1)
361 {
362 auto policyServerTest = GetPolicyServerUnitTest();
363 int32_t systemAbilityId = AVSESSION_SERVICE_ID;
364 std::string deviceId = "132456";
365 policyServerTest->OnRemoveSystemAbility(systemAbilityId, deviceId);
366 }
367
368 /**
369 * @tc.name : Test AudioPolicyServer.
370 * @tc.number: AudioPolicyServer_015
371 * @tc.desc : Test InitMicrophoneMute.
372 */
373 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_015, TestSize.Level1)
374 {
375 auto policyServerTest = GetPolicyServerUnitTest();
376 policyServerTest->isInitMuteState_ = true;
377 policyServerTest->InitMicrophoneMute();
378 }
379
380 /**
381 * @tc.name : Test AudioPolicyServer.
382 * @tc.number: AudioPolicyServer_016
383 * @tc.desc : Test ActivateAudioInterrupt.
384 */
385 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_016, TestSize.Level1)
386 {
387 auto policyServerTest = GetPolicyServerUnitTest();
388 AudioInterrupt audioInterrupt;
389 int32_t zoneID = 456;
390 int32_t result = 0;
391 policyServerTest->ActivateAudioInterrupt(audioInterrupt, zoneID, result);
392 EXPECT_EQ(result, SUCCESS);
393 }
394
395 /**
396 * @tc.name : Test AudioPolicyServer.
397 * @tc.number: AudioPolicyServer_017
398 * @tc.desc : Test SetRingerModeLegacy.
399 */
400 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_017, TestSize.Level1)
401 {
402 auto policyServerTest = GetPolicyServerUnitTest();
403
404 AudioRingerMode audioRingerMode = AudioRingerMode::RINGER_MODE_NORMAL;
405 int32_t result = policyServerTest->SetRingerModeLegacy(audioRingerMode);
406 EXPECT_EQ(result, 0);
407 }
408
409 /**
410 * @tc.name : Test AudioPolicyServer.
411 * @tc.number: AudioPolicyServer_018
412 * @tc.desc : Test AudioPolicyServer::LoadSplitModule.
413 */
414 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_018, TestSize.Level1)
415 {
416 int32_t systemAbilityId = 3009;
417 bool runOnCreate = false;
418 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
419
420 EXPECT_NE(ptrAudioPolicyServer, nullptr);
421
422 const std::string splitArgs = "";
423 const std::string networkId = "";
424 ptrAudioPolicyServer->LoadSplitModule(splitArgs, networkId);
425 }
426
427 /**
428 * @tc.name : Test AudioPolicyServer.
429 * @tc.number: AudioPolicyServer_019
430 * @tc.desc : Test AudioPolicyServer::IsAudioSessionActivated
431 */
432 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_019, TestSize.Level1)
433 {
434 int32_t systemAbilityId = 3009;
435 bool runOnCreate = false;
436 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
437
438 EXPECT_NE(ptrAudioPolicyServer, nullptr);
439
440 bool isActive = false;
441 ptrAudioPolicyServer->interruptService_ = std::make_shared<AudioInterruptService>();
442 ptrAudioPolicyServer->IsAudioSessionActivated(isActive);
443 EXPECT_EQ(isActive, false);
444 }
445
446 /**
447 * @tc.name : Test AudioPolicyServer.
448 * @tc.number: AudioPolicyServer_020
449 * @tc.desc : Test AudioPolicyServer::IsAudioSessionActivated
450 */
451 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_020, TestSize.Level1)
452 {
453 int32_t systemAbilityId = 3009;
454 bool runOnCreate = false;
455 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
456
457 EXPECT_NE(ptrAudioPolicyServer, nullptr);
458
459 bool isActive = false;
460 ptrAudioPolicyServer->interruptService_ = nullptr;
461 ptrAudioPolicyServer->IsAudioSessionActivated(isActive);
462 EXPECT_EQ(isActive, false);
463 }
464
465 /**
466 * @tc.name : Test AudioPolicyServer.
467 * @tc.number: AudioPolicyServer_021
468 * @tc.desc : Test AudioPolicyServer::DeactivateAudioSession
469 */
470 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_021, TestSize.Level1)
471 {
472 int32_t systemAbilityId = 3009;
473 bool runOnCreate = false;
474 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
475
476 EXPECT_NE(ptrAudioPolicyServer, nullptr);
477
478 ptrAudioPolicyServer->interruptService_ = nullptr;
479 ptrAudioPolicyServer->DeactivateAudioSession();
480 }
481
482 /**
483 * @tc.name : Test AudioPolicyServer.
484 * @tc.number: AudioPolicyServer_022
485 * @tc.desc : Test AudioPolicyServer::DeactivateAudioSession
486 */
487 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_022, TestSize.Level1)
488 {
489 int32_t systemAbilityId = 3009;
490 bool runOnCreate = false;
491 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
492
493 EXPECT_NE(ptrAudioPolicyServer, nullptr);
494
495 ptrAudioPolicyServer->interruptService_ = std::make_shared<AudioInterruptService>();
496 ptrAudioPolicyServer->DeactivateAudioSession();
497 }
498
499 /**
500 * @tc.name : Test AudioPolicyServer.
501 * @tc.number: AudioPolicyServer_023
502 * @tc.desc : Test AudioPolicyServer::ActivateAudioSession
503 */
504 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_023, TestSize.Level1)
505 {
506 int32_t systemAbilityId = 3009;
507 bool runOnCreate = false;
508 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
509
510 EXPECT_NE(ptrAudioPolicyServer, nullptr);
511
512 int32_t strategy = 0;
513 ptrAudioPolicyServer->interruptService_ = std::make_shared<AudioInterruptService>();
514 auto ret = ptrAudioPolicyServer->ActivateAudioSession(strategy);
515
516 EXPECT_EQ(ret, ERR_UNKNOWN);
517 }
518
519 /**
520 * @tc.name : Test AudioPolicyServer.
521 * @tc.number: AudioPolicyServer_024
522 * @tc.desc : Test AudioPolicyServer::ActivateAudioSession
523 */
524 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_024, TestSize.Level1)
525 {
526 int32_t systemAbilityId = 3009;
527 bool runOnCreate = false;
528 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
529
530 EXPECT_NE(ptrAudioPolicyServer, nullptr);
531
532 int32_t strategy = 0;
533 ptrAudioPolicyServer->interruptService_ = nullptr;
534 auto ret = ptrAudioPolicyServer->ActivateAudioSession(strategy);
535
536 EXPECT_EQ(ret, ERR_UNKNOWN);
537 }
538
539 /**
540 * @tc.name : Test AudioPolicyServer.
541 * @tc.number: AudioPolicyServer_025
542 * @tc.desc : Test AudioPolicyServer::ActivateAudioSession
543 */
544 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_025, TestSize.Level1)
545 {
546 int32_t systemAbilityId = 3009;
547 bool runOnCreate = false;
548 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
549
550 EXPECT_NE(ptrAudioPolicyServer, nullptr);
551
552 int32_t strategy = 0;
553 ptrAudioPolicyServer->interruptService_ = std::make_shared<AudioInterruptService>();
554
555 auto ret = ptrAudioPolicyServer->ActivateAudioSession(strategy);
556
557 EXPECT_EQ(ret, ERR_UNKNOWN);
558 }
559
560 /**
561 * @tc.name : Test AudioPolicyServer.
562 * @tc.number: AudioPolicyServer_026
563 * @tc.desc : Test AudioPolicyServer::ActivateAudioSession
564 */
565 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_026, TestSize.Level1)
566 {
567 int32_t systemAbilityId = 3009;
568 bool runOnCreate = false;
569 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
570
571 EXPECT_NE(ptrAudioPolicyServer, nullptr);
572
573 int32_t strategy = 0;
574 ptrAudioPolicyServer->interruptService_ = std::make_shared<AudioInterruptService>();
575
576 auto ret = ptrAudioPolicyServer->ActivateAudioSession(strategy);
577
578 EXPECT_EQ(ret, ERR_UNKNOWN);
579 }
580
581 /**
582 * @tc.name : Test AudioPolicyServer.
583 * @tc.number: AudioPolicyServer_027
584 * @tc.desc : Test AudioPolicyServer::InjectInterruption
585 */
586 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_027, TestSize.Level1)
587 {
588 int32_t systemAbilityId = 3009;
589 bool runOnCreate = false;
590 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
591
592 EXPECT_NE(ptrAudioPolicyServer, nullptr);
593
594 const std::string networkId = "";
595 InterruptEvent event;
596
597 auto ret = ptrAudioPolicyServer->InjectInterruption(networkId, event);
598
599 EXPECT_EQ(ret, ERROR);
600 }
601
602 /**
603 * @tc.name : Test AudioPolicyServer.
604 * @tc.number: AudioPolicyServer_028
605 * @tc.desc : Test AudioPolicyServer::UnsetAudioDeviceAnahsCallback
606 */
607 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_028, TestSize.Level1)
608 {
609 int32_t systemAbilityId = 3009;
610 bool runOnCreate = false;
611 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
612
613 EXPECT_NE(ptrAudioPolicyServer, nullptr);
614
615 auto ret = ptrAudioPolicyServer->UnsetAudioDeviceAnahsCallback();
616
617 EXPECT_EQ(ret, ERROR);
618 }
619
620 /**
621 * @tc.name : Test AudioPolicyServer.
622 * @tc.number: AudioPolicyServer_029
623 * @tc.desc : Test AudioPolicyServer::TriggerFetchDevice
624 */
625 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_029, TestSize.Level1)
626 {
627 int32_t systemAbilityId = 3009;
628 bool runOnCreate = false;
629 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
630
631 EXPECT_NE(ptrAudioPolicyServer, nullptr);
632
633 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::NEW_DEVICE_AVAILABLE;
634 auto ret = ptrAudioPolicyServer->TriggerFetchDevice(reason);
635
636 EXPECT_EQ(ret, ERROR);
637 }
638
639 /**
640 * @tc.name : Test AudioPolicyServer.
641 * @tc.number: AudioPolicyServer_030
642 * @tc.desc : Test AudioPolicyServer::UnsetAudioDeviceRefinerCallback
643 */
644 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_030, TestSize.Level1)
645 {
646 int32_t systemAbilityId = 3009;
647 bool runOnCreate = false;
648 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
649
650 EXPECT_NE(ptrAudioPolicyServer, nullptr);
651
652 auto ret = ptrAudioPolicyServer->UnsetAudioDeviceRefinerCallback();
653
654 EXPECT_EQ(ret, ERROR);
655 }
656
657 #ifdef TEMP_DISABLE
658 /**
659 * @tc.name : Test AudioPolicyServer.
660 * @tc.number: AudioPolicyServer_031
661 * @tc.desc : Test AudioPolicyServer::SetHighResolutionExist
662 */
663 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_031, TestSize.Level1)
664 {
665 int32_t systemAbilityId = 3009;
666 bool runOnCreate = false;
667 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
668
669 EXPECT_NE(ptrAudioPolicyServer, nullptr);
670
671 bool highResExist = true;
672 auto ret = ptrAudioPolicyServer->SetHighResolutionExist(highResExist);
673
674 EXPECT_EQ(ret, SUCCESS);
675 }
676 #endif
677
678 /**
679 * @tc.name : Test AudioPolicyServer.
680 * @tc.number: AudioPolicyServer_032
681 * @tc.desc : Test AudioPolicyServer::IsHighResolutionExist
682 */
683 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_032, TestSize.Level1)
684 {
685 int32_t systemAbilityId = 3009;
686 bool runOnCreate = false;
687 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
688
689 EXPECT_NE(ptrAudioPolicyServer, nullptr);
690
691 bool ret;
692 ptrAudioPolicyServer->IsHighResolutionExist(ret);
693
694 EXPECT_EQ(ret, false);
695 }
696
697 #ifdef TEMP_DISABLE
698 /**
699 * @tc.name : Test AudioPolicyServer.
700 * @tc.number: AudioPolicyServer_033
701 * @tc.desc : Test AudioPolicyServer::DisableSafeMediaVolume
702 */
703 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_033, TestSize.Level1)
704 {
705 int32_t systemAbilityId = 3009;
706 bool runOnCreate = false;
707 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
708
709 EXPECT_NE(ptrAudioPolicyServer, nullptr);
710
711 auto ret = ptrAudioPolicyServer->DisableSafeMediaVolume();
712
713 EXPECT_EQ(ret, SUCCESS);
714 }
715
716 /**
717 * @tc.name : Test AudioPolicyServer.
718 * @tc.number: AudioPolicyServer_034
719 * @tc.desc : Test AudioPolicyServer::SetSpatializationSceneType
720 */
721 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_034, TestSize.Level1)
722 {
723 int32_t systemAbilityId = 3009;
724 bool runOnCreate = false;
725 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
726
727 EXPECT_NE(ptrAudioPolicyServer, nullptr);
728
729 const AudioSpatializationSceneType spatializationSceneType =
730 AudioSpatializationSceneType::SPATIALIZATION_SCENE_TYPE_DEFAULT;
731 auto ret = ptrAudioPolicyServer->SetSpatializationSceneType(spatializationSceneType);
732
733 EXPECT_EQ(ret, OPEN_PORT_FAILURE);
734 }
735
736 /**
737 * @tc.name : Test AudioPolicyServer.
738 * @tc.number: AudioPolicyServer_035
739 * @tc.desc : Test AudioPolicyServer::GetSpatializationSceneType
740 */
741 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_035, TestSize.Level1)
742 {
743 int32_t systemAbilityId = 3009;
744 bool runOnCreate = false;
745 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
746
747 EXPECT_NE(ptrAudioPolicyServer, nullptr);
748
749 int32_t ret = 0;
750 ptrAudioPolicyServer->GetSpatializationSceneType(ret);
751
752 EXPECT_EQ(ret, SUCCESS);
753 }
754
755 /**
756 * @tc.name : Test AudioPolicyServer.
757 * @tc.number: AudioPolicyServer_036
758 * @tc.desc : Test AudioPolicyServer::GetSpatializationSceneType
759 */
760 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_036, TestSize.Level1)
761 {
762 auto ptrAudioPolicyServer = GetPolicyServerUnitTest();
763
764 EXPECT_NE(ptrAudioPolicyServer, nullptr);
765
766 std::shared_ptr<AudioDeviceDescriptor> descs = nullptr;
767 ptrAudioPolicyServer->GetActiveBluetoothDevice(descs);
768 EXPECT_EQ(descs, nullptr);
769 }
770
771 /**
772 * @tc.name : Test AudioPolicyServer.
773 * @tc.number: AudioPolicyServer_037
774 * @tc.desc : Test AudioPolicyServer::SetCallDeviceActive
775 */
776 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_037, 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 InternalDeviceType deviceType = DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP_IN;
785 bool active = true;
786 std::string address = "";
787 int32_t ret = 0;
788 ptrAudioPolicyServer->SetCallDeviceActive(deviceType, active, address, ret);
789
790 EXPECT_EQ(ret, ERR_NOT_SUPPORTED);
791 }
792
793 /**
794 * @tc.name : Test AudioPolicyServer.
795 * @tc.number: AudioPolicyServer_038
796 * @tc.desc : Test AudioPolicyServer::SetCallDeviceActive
797 */
798 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_038, TestSize.Level1)
799 {
800 int32_t systemAbilityId = 3009;
801 bool runOnCreate = false;
802 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
803
804 EXPECT_NE(ptrAudioPolicyServer, nullptr);
805
806 InternalDeviceType deviceType = DeviceType::DEVICE_TYPE_EARPIECE;
807 bool active = true;
808 std::string address = "";
809 int32_t ret = 0;
810 ptrAudioPolicyServer->SetCallDeviceActive(deviceType, active, address, ret);
811
812 EXPECT_NE(ret, ERR_SYSTEM_PERMISSION_DENIED);
813 }
814 #endif
815
816 /**
817 * @tc.name : Test AudioPolicyServer.
818 * @tc.number: AudioPolicyServer_039
819 * @tc.desc : Test AudioPolicyServer::ReleaseAudioInterruptZone
820 */
821 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_039, TestSize.Level1)
822 {
823 int32_t systemAbilityId = 3009;
824 bool runOnCreate = false;
825 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
826
827 EXPECT_NE(ptrAudioPolicyServer, nullptr);
828
829 const int32_t zoneID = 0;
830 ptrAudioPolicyServer->interruptService_ = std::make_shared<AudioInterruptService>();
831 auto ret = ptrAudioPolicyServer->ReleaseAudioInterruptZone(zoneID);
832
833 EXPECT_EQ(ret, ERR_UNKNOWN);
834 }
835
836 /**
837 * @tc.name : Test AudioPolicyServer.
838 * @tc.number: AudioPolicyServer_040
839 * @tc.desc : Test AudioPolicyServer::ReleaseAudioInterruptZone
840 */
841 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_040, TestSize.Level1)
842 {
843 int32_t systemAbilityId = 3009;
844 bool runOnCreate = false;
845 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
846
847 EXPECT_NE(ptrAudioPolicyServer, nullptr);
848
849 const int32_t zoneID = 0;
850 ptrAudioPolicyServer->interruptService_ = nullptr;
851 auto ret = ptrAudioPolicyServer->ReleaseAudioInterruptZone(zoneID);
852
853 EXPECT_EQ(ret, ERR_UNKNOWN);
854 }
855
856 /**
857 * @tc.name : Test AudioPolicyServer.
858 * @tc.number: SetSystemVolumeLevelInternal_001
859 * @tc.desc : Test AudioPolicyServer::SetSystemVolumeLevelInternal
860 */
861 HWTEST(AudioPolicyUnitTest, SetSystemVolumeLevelInternal_001, TestSize.Level1)
862 {
863 AUDIO_INFO_LOG("SetSystemVolumeLevelInternal_001 start");
864 int32_t systemAbilityId = 3009;
865 bool runOnCreate = false;
866 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
867 ASSERT_NE(ptrAudioPolicyServer, nullptr);
868
869 int32_t volumeLevel = 5;
870 bool isUpdateUi = true;
871 auto ret = ptrAudioPolicyServer->SetSystemVolumeLevelInternal(STREAM_VOICE_CALL, volumeLevel, isUpdateUi);
872 EXPECT_EQ(ret, SUCCESS);
873 }
874
875 /**
876 * @tc.name : Test AudioPolicyServer.
877 * @tc.number: SetSystemVolumeLevelInternal_002
878 * @tc.desc : Test AudioPolicyServer::SetSystemVolumeLevelInternal
879 */
880 HWTEST(AudioPolicyUnitTest, SetSystemVolumeLevelInternal_002, TestSize.Level1)
881 {
882 AUDIO_INFO_LOG("SetSystemVolumeLevelInternal_002 start");
883 int32_t systemAbilityId = 3009;
884 bool runOnCreate = false;
885 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
886 ASSERT_NE(ptrAudioPolicyServer, nullptr);
887
888 int32_t volumeLevel = 5;
889 bool isUpdateUi = true;
890 VolumeUtils::SetPCVolumeEnable(true);
891 auto ret = ptrAudioPolicyServer->SetSystemVolumeLevelInternal(STREAM_VOICE_CALL, volumeLevel, isUpdateUi);
892 VolumeUtils::SetPCVolumeEnable(false);
893 EXPECT_EQ(ret, SUCCESS);
894 }
895
896 /**
897 * @tc.name : Test AudioPolicyServer.
898 * @tc.number: AudioPolicyServer_041
899 * @tc.desc : Test AudioPolicyServer::GetSystemActiveVolumeType
900 */
901 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_041, TestSize.Level1)
902 {
903 int32_t systemAbilityId = 3009;
904 bool runOnCreate = false;
905 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
906
907 EXPECT_NE(ptrAudioPolicyServer, nullptr);
908
909 int32_t streamType;
910 int32_t clientUid = 0;
911 ptrAudioPolicyServer->GetSystemActiveVolumeType(clientUid, streamType);
912 EXPECT_EQ(streamType, STREAM_MUSIC);
913 clientUid = 1;
914 ptrAudioPolicyServer->GetSystemActiveVolumeType(clientUid, streamType);
915 EXPECT_EQ(streamType, STREAM_MUSIC);
916 }
917
918 /**
919 * @tc.name : Test AudioPolicyServer.
920 * @tc.number: AudioPolicyServer_042
921 * @tc.desc : Test AudioPolicyServer::GetSystemVolumeLevelNoMuteState
922 */
923 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_042, TestSize.Level1)
924 {
925 int32_t systemAbilityId = 3009;
926 bool runOnCreate = false;
927 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
928
929 EXPECT_NE(ptrAudioPolicyServer, nullptr);
930
931 AudioStreamType streamType = STREAM_ALL;
932 int res = ptrAudioPolicyServer->GetSystemVolumeLevelNoMuteState(streamType);
933 EXPECT_EQ(res, 5);
934 streamType = STREAM_MUSIC;
935 res = ptrAudioPolicyServer->GetSystemVolumeLevelNoMuteState(streamType);
936 EXPECT_EQ(res, 5);
937 }
938
939 /**
940 * @tc.name : Test AudioPolicyServer.
941 * @tc.number: AudioPolicyServer_043
942 * @tc.desc : Test AudioPolicyServer::GetStreamMute
943 */
944 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_043, TestSize.Level1)
945 {
946 int32_t systemAbilityId = 3009;
947 bool runOnCreate = false;
948 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
949
950 EXPECT_NE(ptrAudioPolicyServer, nullptr);
951
952 int32_t streamType = 2;
953 bool ret;
954 ptrAudioPolicyServer->GetStreamMute(streamType, ret);
955 EXPECT_EQ(ret, false);
956 streamType = 25;
957 ret = ptrAudioPolicyServer->GetStreamMute(streamType, ret);
958 EXPECT_EQ(ret, false);
959 streamType = 1;
960 ret = ptrAudioPolicyServer->GetStreamMute(streamType, ret);
961 EXPECT_EQ(ret, false);
962 }
963
964 /**
965 * @tc.name : Test AudioPolicyServer.
966 * @tc.number: AudioPolicyServer_044
967 * @tc.desc : Test AudioPolicyServer::GetPreferredOutputStreamType
968 */
969 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_044, TestSize.Level1)
970 {
971 auto ptrAudioPolicyServer = GetPolicyServerUnitTest();
972
973 EXPECT_NE(ptrAudioPolicyServer, nullptr);
974
975 AudioRendererInfo rendererInfo;
976 int32_t ret = 0;
977 ptrAudioPolicyServer->GetPreferredOutputStreamType(rendererInfo, ret);
978 EXPECT_EQ(ret, 0);
979 ptrAudioPolicyServer->audioPolicyService_.isFastControlled_ = true;
980 ptrAudioPolicyServer->GetPreferredOutputStreamType(rendererInfo, ret);
981 EXPECT_EQ(ret, 0);
982 rendererInfo.rendererFlags = AUDIO_FLAG_MMAP;
983 ptrAudioPolicyServer->GetPreferredOutputStreamType(rendererInfo, ret);
984 EXPECT_EQ(ret, AUDIO_FLAG_NORMAL);
985 }
986
987 /**
988 * @tc.name : Test TranslateErrorCodeer.
989 * @tc.number: TranslateErrorCode_001
990 * @tc.desc : Test TranslateErrorCodeer.
991 */
992 HWTEST(AudioPolicyUnitTest, TranslateErrorCode_001, TestSize.Level1)
993 {
994 int32_t systemAbilityId = 3009;
995 bool runOnCreate = false;
996 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
997 EXPECT_NE(ptrAudioPolicyServer, nullptr);
998
999 int32_t result = ERR_INVALID_PARAM;
1000 uint32_t resultForMonitor = ERR_SUBSCRIBE_INVALID_PARAM;
1001 uint32_t actual = ptrAudioPolicyServer->TranslateErrorCode(result);
1002 EXPECT_EQ(resultForMonitor, actual);
1003
1004 result = ERR_NULL_POINTER;
1005 resultForMonitor = ERR_SUBSCRIBE_KEY_OPTION_NULL;
1006 actual = ptrAudioPolicyServer->TranslateErrorCode(result);
1007 EXPECT_EQ(resultForMonitor, actual);
1008
1009 result = ERR_MMI_CREATION;
1010 resultForMonitor = ERR_SUBSCRIBE_MMI_NULL;
1011 actual = ptrAudioPolicyServer->TranslateErrorCode(result);
1012 EXPECT_EQ(resultForMonitor, actual);
1013
1014 result = ERR_MMI_SUBSCRIBE;
1015 resultForMonitor = ERR_MODE_SUBSCRIBE;
1016 actual = ptrAudioPolicyServer->TranslateErrorCode(result);
1017 EXPECT_EQ(resultForMonitor, actual);
1018
1019 result = 99999;
1020 resultForMonitor = 0;
1021 actual = ptrAudioPolicyServer->TranslateErrorCode(result);
1022 EXPECT_EQ(resultForMonitor, actual);
1023 }
1024
1025 /**
1026 * @tc.name : Test IsVolumeTypeValid.
1027 * @tc.number: IsVolumeTypeValid_001
1028 * @tc.desc : Test AudioPolicyServer::IsVolumeTypeValid
1029 */
1030 HWTEST(AudioPolicyUnitTest, IsVolumeTypeValid_001, TestSize.Level1)
1031 {
1032 int32_t systemAbilityId = 3009;
1033 bool runOnCreate = false;
1034 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1035
1036 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1037 bool result = ptrAudioPolicyServer->IsVolumeTypeValid(static_cast<AudioStreamType>(-1));
1038 EXPECT_FALSE(result);
1039 }
1040
1041 /**
1042 * @tc.name : Test UpdateMuteStateAccordingToVolLevel.
1043 * @tc.number: UpdateMuteStateAccordingToVolLevel_001
1044 * @tc.desc : Test AudioPolicyServer::UpdateMuteStateAccordingToVolLevel
1045 */
1046 HWTEST(AudioPolicyUnitTest, UpdateMuteStateAccordingToVolLevel_001, TestSize.Level1)
1047 {
1048 int32_t systemAbilityId = 3009;
1049 bool runOnCreate = false;
1050 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1051
1052 AudioStreamType streamType = AudioStreamType::STREAM_MUSIC;
1053 int32_t volumeLevel = 1;
1054 bool mute = true;
1055 ptrAudioPolicyServer->UpdateMuteStateAccordingToVolLevel(streamType, volumeLevel, mute);
1056 }
1057
1058 /**
1059 * @tc.name : Test UpdateMuteStateAccordingToVolLevel.
1060 * @tc.number: UpdateMuteStateAccordingToVolLevel_002
1061 * @tc.desc : Test AudioPolicyServer::UpdateMuteStateAccordingToVolLevel
1062 */
1063 HWTEST(AudioPolicyUnitTest, UpdateMuteStateAccordingToVolLevel_002, TestSize.Level1)
1064 {
1065 int32_t systemAbilityId = 3009;
1066 bool runOnCreate = false;
1067 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1068
1069 AudioStreamType streamType = AudioStreamType::STREAM_MUSIC;
1070 int32_t volumeLevel = 0;
1071 bool mute = false;
1072 ptrAudioPolicyServer->UpdateMuteStateAccordingToVolLevel(streamType, volumeLevel, mute);
1073 }
1074
1075 /**
1076 * @tc.name : Test UpdateMuteStateAccordingToVolLevel.
1077 * @tc.number: UpdateMuteStateAccordingToVolLevel_003
1078 * @tc.desc : Test AudioPolicyServer::UpdateMuteStateAccordingToVolLevel
1079 */
1080 HWTEST(AudioPolicyUnitTest, UpdateMuteStateAccordingToVolLevel_003, TestSize.Level1)
1081 {
1082 int32_t systemAbilityId = 3009;
1083 bool runOnCreate = false;
1084 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1085
1086 AudioStreamType streamType = AudioStreamType::STREAM_SYSTEM;
1087 int32_t volumeLevel = 1;
1088 bool mute = false;
1089 ptrAudioPolicyServer->UpdateMuteStateAccordingToVolLevel(streamType, volumeLevel, mute);
1090 }
1091
1092 /**
1093 * @tc.name : Test ChangeVolumeOnVoiceAssistant.
1094 * @tc.number: ChangeVolumeOnVoiceAssistant_001
1095 * @tc.desc : Test AudioPolicyServer::ChangeVolumeOnVoiceAssistant
1096 */
1097 HWTEST(AudioPolicyUnitTest, ChangeVolumeOnVoiceAssistant_001, TestSize.Level1)
1098 {
1099 int32_t systemAbilityId = 3009;
1100 bool runOnCreate = false;
1101 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1102 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1103 AudioStreamType streamInFocus = AudioStreamType::STREAM_VOICE_ASSISTANT;
1104 ptrAudioPolicyServer->ChangeVolumeOnVoiceAssistant(streamInFocus);
1105 }
1106
1107 /**
1108 * @tc.name : Test MaxOrMinVolumeOption.
1109 * @tc.number: MaxOrMinVolumeOption_001
1110 * @tc.desc : Test AudioPolicyServer::MaxOrMinVolumeOption
1111 */
1112 #ifdef FEATURE_MULTIMODALINPUT_INPUT
1113 HWTEST(AudioPolicyUnitTest, MaxOrMinVolumeOption_001, TestSize.Level1)
1114 {
1115 int32_t systemAbilityId = 3009;
1116 bool runOnCreate = false;
1117 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1118 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1119 int32_t volLevel = 20;
1120 int32_t keyType = OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP;
1121 AudioStreamType streamInFocus = AudioStreamType::STREAM_MUSIC;
1122 bool result = ptrAudioPolicyServer->MaxOrMinVolumeOption(volLevel, keyType, streamInFocus);
1123 EXPECT_FALSE(result);
1124 }
1125
1126 /**
1127 * @tc.name : Test MaxOrMinVolumeOption.
1128 * @tc.number: MaxOrMinVolumeOption_002
1129 * @tc.desc : Test AudioPolicyServer::MaxOrMinVolumeOption
1130 */
1131 HWTEST(AudioPolicyUnitTest, MaxOrMinVolumeOption_002, TestSize.Level1)
1132 {
1133 int32_t systemAbilityId = 3009;
1134 bool runOnCreate = false;
1135 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1136 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1137 int32_t volLevel = 0;
1138 int32_t keyType = OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP;
1139 AudioStreamType streamInFocus = AudioStreamType::STREAM_MUSIC;
1140 bool result = ptrAudioPolicyServer->MaxOrMinVolumeOption(volLevel, keyType, streamInFocus);
1141 EXPECT_FALSE(result);
1142 }
1143 #endif
1144
1145 /**
1146 * @tc.name : Test IsVolumeLevelValid.
1147 * @tc.number: IsVolumeLevelValid_001
1148 * @tc.desc : Test AudioPolicyServer::IsVolumeLevelValid
1149 */
1150 HWTEST(AudioPolicyUnitTest, IsVolumeLevelValid_001, TestSize.Level1)
1151 {
1152 int32_t systemAbilityId = 3009;
1153 bool runOnCreate = false;
1154 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1155 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1156 AudioStreamType streamType = AudioStreamType::STREAM_MUSIC;
1157 int32_t volumeLevel = 20;
1158 bool result = ptrAudioPolicyServer->IsVolumeLevelValid(streamType, volumeLevel);
1159 EXPECT_FALSE(result);
1160 }
1161
1162 /**
1163 * @tc.name : Test GetSystemVolumeInDb.
1164 * @tc.number: GetSystemVolumeInDb_001
1165 * @tc.desc : Test AudioPolicyServer::GetSystemVolumeInDb
1166 */
1167 HWTEST(AudioPolicyUnitTest, GetSystemVolumeInDb_001, TestSize.Level1)
1168 {
1169 int32_t systemAbilityId = 3009;
1170 bool runOnCreate = false;
1171 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1172 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1173 AudioVolumeType volumeType = AudioStreamType::STREAM_MUSIC;
1174 int32_t volumeLevel = 20;
1175 DeviceType deviceType = DeviceType::DEVICE_TYPE_DEFAULT;
1176 float actual = 0;
1177 ptrAudioPolicyServer->GetSystemVolumeInDb(volumeType, volumeLevel, deviceType, actual);
1178 float result = static_cast<float>(ERR_INVALID_PARAM);
1179 EXPECT_EQ(actual, result);
1180 }
1181
1182 /**
1183 * @tc.name : Test IsArmUsbDevice.
1184 * @tc.number: IsArmUsbDevice_001
1185 * @tc.desc : Test AudioPolicyServer::IsArmUsbDevice
1186 */
1187 HWTEST(AudioPolicyUnitTest, IsArmUsbDevice_001, TestSize.Level1)
1188 {
1189 int32_t systemAbilityId = 3009;
1190 bool runOnCreate = false;
1191 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1192 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1193 AudioDeviceDescriptor desc;
1194 desc.deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET;
1195 bool result = ptrAudioPolicyServer->IsArmUsbDevice(desc);
1196 EXPECT_TRUE(result);
1197 }
1198
1199 /**
1200 * @tc.name : Test IsArmUsbDevice.
1201 * @tc.number: IsArmUsbDevice_002
1202 * @tc.desc : Test AudioPolicyServer::IsArmUsbDevice
1203 */
1204 HWTEST(AudioPolicyUnitTest, IsArmUsbDevice_002, TestSize.Level1)
1205 {
1206 auto ptrAudioPolicyServer = GetPolicyServerUnitTest();
1207 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1208 AudioDeviceDescriptor desc;
1209 desc.deviceType_ = DEVICE_TYPE_USB_HEADSET;
1210 bool result = ptrAudioPolicyServer->IsArmUsbDevice(desc);
1211 EXPECT_FALSE(result);
1212 }
1213
1214 /**
1215 * @tc.name : Test MapExternalToInternalDeviceType.
1216 * @tc.number: MapExternalToInternalDeviceType_001
1217 * @tc.desc : Test AudioPolicyServer::MapExternalToInternalDeviceType
1218 */
1219 HWTEST(AudioPolicyUnitTest, MapExternalToInternalDeviceType_001, TestSize.Level1)
1220 {
1221 int32_t systemAbilityId = 3009;
1222 bool runOnCreate = false;
1223 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1224 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1225 AudioDeviceDescriptor desc;
1226 desc.deviceType_ = DEVICE_TYPE_USB_HEADSET;
1227 desc.deviceId_ = 0;
1228 auto ptrAudioDeviceDescriptor = std::make_shared<AudioDeviceDescriptor>(desc);
1229 EXPECT_NE(ptrAudioDeviceDescriptor, nullptr);
1230 ptrAudioPolicyServer->audioDeviceManager_.connectedDevices_.push_back(ptrAudioDeviceDescriptor);
1231 ptrAudioPolicyServer->MapExternalToInternalDeviceType(desc);
1232 }
1233
1234 /**
1235 * @tc.name : Test MapExternalToInternalDeviceType.
1236 * @tc.number: MapExternalToInternalDeviceType_002
1237 * @tc.desc : Test AudioPolicyServer::MapExternalToInternalDeviceType
1238 */
1239 HWTEST(AudioPolicyUnitTest, MapExternalToInternalDeviceType_002, TestSize.Level1)
1240 {
1241 int32_t systemAbilityId = 3009;
1242 bool runOnCreate = false;
1243 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1244 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1245 AudioDeviceDescriptor desc;
1246 desc.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP;
1247 desc.deviceRole_ == INPUT_DEVICE;
1248 auto ptrAudioDeviceDescriptor = std::make_shared<AudioDeviceDescriptor>(desc);
1249 EXPECT_NE(ptrAudioDeviceDescriptor, nullptr);
1250 ptrAudioPolicyServer->audioDeviceManager_.connectedDevices_.push_back(ptrAudioDeviceDescriptor);
1251 ptrAudioPolicyServer->MapExternalToInternalDeviceType(desc);
1252 }
1253
1254 /**
1255 * @tc.name : Test MapExternalToInternalDeviceType.
1256 * @tc.number: MapExternalToInternalDeviceType_003
1257 * @tc.desc : Test MapExternalToInternalDeviceType
1258 */
1259 HWTEST(AudioPolicyUnitTest, MapExternalToInternalDeviceType_003, TestSize.Level1)
1260 {
1261 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
1262 ASSERT_TRUE(server != nullptr);
1263 AudioDeviceDescriptor desc;
1264
1265 desc.deviceType_ == DEVICE_TYPE_NEARLINK;
1266 desc.deviceRole_ == INPUT_DEVICE;
1267 server->MapExternalToInternalDeviceType(desc);
1268 EXPECT_EQ(desc.deviceType_, DEVICE_TYPE_NONE);
1269
1270 desc.deviceType_ == DEVICE_TYPE_BLUETOOTH_A2DP;
1271 desc.deviceRole_ == INPUT_DEVICE;
1272 server->MapExternalToInternalDeviceType(desc);
1273 EXPECT_EQ(desc.deviceType_, DEVICE_TYPE_NONE);
1274 }
1275
1276 /**
1277 * @tc.name : Test SetNearlinkDeviceVolume.
1278 * @tc.number: SetNearlinkDeviceVolume_001
1279 * @tc.desc : Test SetNearlinkDeviceVolume
1280 */
1281 HWTEST(AudioPolicyUnitTest, SetNearlinkDeviceVolume_001, TestSize.Level1)
1282 {
1283 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
1284 ASSERT_TRUE(server != nullptr);
1285
1286 std::string macAddress = "LocalDevice";
1287 int32_t streamTypeIn = 1;
1288 int32_t volume = 0;
1289 bool updateUi =true;
1290
1291 int32_t ret = server->SetNearlinkDeviceVolume(macAddress, streamTypeIn, volume, updateUi);
1292
1293
1294 EXPECT_EQ(ret, ERR_PERMISSION_DENIED);
1295 }
1296
1297 /**
1298 * @tc.name : Test UpdateDeviceInfo.
1299 * @tc.number: UpdateDeviceInfo_001
1300 * @tc.desc : Test UpdateDeviceInfo.
1301 */
1302 HWTEST(AudioPolicyUnitTest, UpdateDeviceInfo_001, TestSize.Level1)
1303 {
1304 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
1305 ASSERT_TRUE(server != nullptr);
1306
1307 std::shared_ptr<AudioDeviceDescriptor> deviceDesc =
1308 std::make_shared<AudioDeviceDescriptor>();
1309 int32_t command = 1;
1310
1311 int32_t ret = server->UpdateDeviceInfo(deviceDesc, command);
1312 EXPECT_EQ(ERR_PERMISSION_DENIED, ret);
1313 }
1314
1315 /**
1316 * @tc.name : Test SetSleAudioOperationCallback.
1317 * @tc.number: SetSleAudioOperationCallback_001
1318 * @tc.desc : Test SetSleAudioOperationCallback.
1319 */
1320 HWTEST(AudioPolicyUnitTest, SetSleAudioOperationCallback_001, TestSize.Level1)
1321 {
1322 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
1323 ASSERT_TRUE(server != nullptr);
1324
1325 sptr<IRemoteObject> objectct = nullptr;
1326
1327 int32_t ret = server->SetSleAudioOperationCallback(objectct);
1328 EXPECT_EQ(ERR_INVALID_PARAM, ret);
1329
1330 sptr<IRemoteObject> object = new RemoteObjectTestStub();
1331
1332 ret = server->SetSleAudioOperationCallback(objectct);
1333 EXPECT_EQ(ERR_INVALID_PARAM, ret);
1334 }
1335
1336 /**
1337 * @tc.name : Test SetCallbackCapturerInfo.
1338 * @tc.number: SetCallbackCapturerInfo_001
1339 * @tc.desc : Test AudioPolicyServer::SetCallbackCapturerInfo
1340 */
1341 HWTEST(AudioPolicyUnitTest, SetCallbackCapturerInfo_001, TestSize.Level1)
1342 {
1343 int32_t systemAbilityId = 3009;
1344 bool runOnCreate = false;
1345 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1346 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1347 SourceType sourceType = SOURCE_TYPE_INVALID;
1348 int32_t capturerFlags = 0;
1349 AudioCapturerInfo audioCapturerInfo(sourceType, capturerFlags);
1350 int32_t result = ptrAudioPolicyServer->SetCallbackCapturerInfo(audioCapturerInfo);
1351 EXPECT_EQ(result, SUCCESS);
1352 }
1353
1354 /**
1355 * @tc.name : Test SetAudioScene.
1356 * @tc.number: SetAudioScene_001
1357 * @tc.desc : Test AudioPolicyServer::SetAudioScene
1358 */
1359 HWTEST(AudioPolicyUnitTest, SetAudioScene_001, TestSize.Level1)
1360 {
1361 int32_t systemAbilityId = 3009;
1362 bool runOnCreate = false;
1363 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1364 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1365 AudioScene audioScene = AUDIO_SCENE_CALL_START;
1366 int32_t result = ptrAudioPolicyServer->SetAudioScene(audioScene);
1367 EXPECT_NE(result, SUCCESS);
1368 }
1369
1370 /**
1371 * @tc.name : Test SetAudioInterruptCallback.
1372 * @tc.number: SetAudioInterruptCallback_001
1373 * @tc.desc : Test AudioPolicyServer::SetAudioInterruptCallback
1374 */
1375 HWTEST(AudioPolicyUnitTest, SetAudioInterruptCallback_001, TestSize.Level1)
1376 {
1377 int32_t systemAbilityId = 3009;
1378 bool runOnCreate = false;
1379 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1380 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1381 uint32_t sessionID = 0;
1382 sptr<IRemoteObject> object = nullptr;
1383 uint32_t clientUid = 0;
1384 int32_t zoneID = 0;
1385 int32_t result = ptrAudioPolicyServer->SetAudioInterruptCallback(sessionID, object, clientUid, zoneID);
1386 EXPECT_EQ(result, ERR_UNKNOWN);
1387 }
1388
1389 /**
1390 * @tc.name : Test GetStreamVolumeInfoMap.
1391 * @tc.number: GetStreamVolumeInfoMap_001
1392 * @tc.desc : Test AudioPolicyServer::GetStreamVolumeInfoMap
1393 */
1394 HWTEST(AudioPolicyUnitTest, GetStreamVolumeInfoMap_001, TestSize.Level1)
1395 {
1396 int32_t systemAbilityId = 3009;
1397 bool runOnCreate = false;
1398 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1399 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1400 StreamVolumeInfoMap streamVolumeInfos;
1401 ptrAudioPolicyServer->GetStreamVolumeInfoMap(streamVolumeInfos);
1402 }
1403
1404 /**
1405 * @tc.name : Test InitPolicyDumpMap.
1406 * @tc.number: InitPolicyDumpMap_001
1407 * @tc.desc : Test AudioPolicyServer::InitPolicyDumpMap
1408 */
1409 HWTEST(AudioPolicyUnitTest, InitPolicyDumpMap_001, TestSize.Level1)
1410 {
1411 int32_t systemAbilityId = 3009;
1412 bool runOnCreate = false;
1413 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1414 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1415 ptrAudioPolicyServer->InitPolicyDumpMap();
1416 }
1417
1418 /**
1419 * @tc.name : Test AudioDevicesDump.
1420 * @tc.number: AudioDevicesDump_001
1421 * @tc.desc : Test AudioPolicyServer::AudioDevicesDump
1422 */
1423 HWTEST(AudioPolicyUnitTest, AudioDevicesDump_001, TestSize.Level1)
1424 {
1425 int32_t systemAbilityId = 3009;
1426 bool runOnCreate = false;
1427 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1428 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1429 std::string dumpString = "";
1430 ptrAudioPolicyServer->AudioDevicesDump(dumpString);
1431 }
1432
1433 /**
1434 * @tc.name : Test AudioModeDump.
1435 * @tc.number: AudioModeDump_001
1436 * @tc.desc : Test AudioPolicyServer::AudioModeDump
1437 */
1438 HWTEST(AudioPolicyUnitTest, AudioModeDump_001, TestSize.Level1)
1439 {
1440 int32_t systemAbilityId = 3009;
1441 bool runOnCreate = false;
1442 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1443 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1444 std::string dumpString = "";
1445 ptrAudioPolicyServer->AudioModeDump(dumpString);
1446 }
1447
1448 /**
1449 * @tc.name : Test AudioVolumeDump.
1450 * @tc.number: AudioVolumeDump_001
1451 * @tc.desc : Test AudioPolicyServer::AudioVolumeDump
1452 */
1453 HWTEST(AudioPolicyUnitTest, AudioVolumeDump_001, TestSize.Level1)
1454 {
1455 int32_t systemAbilityId = 3009;
1456 bool runOnCreate = false;
1457 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1458 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1459 std::string dumpString = "";
1460 ptrAudioPolicyServer->AudioVolumeDump(dumpString);
1461 }
1462
1463 /**
1464 * @tc.name : Test AudioPolicyParserDump.
1465 * @tc.number: AudioPolicyParserDump_001
1466 * @tc.desc : Test AudioPolicyServer::AudioPolicyParserDump
1467 */
1468 HWTEST(AudioPolicyUnitTest, AudioPolicyParserDump_001, TestSize.Level1)
1469 {
1470 int32_t systemAbilityId = 3009;
1471 bool runOnCreate = false;
1472 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1473 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1474 std::string dumpString = "";
1475 ptrAudioPolicyServer->AudioPolicyParserDump(dumpString);
1476 }
1477
1478 /**
1479 * @tc.name : Test AudioStreamDump.
1480 * @tc.number: AudioStreamDump_001
1481 * @tc.desc : Test AudioPolicyServer::AudioStreamDump
1482 */
1483 HWTEST(AudioPolicyUnitTest, AudioStreamDump_001, TestSize.Level1)
1484 {
1485 int32_t systemAbilityId = 3009;
1486 bool runOnCreate = false;
1487 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1488 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1489 std::string dumpString = "";
1490 ptrAudioPolicyServer->AudioStreamDump(dumpString);
1491 }
1492
1493 /**
1494 * @tc.name : Test XmlParsedDataMapDump.
1495 * @tc.number: XmlParsedDataMapDump_001
1496 * @tc.desc : Test AudioPolicyServer::XmlParsedDataMapDump
1497 */
1498 HWTEST(AudioPolicyUnitTest, XmlParsedDataMapDump_001, TestSize.Level1)
1499 {
1500 int32_t systemAbilityId = 3009;
1501 bool runOnCreate = false;
1502 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1503 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1504 std::string dumpString = "";
1505 ptrAudioPolicyServer->XmlParsedDataMapDump(dumpString);
1506 }
1507
1508 /**
1509 * @tc.name : Test EffectManagerInfoDump.
1510 * @tc.number: EffectManagerInfoDump_001
1511 * @tc.desc : Test AudioPolicyServer::EffectManagerInfoDump
1512 */
1513 HWTEST(AudioPolicyUnitTest, EffectManagerInfoDump_001, TestSize.Level1)
1514 {
1515 int32_t systemAbilityId = 3009;
1516 bool runOnCreate = false;
1517 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1518 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1519 std::string dumpString = "";
1520 ptrAudioPolicyServer->EffectManagerInfoDump(dumpString);
1521 }
1522
1523 /**
1524 * @tc.name : Test MicrophoneMuteInfoDump.
1525 * @tc.number: MicrophoneMuteInfoDump_001
1526 * @tc.desc : Test AudioPolicyServer::MicrophoneMuteInfoDump
1527 */
1528 HWTEST(AudioPolicyUnitTest, MicrophoneMuteInfoDump_001, TestSize.Level1)
1529 {
1530 int32_t systemAbilityId = 3009;
1531 bool runOnCreate = false;
1532 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1533 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1534 std::string dumpString = "";
1535 ptrAudioPolicyServer->MicrophoneMuteInfoDump(dumpString);
1536 }
1537
1538 /**
1539 * @tc.name : Test ChangeVolumeOnVoiceAssistant.
1540 * @tc.number: ChangeVolumeOnVoiceAssistant_002
1541 * @tc.desc : Test AudioPolicyServer::ChangeVolumeOnVoiceAssistant
1542 */
1543 HWTEST(AudioPolicyUnitTest, ChangeVolumeOnVoiceAssistant_002, TestSize.Level1)
1544 {
1545 int32_t systemAbilityId = 3009;
1546 bool runOnCreate = false;
1547 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1548 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1549 AudioStreamType streamInFocus = AudioStreamType::STREAM_DEFAULT;
1550 ptrAudioPolicyServer->ChangeVolumeOnVoiceAssistant(streamInFocus);
1551 }
1552 /**
1553 * @tc.name : Test AudioPolicyServer.
1554 * @tc.number: AudioPolicyServer_046
1555 * @tc.desc : Test AudioPolicyServer::GetSystemVolumeLevelNoMuteState
1556 */
1557 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_046, TestSize.Level1)
1558 {
1559 int32_t systemAbilityId = 3009;
1560 bool runOnCreate = false;
1561 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1562 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1563 ptrAudioPolicyServer->volumeApplyToAll_ = true;
1564 ptrAudioPolicyServer->isScreenOffOrLock_ = true;
1565
1566 int32_t keyType = OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP;
1567 int32_t ret = ptrAudioPolicyServer->ProcessVolumeKeyEvents(keyType);
1568 EXPECT_EQ(ret, AUDIO_OK);
1569 }
1570 /**
1571 * @tc.name : Test AudioPolicyServer.
1572 * @tc.number: AudioPolicyServer_047
1573 * @tc.desc : Test AudioPolicyServer::GetSystemVolumeLevelNoMuteState
1574 */
1575 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_047, TestSize.Level1)
1576 {
1577 int32_t systemAbilityId = 3009;
1578 bool runOnCreate = false;
1579 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1580 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1581 ptrAudioPolicyServer->volumeApplyToAll_ = true;
1582 ptrAudioPolicyServer->isScreenOffOrLock_ = false;
1583
1584 int32_t keyType = OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP;
1585 int32_t ret = ptrAudioPolicyServer->ProcessVolumeKeyEvents(keyType);
1586 EXPECT_EQ(ret, ERROR_UNSUPPORTED);
1587 }
1588 /**
1589 * @tc.name : Test AudioPolicyServer.
1590 * @tc.number: AudioPolicyServer_048
1591 * @tc.desc : Test AudioPolicyServer::GetSystemVolumeLevelNoMuteState
1592 */
1593 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_048, TestSize.Level1)
1594 {
1595 int32_t systemAbilityId = 3009;
1596 bool runOnCreate = false;
1597 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1598 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1599 ptrAudioPolicyServer->volumeApplyToAll_ = false;
1600 ptrAudioPolicyServer->isScreenOffOrLock_ = true;
1601
1602 int32_t keyType = OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP;
1603 int32_t ret = ptrAudioPolicyServer->ProcessVolumeKeyEvents(keyType);
1604 EXPECT_EQ(ret, AUDIO_OK);
1605 }
1606 /**
1607 * @tc.name : Test AudioPolicyServer.
1608 * @tc.number: AudioPolicyServer_049
1609 * @tc.desc : Test AudioPolicyServer::GetSystemVolumeLevelNoMuteState
1610 */
1611 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_049, TestSize.Level1)
1612 {
1613 int32_t systemAbilityId = 3009;
1614 bool runOnCreate = false;
1615 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1616 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1617 ptrAudioPolicyServer->volumeApplyToAll_ = false;
1618 ptrAudioPolicyServer->isScreenOffOrLock_ = false;
1619
1620 int32_t keyType = OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP;
1621 int32_t ret = ptrAudioPolicyServer->ProcessVolumeKeyEvents(keyType);
1622 EXPECT_EQ(ret, AUDIO_OK);
1623 }
1624 /**
1625 * @tc.name : Test AudioPolicyServer.
1626 * @tc.number: AudioPolicyServer_050
1627 * @tc.desc : Test AudioPolicyServer::GetSystemVolumeLevelNoMuteState
1628 */
1629 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_050, TestSize.Level1)
1630 {
1631 int32_t systemAbilityId = 3009;
1632 bool runOnCreate = false;
1633 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1634 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1635 DeviceType deviceType = DeviceType::DEVICE_TYPE_WIRED_HEADSET;
1636 int32_t ret = ptrAudioPolicyServer->SetStreamMute(AudioStreamType::STREAM_ALL, false, deviceType);
1637 EXPECT_EQ(ret, SUCCESS);
1638 }
1639
1640 /**
1641 * @tc.name : Test AudioPolicyServer.
1642 * @tc.number: AudioPolicyServer_051
1643 * @tc.desc : Test AudioPolicyServer::SetRingerMode
1644 */
1645 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_051, TestSize.Level1)
1646 {
1647 int32_t systemAbilityId = 3009;
1648 bool runOnCreate = false;
1649 auto ptrAudioPolicyServer = std::make_shared<AudioPolicyServer>(systemAbilityId, runOnCreate);
1650 EXPECT_NE(ptrAudioPolicyServer, nullptr);
1651
1652 ptrAudioPolicyServer->coreService_ = std::make_shared<AudioCoreService>();
1653 auto ret = ptrAudioPolicyServer->SetRingerMode(AudioRingerMode::RINGER_MODE_SILENT);
1654 EXPECT_EQ(ret, SUCCESS);
1655 ret = ptrAudioPolicyServer->SetRingerMode(AudioRingerMode::RINGER_MODE_VIBRATE);
1656 EXPECT_EQ(ret, SUCCESS);
1657 ret = ptrAudioPolicyServer->SetRingerMode(AudioRingerMode::RINGER_MODE_NORMAL);
1658 EXPECT_EQ(ret, SUCCESS);
1659 ret = ptrAudioPolicyServer->SetRingerMode(60);
1660 EXPECT_EQ(ret, ERR_INVALID_PARAM);
1661 }
1662
1663 /**
1664 * @tc.name : Test AudioPolicyServer.
1665 * @tc.number: AudioPolicyServer_052
1666 * @tc.desc : Test ArgInfoDump.
1667 */
1668 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_052, TestSize.Level1)
1669 {
1670 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
1671 ASSERT_TRUE(server != nullptr);
1672
1673 std::string dumpString;
1674 std::queue<std::u16string> argQue;
1675 server->ArgInfoDump(dumpString, argQue);
1676 }
1677
1678 /**
1679 * @tc.name : Test AudioPolicyServer.
1680 * @tc.number: AudioPolicyServer_053
1681 * @tc.desc : Test IsHeadTrackingEnabled.
1682 */
1683 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_053, TestSize.Level1)
1684 {
1685 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
1686 ASSERT_TRUE(server != nullptr);
1687
1688 bool ret = false;
1689 server->IsHeadTrackingEnabled(ret);
1690 EXPECT_EQ(ret, false);
1691 }
1692
1693 /**
1694 * @tc.name : Test AudioPolicyServer.
1695 * @tc.number: AudioPolicyServer_054
1696 * @tc.desc : Test IsHeadTrackingEnabled.
1697 */
1698 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_054, TestSize.Level1)
1699 {
1700 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
1701 ASSERT_TRUE(server != nullptr);
1702
1703 std::string address = "test";
1704 bool ret = false;
1705 server->IsHeadTrackingEnabled(address, ret);
1706 EXPECT_EQ(ret, false);
1707 }
1708
1709 #ifdef TEMP_DISABLE
1710 /**
1711 * @tc.name : Test AudioPolicyServer.
1712 * @tc.number: AudioPolicyServer_055
1713 * @tc.desc : Test SetHeadTrackingEnabled.
1714 */
1715 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_055, TestSize.Level1)
1716 {
1717 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
1718 ASSERT_TRUE(server != nullptr);
1719
1720 auto ret = server->SetHeadTrackingEnabled(true);
1721 EXPECT_EQ(ret, SUCCESS);
1722 }
1723 #endif
1724
1725 /**
1726 * @tc.name : Test AudioPolicyServer.
1727 * @tc.number: AudioPolicyServer_056
1728 * @tc.desc : Test IsSpatializationSupported.
1729 */
1730 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_056, TestSize.Level1)
1731 {
1732 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
1733 ASSERT_TRUE(server != nullptr);
1734
1735 bool ret = false;
1736 server->IsSpatializationSupported(ret);
1737 EXPECT_EQ(ret, false);
1738 }
1739
1740 /**
1741 * @tc.name : Test AudioPolicyServer.
1742 * @tc.number: AudioPolicyServer_057
1743 * @tc.desc : Test IsSpatializationSupportedForDevice.
1744 */
1745 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_057, TestSize.Level1)
1746 {
1747 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
1748 ASSERT_TRUE(server != nullptr);
1749
1750 std::string address = "test";
1751 bool ret = false;
1752 server->IsSpatializationSupportedForDevice(address, ret);
1753 EXPECT_EQ(ret, false);
1754 }
1755
1756 /**
1757 * @tc.name : Test AudioPolicyServer.
1758 * @tc.number: AudioPolicyServer_058
1759 * @tc.desc : Test IsHeadTrackingSupported.
1760 */
1761 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_058, TestSize.Level1)
1762 {
1763 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
1764 ASSERT_TRUE(server != nullptr);
1765
1766 bool ret = false;
1767 server->IsHeadTrackingSupported(ret);
1768 EXPECT_EQ(ret, false);
1769 }
1770
1771 /**
1772 * @tc.name : Test AudioPolicyServer.
1773 * @tc.number: AudioPolicyServer_059
1774 * @tc.desc : Test IsHeadTrackingSupportedForDevice.
1775 */
1776 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_059, TestSize.Level1)
1777 {
1778 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
1779 ASSERT_TRUE(server != nullptr);
1780
1781 std::string address = "test";
1782 bool ret;
1783 server->IsHeadTrackingSupportedForDevice(address, ret);
1784 EXPECT_EQ(ret, false);
1785 }
1786
1787 #ifdef TEMP_DISABLE
1788 /**
1789 * @tc.name : Test AudioPolicyServer.
1790 * @tc.number: AudioPolicyServer_060
1791 * @tc.desc : Test UpdateSpatialDeviceState.
1792 */
1793 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_060, TestSize.Level1)
1794 {
1795 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
1796 ASSERT_TRUE(server != nullptr);
1797
1798 AudioSpatialDeviceState audioSpatialDeviceState;
1799 auto ret = server->UpdateSpatialDeviceState(audioSpatialDeviceState);
1800 EXPECT_EQ(ret, SUCCESS);
1801 }
1802 #endif
1803
1804 /**
1805 * @tc.name : Test AudioPolicyServer.
1806 * @tc.number: AudioPolicyServer_061
1807 * @tc.desc : Test SetAudioDeviceRefinerCallback.
1808 */
1809 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_061, TestSize.Level1)
1810 {
1811 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
1812 ASSERT_TRUE(server != nullptr);
1813
1814 sptr<IRemoteObject> object = new RemoteObjectTestStub();
1815 auto ret = server->SetAudioDeviceRefinerCallback(object);
1816 EXPECT_EQ(ret, ERROR);
1817 }
1818
1819 /**
1820 * @tc.name : Test AudioPolicyServer.
1821 * @tc.number: AudioPolicyServer_062
1822 * @tc.desc : Test SetPreferredDevice.
1823 */
1824 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_062, TestSize.Level1)
1825 {
1826 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
1827 ASSERT_TRUE(server != nullptr);
1828
1829 std::shared_ptr<AudioDeviceDescriptor> desc;
1830 int32_t ret = 0;
1831 server->SetPreferredDevice(PreferredType::AUDIO_CALL_CAPTURE, desc, ret);
1832 EXPECT_EQ(ret, SUCCESS);
1833 }
1834
1835 /**
1836 * @tc.name : Test AudioPolicyServer.
1837 * @tc.number: AudioPolicyServer_063
1838 * @tc.desc : Test SetPreferredDevice.
1839 */
1840 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_063, TestSize.Level1)
1841 {
1842 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
1843 ASSERT_TRUE(server != nullptr);
1844
1845 std::string networkId = "test";
1846 VolumeBehavior volumeBehavior;
1847 int32_t result = server->SetDeviceVolumeBehavior(networkId, DeviceType::DEVICE_TYPE_EARPIECE, volumeBehavior);
1848 EXPECT_EQ(result, ERR_PERMISSION_DENIED);
1849 }
1850
1851 /**
1852 * @tc.name : Test AudioPolicyServer.
1853 * @tc.number: AudioPolicyServer_064
1854 * @tc.desc : Test SetAudioDeviceAnahsCallback.
1855 */
1856 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_064, TestSize.Level1)
1857 {
1858 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
1859 ASSERT_TRUE(server != nullptr);
1860
1861 sptr<IRemoteObject> object = new RemoteObjectTestStub();
1862 auto ret = server->SetAudioDeviceAnahsCallback(object);
1863 EXPECT_EQ(ret, ERROR);
1864 }
1865
1866 #ifdef TEMP_DISABLE
1867 /**
1868 * @tc.name : Test AudioPolicyServer.
1869 * @tc.number: AudioPolicyServer_065
1870 * @tc.desc : Test GetSupportedAudioEffectProperty.
1871 */
1872 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_065, TestSize.Level1)
1873 {
1874 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
1875 ASSERT_TRUE(server != nullptr);
1876
1877 AudioEffectPropertyArrayV3 propertyArray;
1878 auto ret = server->GetSupportedAudioEffectProperty(propertyArray);
1879 EXPECT_EQ(ret, AUDIO_OK);
1880 }
1881
1882 /**
1883 * @tc.name : Test AudioPolicyServer.
1884 * @tc.number: AudioPolicyServer_066
1885 * @tc.desc : Test GetSupportedAudioEffectProperty.
1886 */
1887 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_066, TestSize.Level1)
1888 {
1889 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
1890 ASSERT_TRUE(server != nullptr);
1891
1892 AudioEffectPropertyArrayV3 propertyArray;
1893 auto ret = server->SetAudioEffectProperty(propertyArray);
1894 EXPECT_EQ(ret, AUDIO_OK);
1895 }
1896 #endif
1897
1898 /**
1899 * @tc.name : Test AudioPolicyServer.
1900 * @tc.number: AudioPolicyServer_067
1901 * @tc.desc : Test GetAudioEffectProperty.
1902 */
1903 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_067, TestSize.Level1)
1904 {
1905 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
1906 ASSERT_TRUE(server != nullptr);
1907
1908 AudioEffectPropertyArrayV3 propertyArray;
1909 server->GetAudioEffectProperty(propertyArray);
1910 }
1911
1912 /**
1913 * @tc.name : Test AudioPolicyServer.
1914 * @tc.number: AudioPolicyServer_068
1915 * @tc.desc : Test SetDeviceAbsVolumeSupported.
1916 */
1917 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_068, TestSize.Level1)
1918 {
1919 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
1920 ASSERT_TRUE(server != nullptr);
1921
1922 std::string macAddress = "test";
1923 bool support = true;
1924 auto ret = server->SetDeviceAbsVolumeSupported(macAddress, support);
1925 EXPECT_EQ(ret, ERROR);
1926 }
1927
1928 /**
1929 * @tc.name : Test AudioPolicyServer.
1930 * @tc.number: AudioPolicyServer_069
1931 * @tc.desc : Test SetA2dpDeviceVolume.
1932 */
1933 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_069, TestSize.Level1)
1934 {
1935 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
1936 ASSERT_TRUE(server != nullptr);
1937
1938 std::string macAddress = "test";
1939 int32_t volume = 1;
1940 bool updateUi = true;
1941 auto ret = server->SetA2dpDeviceVolume(macAddress, volume, updateUi);
1942 EXPECT_EQ(ret, ERROR);
1943 }
1944
1945 /**
1946 * @tc.name : Test AudioPolicyServer.
1947 * @tc.number: AudioPolicyServer_070
1948 * @tc.desc : Test GetAvailableDevices.
1949 */
1950 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_070, TestSize.Level1)
1951 {
1952 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
1953 ASSERT_TRUE(server != nullptr);
1954
1955 server->coreService_ = AudioCoreService::GetCoreService();
1956 server->eventEntry_ = server->coreService_->GetEventEntry();
1957 std::vector<std::shared_ptr<AudioDeviceDescriptor>> ret;
1958 server->GetAvailableDevices(AudioDeviceUsage::ALL_CALL_DEVICES, ret);
1959 EXPECT_NE(ret.size(), 0);
1960 }
1961
1962 /**
1963 * @tc.name : Test AudioPolicyServer.
1964 * @tc.number: AudioPolicyServer_071
1965 * @tc.desc : Test GetAvailableDevices.
1966 */
1967 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_071, TestSize.Level1)
1968 {
1969 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
1970 ASSERT_TRUE(server != nullptr);
1971
1972 int32_t deviceUsage = -1;
1973 AudioDeviceUsage usge = static_cast<AudioDeviceUsage>(deviceUsage);
1974 std::vector<std::shared_ptr<AudioDeviceDescriptor>> ret;
1975 server->GetAvailableDevices(usge, ret);
1976 EXPECT_EQ(ret.size(), 0);
1977 }
1978
1979 /**
1980 * @tc.name : Test AudioPolicyServer.
1981 * @tc.number: AudioPolicyServer_072
1982 * @tc.desc : Test SetAvailableDeviceChangeCallback.
1983 */
1984 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_072, TestSize.Level1)
1985 {
1986 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
1987 ASSERT_TRUE(server != nullptr);
1988
1989 int32_t clientId = 0;
1990 sptr<IRemoteObject> object = new RemoteObjectTestStub();
1991 auto ret = server->SetAvailableDeviceChangeCallback(clientId, AudioDeviceUsage::ALL_CALL_DEVICES, object);
1992 EXPECT_EQ(ret, AUDIO_OK);
1993 }
1994
1995 /**
1996 * @tc.name : Test AudioPolicyServer.
1997 * @tc.number: AudioPolicyServer_073
1998 * @tc.desc : Test SetAvailableDeviceChangeCallback.
1999 */
2000 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_073, TestSize.Level1)
2001 {
2002 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2003 ASSERT_TRUE(server != nullptr);
2004
2005 int32_t clientId = 0;
2006 int32_t deviceUsage = -1;
2007 AudioDeviceUsage usge = static_cast<AudioDeviceUsage>(deviceUsage);
2008 sptr<IRemoteObject> object = new RemoteObjectTestStub();
2009 auto ret = server->SetAvailableDeviceChangeCallback(clientId, usge, object);
2010 EXPECT_EQ(ret, ERR_INVALID_PARAM);
2011 }
2012
2013 #ifdef TEMP_DISABLE
2014 /**
2015 * @tc.name : Test AudioPolicyServer.
2016 * @tc.number: AudioPolicyServer_074
2017 * @tc.desc : Test ConfigDistributedRoutingRole.
2018 */
2019 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_074, TestSize.Level1)
2020 {
2021 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2022 ASSERT_TRUE(server != nullptr);
2023
2024 std::shared_ptr<AudioDeviceDescriptor> descriptor;
2025 server->coreService_ = AudioCoreService::GetCoreService();
2026 auto ret = server->ConfigDistributedRoutingRole(descriptor, CastType::CAST_TYPE_ALL);
2027 EXPECT_EQ(ret, SUCCESS);
2028 }
2029 #endif
2030
2031 /**
2032 * @tc.name : Test AudioPolicyServer.
2033 * @tc.number: AudioPolicyServer_075
2034 * @tc.desc : Test SetDistributedRoutingRoleCallback.
2035 */
2036 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_075, TestSize.Level1)
2037 {
2038 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2039 ASSERT_TRUE(server != nullptr);
2040
2041 server->audioPolicyServerHandler_ = nullptr;
2042 sptr<IRemoteObject> object = new RemoteObjectTestStub();
2043 auto ret = server->SetDistributedRoutingRoleCallback(object);
2044 EXPECT_EQ(ret, SUCCESS);
2045
2046 server->audioPolicyServerHandler_ = std::make_shared<AudioPolicyServerHandler>();
2047 ret = server->SetDistributedRoutingRoleCallback(object);
2048 EXPECT_EQ(ret, SUCCESS);
2049 }
2050
2051 /**
2052 * @tc.name : Test AudioPolicyServer.
2053 * @tc.number: AudioPolicyServer_076
2054 * @tc.desc : Test UnsetDistributedRoutingRoleCallback.
2055 */
2056 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_076, TestSize.Level1)
2057 {
2058 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2059 ASSERT_TRUE(server != nullptr);
2060
2061 server->audioPolicyServerHandler_ = nullptr;
2062 auto ret = server->UnsetDistributedRoutingRoleCallback();
2063 EXPECT_EQ(ret, SUCCESS);
2064
2065 server->audioPolicyServerHandler_ = std::make_shared<AudioPolicyServerHandler>();
2066 ret = server->UnsetDistributedRoutingRoleCallback();
2067 }
2068
2069 /**
2070 * @tc.name : Test AudioPolicyServer.
2071 * @tc.number: AudioPolicyServer_077
2072 * @tc.desc : Test RegisterPowerStateListener.
2073 */
2074 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_077, TestSize.Level1)
2075 {
2076 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2077 ASSERT_TRUE(server != nullptr);
2078
2079 server->RegisterPowerStateListener();
2080 }
2081
2082 /**
2083 * @tc.name : Test AudioPolicyServer.
2084 * @tc.number: AudioPolicyServer_078
2085 * @tc.desc : Test UnRegisterPowerStateListener.
2086 */
2087 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_078, TestSize.Level1)
2088 {
2089 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2090 ASSERT_TRUE(server != nullptr);
2091
2092 server->powerStateListener_ = nullptr;
2093 server->UnRegisterPowerStateListener();
2094
2095 server->powerStateListener_ = new PowerStateListener(server);
2096 server->UnRegisterPowerStateListener();
2097 }
2098
2099 /**
2100 * @tc.name : Test AudioPolicyServer.
2101 * @tc.number: AudioPolicyServer_079
2102 * @tc.desc : Test RegisterAppStateListener.
2103 */
2104 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_079, TestSize.Level1)
2105 {
2106 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2107 ASSERT_TRUE(server != nullptr);
2108
2109 server->appStateListener_ = nullptr;
2110 server->RegisterAppStateListener();
2111
2112 server->appStateListener_ = new AppStateListener();
2113 server->RegisterAppStateListener();
2114 }
2115
2116 /**
2117 * @tc.name : Test AudioPolicyServer.
2118 * @tc.number: AudioPolicyServer_080
2119 * @tc.desc : Test RegisterSyncHibernateListener.
2120 */
2121 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_080, TestSize.Level1)
2122 {
2123 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2124 ASSERT_TRUE(server != nullptr);
2125
2126 server->syncHibernateListener_ = nullptr;
2127 server->RegisterSyncHibernateListener();
2128
2129 server->syncHibernateListener_ = new SyncHibernateListener(server);
2130 server->RegisterSyncHibernateListener();
2131 }
2132
2133 /**
2134 * @tc.name : Test AudioPolicyServer.
2135 * @tc.number: AudioPolicyServer_081
2136 * @tc.desc : Test UnRegisterSyncHibernateListener.
2137 */
2138 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_081, TestSize.Level1)
2139 {
2140 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2141 ASSERT_TRUE(server != nullptr);
2142
2143 server->syncHibernateListener_ = nullptr;
2144 server->UnRegisterSyncHibernateListener();
2145
2146 server->syncHibernateListener_ = new SyncHibernateListener(server);
2147 server->UnRegisterSyncHibernateListener();
2148 }
2149
2150 /**
2151 * @tc.name : Test AudioPolicyServer.
2152 * @tc.number: AudioPolicyServer_082
2153 * @tc.desc : Test IsSpatializationEnabled.
2154 */
2155 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_082, TestSize.Level1)
2156 {
2157 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2158 ASSERT_TRUE(server != nullptr);
2159
2160 bool ret = false;
2161 server->IsSpatializationEnabled(ret);
2162 EXPECT_EQ(ret, false);
2163 }
2164
2165 /**
2166 * @tc.name : Test AudioPolicyServer.
2167 * @tc.number: AudioPolicyServer_083
2168 * @tc.desc : Test IsSpatializationEnabled.
2169 */
2170 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_083, TestSize.Level1)
2171 {
2172 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2173 ASSERT_TRUE(server != nullptr);
2174
2175 std::string address = "test";
2176 auto ret = false;
2177 server->IsSpatializationEnabled(address, ret);
2178 EXPECT_EQ(ret, false);
2179 }
2180
2181 #ifdef TEMP_DISABLE
2182 /**
2183 * @tc.name : Test AudioPolicyServer.
2184 * @tc.number: AudioPolicyServer_084
2185 * @tc.desc : Test SetSpatializationEnabled.
2186 */
2187 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_084, TestSize.Level1)
2188 {
2189 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2190 ASSERT_TRUE(server != nullptr);
2191
2192 auto ret = server->SetSpatializationEnabled(true);
2193 EXPECT_EQ(ret, SUCCESS);
2194 }
2195
2196 /**
2197 * @tc.name : Test AudioPolicyServer.
2198 * @tc.number: AudioPolicyServer_085
2199 * @tc.desc : Test SetSpatializationEnabled.
2200 */
2201 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_085, TestSize.Level1)
2202 {
2203 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2204 ASSERT_TRUE(server != nullptr);
2205
2206 std::shared_ptr<AudioDeviceDescriptor> selectedAudioDevice = std::make_shared<AudioDeviceDescriptor>();
2207 auto ret = server->SetSpatializationEnabled(selectedAudioDevice, true);
2208 EXPECT_EQ(ret, SUCCESS);
2209 }
2210 #endif
2211
2212 /**
2213 * @tc.name : Test AudioPolicyServer.
2214 * @tc.number: AudioPolicyServer_086
2215 * @tc.desc : Test UpdateTracker.
2216 */
2217 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_086, TestSize.Level1)
2218 {
2219 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2220 ASSERT_TRUE(server != nullptr);
2221
2222 AudioStreamChangeInfo streamChangeInfo;
2223 AudioMode mode = AudioMode::AUDIO_MODE_PLAYBACK;
2224 streamChangeInfo.audioRendererChangeInfo.rendererState = RENDERER_PAUSED;
2225 auto ret = server->UpdateTracker(mode, streamChangeInfo);
2226 EXPECT_EQ(ret, SUCCESS);
2227
2228 streamChangeInfo.audioRendererChangeInfo.rendererState = RENDERER_STOPPED;
2229 ret = server->UpdateTracker(mode, streamChangeInfo);
2230 EXPECT_EQ(ret, SUCCESS);
2231
2232 streamChangeInfo.audioRendererChangeInfo.rendererState = RENDERER_RELEASED;
2233 ret = server->UpdateTracker(mode, streamChangeInfo);
2234 EXPECT_EQ(ret, SUCCESS);
2235
2236 streamChangeInfo.audioRendererChangeInfo.rendererState = RENDERER_RUNNING;
2237 ret = server->UpdateTracker(mode, streamChangeInfo);
2238 EXPECT_EQ(ret, SUCCESS);
2239 }
2240
2241 /**
2242 * @tc.name : Test AudioPolicyServer.
2243 * @tc.number: AudioPolicyServer_087
2244 * @tc.desc : Test FetchOutputDeviceForTrack.
2245 */
2246 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_087, TestSize.Level1)
2247 {
2248 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2249 ASSERT_TRUE(server != nullptr);
2250
2251 AudioStreamChangeInfo streamChangeInfo;
2252 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::NEW_DEVICE_AVAILABLE;
2253 server->FetchOutputDeviceForTrack(streamChangeInfo, reason);
2254 }
2255
2256 /**
2257 * @tc.name : Test AudioPolicyServer.
2258 * @tc.number: AudioPolicyServer_088
2259 * @tc.desc : Test FetchInputDeviceForTrack.
2260 */
2261 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_088, TestSize.Level1)
2262 {
2263 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2264 ASSERT_TRUE(server != nullptr);
2265
2266 AudioStreamChangeInfo streamChangeInfo;
2267 server->FetchInputDeviceForTrack(streamChangeInfo);
2268 }
2269
2270 /**
2271 * @tc.name : Test AudioPolicyServer.
2272 * @tc.number: AudioPolicyServer_093
2273 * @tc.desc : Test GetNetworkIdByGroupId.
2274 */
2275 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_093, TestSize.Level1)
2276 {
2277 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2278 ASSERT_TRUE(server != nullptr);
2279
2280 int32_t groupId = 0;
2281 std::string networkId = "test";
2282 auto ret = server->GetNetworkIdByGroupId(groupId, networkId);
2283 EXPECT_EQ(ret, ERROR);
2284 }
2285
2286 #ifdef TEMP_DISABLE
2287 /**
2288 * @tc.name : Test AudioPolicyServer.
2289 * @tc.number: AudioPolicyServer_094
2290 * @tc.desc : Test SetSystemSoundUri.
2291 */
2292 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_094, TestSize.Level1)
2293 {
2294 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2295 ASSERT_TRUE(server != nullptr);
2296
2297 std::string key = "test";
2298 std::string uri = "test";
2299 auto ret = server->SetSystemSoundUri(key, uri);
2300 EXPECT_EQ(ret, ERR_INVALID_PARAM);
2301 }
2302 #endif
2303
2304 /**
2305 * @tc.name : Test AudioPolicyServer.
2306 * @tc.number: AudioPolicyServer_095
2307 * @tc.desc : Test GetSystemSoundUri.
2308 */
2309 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_095, TestSize.Level1)
2310 {
2311 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2312 ASSERT_TRUE(server != nullptr);
2313
2314 std::string key = "test";
2315 std::string ret;
2316 server->GetSystemSoundUri(key, ret);
2317 EXPECT_EQ(ret, "");
2318 }
2319
2320 /**
2321 * @tc.name : Test AudioPolicyServer.
2322 * @tc.number: AudioPolicyServer_096
2323 * @tc.desc : Test GetMaxRendererInstances.
2324 */
2325 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_096, TestSize.Level1)
2326 {
2327 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2328 ASSERT_TRUE(server != nullptr);
2329
2330 int32_t ret = 0;
2331 server->isFirstAudioServiceStart_.store(true);
2332 server->GetMaxRendererInstances(ret);
2333 EXPECT_NE(ret, SUCCESS);
2334 }
2335
2336 /**
2337 * @tc.name : Test AudioPolicyServer.
2338 * @tc.number: AudioPolicyServer_097
2339 * @tc.desc : Test GetMaxRendererInstances.
2340 */
2341 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_097, TestSize.Level1)
2342 {
2343 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2344 ASSERT_TRUE(server != nullptr);
2345
2346 int32_t ret = 0;
2347 server->isFirstAudioServiceStart_.store(false);
2348 server->GetMaxRendererInstances(ret);
2349 EXPECT_NE(ret, SUCCESS);
2350 }
2351
2352 /**
2353 * @tc.name : Test AudioPolicyServer.
2354 * @tc.number: AudioPolicyServer_098
2355 * @tc.desc : Test GetPreferredOutputDeviceDescriptors.
2356 */
2357 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_098, TestSize.Level1)
2358 {
2359 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2360 ASSERT_TRUE(server != nullptr);
2361
2362 AudioRendererInfo rendererInfo;
2363 std::vector<std::shared_ptr<AudioDeviceDescriptor>> deviceDescs;
2364 server->GetPreferredOutputDeviceDescriptors(rendererInfo, true, deviceDescs);
2365 server->GetPreferredOutputDeviceDescriptors(rendererInfo, false, deviceDescs);
2366 }
2367
2368 /**
2369 * @tc.name : Test AudioPolicyServer.
2370 * @tc.number: AudioPolicyServer_099
2371 * @tc.desc : Test SetCallbackRendererInfo.
2372 */
2373 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_099, TestSize.Level1)
2374 {
2375 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2376 ASSERT_TRUE(server != nullptr);
2377
2378 AudioRendererInfo rendererInfo;
2379 server->audioPolicyServerHandler_ = nullptr;
2380 auto ret = server->SetCallbackRendererInfo(rendererInfo);
2381 EXPECT_EQ(ret, SUCCESS);
2382
2383 server->audioPolicyServerHandler_ = std::make_shared<AudioPolicyServerHandler>();
2384 ret = server->SetCallbackRendererInfo(rendererInfo);
2385 EXPECT_EQ(ret, SUCCESS);
2386 }
2387
2388 #ifdef TEMP_DISABLE
2389 /**
2390 * @tc.name : Test AudioPolicyServer.
2391 * @tc.number: AudioPolicyServer_100
2392 * @tc.desc : Test SetInputDevice.
2393 */
2394 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_100, TestSize.Level1)
2395 {
2396 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2397 ASSERT_TRUE(server != nullptr);
2398
2399 uint32_t sessionID = 0;
2400 auto ret = server->SetInputDevice(DeviceType::DEVICE_TYPE_EARPIECE, sessionID,
2401 SourceType::SOURCE_TYPE_INVALID, true);
2402 EXPECT_EQ(ret, SUCCESS);
2403 }
2404 #endif
2405
2406 /**
2407 * @tc.name : Test AudioPolicyServer.
2408 * @tc.number: AudioPolicyServer_101
2409 * @tc.desc : Test GetDmDeviceType.
2410 */
2411 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_101, TestSize.Level1)
2412 {
2413 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2414 ASSERT_TRUE(server != nullptr);
2415
2416 uint16_t deviceType = 0;
2417 server->GetDmDeviceType(deviceType);
2418 EXPECT_EQ(deviceType, 0);
2419 }
2420
2421 /**
2422 * @tc.name : Test AudioPolicyServer.
2423 * @tc.number: AudioPolicyServer_102
2424 * @tc.desc : Test SetRingerModeInner.
2425 */
2426 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_102, TestSize.Level1)
2427 {
2428 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2429 ASSERT_TRUE(server != nullptr);
2430
2431 server->coreService_ = std::make_shared<AudioCoreService>();
2432 auto ret = server->SetRingerModeInner(AudioRingerMode::RINGER_MODE_NORMAL);
2433 EXPECT_EQ(ret, SUCCESS);
2434
2435 ret = server->SetRingerModeInner(AudioRingerMode::RINGER_MODE_SILENT);
2436 EXPECT_EQ(ret, SUCCESS);
2437 }
2438
2439 /**
2440 * @tc.name : Test AudioPolicyServer.
2441 * @tc.number: AudioPolicyServer_103
2442 * @tc.desc : Test SetRingerModeInner.
2443 */
2444 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_103, TestSize.Level1)
2445 {
2446 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2447 ASSERT_TRUE(server != nullptr);
2448
2449 server->SetMicrophoneMuteCommon(true, true);
2450 }
2451
2452 /**
2453 * @tc.name : Test AudioPolicyServer.
2454 * @tc.number: AudioPolicyServer_104
2455 * @tc.desc : Test IsMicrophoneMuteLegacy.
2456 */
2457 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_104, TestSize.Level1)
2458 {
2459 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2460 ASSERT_TRUE(server != nullptr);
2461
2462 bool ret = false;
2463 server->IsMicrophoneMuteLegacy(ret);
2464 EXPECT_EQ(ret, true);
2465 }
2466
2467 /**
2468 * @tc.name : Test AudioPolicyServer.
2469 * @tc.number: AudioPolicyServer_105
2470 * @tc.desc : Test UnsetAudioInterruptCallback.
2471 */
2472 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_105, TestSize.Level1)
2473 {
2474 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2475 ASSERT_TRUE(server != nullptr);
2476
2477 uint32_t sessionID = 0;
2478 int32_t zoneID = 0;
2479 server->interruptService_ = nullptr;
2480 auto ret = server->UnsetAudioInterruptCallback(sessionID, zoneID);
2481 EXPECT_EQ(ret, ERR_UNKNOWN);
2482
2483 server->interruptService_ = std::make_shared<AudioInterruptService>();
2484 server->UnsetAudioInterruptCallback(sessionID, zoneID);
2485 }
2486
2487 #ifdef TEMP_DISABLE
2488 /**
2489 * @tc.name : Test AudioPolicyServer.
2490 * @tc.number: AudioPolicyServer_106
2491 * @tc.desc : Test SetQueryClientTypeCallback.
2492 */
2493 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_106, TestSize.Level1)
2494 {
2495 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2496 ASSERT_TRUE(server != nullptr);
2497
2498 sptr<IRemoteObject> object = new RemoteObjectTestStub();
2499 auto ret = server->SetQueryClientTypeCallback(object);
2500 EXPECT_EQ(ret, SUCCESS);
2501 }
2502
2503 /**
2504 * @tc.name : Test AudioPolicyServer.
2505 * @tc.number: AudioPolicyServer_107
2506 * @tc.desc : Test SetAudioClientInfoMgrCallback.
2507 */
2508 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_107, TestSize.Level1)
2509 {
2510 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2511 ASSERT_TRUE(server != nullptr);
2512
2513 sptr<IRemoteObject> object = new RemoteObjectTestStub();
2514 auto ret = server->SetAudioClientInfoMgrCallback(object);
2515 EXPECT_EQ(ret, SUCCESS);
2516 }
2517 #endif
2518
2519 /**
2520 * @tc.name : Test AudioPolicyServer.
2521 * @tc.number: AudioPolicyServer_108
2522 * @tc.desc : Test SetQueryBundleNameListCallback.
2523 */
2524 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_108, TestSize.Level1)
2525 {
2526 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2527 ASSERT_TRUE(server != nullptr);
2528
2529 sptr<IRemoteObject> object = new RemoteObjectTestStub();
2530 auto ret = server->SetQueryBundleNameListCallback(object);
2531 EXPECT_EQ(ret, SUCCESS);
2532 }
2533
2534 /**
2535 * @tc.name : Test AudioPolicyServer.
2536 * @tc.number: AudioPolicyServer_109
2537 * @tc.desc : Test RequestAudioFocus.
2538 */
2539 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_109, TestSize.Level1)
2540 {
2541 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2542 ASSERT_TRUE(server != nullptr);
2543
2544 int32_t clientId = 0;
2545 AudioInterrupt audioInterrupt;
2546 server->interruptService_ = nullptr;
2547 auto ret = server->RequestAudioFocus(clientId, audioInterrupt);
2548 EXPECT_EQ(ret, ERR_UNKNOWN);
2549
2550 server->interruptService_ = std::make_shared<AudioInterruptService>();
2551 ret = server->RequestAudioFocus(clientId, audioInterrupt);
2552 EXPECT_EQ(ret, SUCCESS);
2553 }
2554
2555 /**
2556 * @tc.name : Test AudioPolicyServer.
2557 * @tc.number: AudioPolicyServer_120
2558 * @tc.desc : Test AbandonAudioFocus.
2559 */
2560 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_120, TestSize.Level1)
2561 {
2562 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2563 ASSERT_TRUE(server != nullptr);
2564
2565 int32_t clientId = 0;
2566 AudioInterrupt audioInterrupt;
2567 server->interruptService_ = nullptr;
2568 auto ret = server->AbandonAudioFocus(clientId, audioInterrupt);
2569 EXPECT_EQ(ret, ERR_UNKNOWN);
2570
2571 server->interruptService_ = std::make_shared<AudioInterruptService>();
2572 ret = server->AbandonAudioFocus(clientId, audioInterrupt);
2573 EXPECT_EQ(ret, SUCCESS);
2574 }
2575
2576 /**
2577 * @tc.name : Test AudioPolicyServer.
2578 * @tc.number: AudioPolicyServer_121
2579 * @tc.desc : Test ProcessRemoteInterrupt.
2580 */
2581 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_121, TestSize.Level1)
2582 {
2583 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2584 ASSERT_TRUE(server != nullptr);
2585
2586 std::set<int32_t> sessionIds;
2587 InterruptEventInternal interruptEvent;
2588 server->interruptService_ = nullptr;
2589 server->ProcessRemoteInterrupt(sessionIds, interruptEvent);
2590
2591 server->interruptService_ = std::make_shared<AudioInterruptService>();
2592 server->ProcessRemoteInterrupt(sessionIds, interruptEvent);
2593 }
2594
2595 /**
2596 * @tc.name : Test AudioPolicyServer.
2597 * @tc.number: AudioPolicyServer_122
2598 * @tc.desc : Test GetStreamInFocusByUid.
2599 */
2600 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_122, TestSize.Level1)
2601 {
2602 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2603 ASSERT_TRUE(server != nullptr);
2604
2605 int32_t uid = 0;
2606 int32_t zoneID = 0;
2607 int32_t ret = 0;
2608 server->GetStreamInFocusByUid(uid, zoneID, ret);
2609 EXPECT_EQ(ret, STREAM_MUSIC);
2610 }
2611
2612 /**
2613 * @tc.name : Test AudioPolicyServer.
2614 * @tc.number: AudioPolicyServer_123
2615 * @tc.desc : Test GetSessionInfoInFocus.
2616 */
2617 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_123, TestSize.Level1)
2618 {
2619 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2620 ASSERT_TRUE(server != nullptr);
2621
2622 AudioInterrupt audioInterrupt;
2623 int32_t zoneID = 0;
2624 server->interruptService_ = nullptr;
2625 auto ret = server->GetSessionInfoInFocus(audioInterrupt, zoneID);
2626 EXPECT_EQ(ret, ERR_UNKNOWN);
2627
2628 server->interruptService_ = std::make_shared<AudioInterruptService>();
2629 ret = server->GetSessionInfoInFocus(audioInterrupt, zoneID);
2630 EXPECT_EQ(ret, SUCCESS);
2631 }
2632
2633 /**
2634 * @tc.name : Test AudioPolicyServer.
2635 * @tc.number: AudioPolicyServer_124
2636 * @tc.desc : Test GetAudioFocusInfoList.
2637 */
2638 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_124, TestSize.Level1)
2639 {
2640 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2641 ASSERT_TRUE(server != nullptr);
2642
2643 std::vector<std::map<AudioInterrupt, int32_t>> focusInfoList;
2644 int32_t zoneID = 0;
2645 server->interruptService_ = nullptr;
2646 auto ret = server->GetAudioFocusInfoList(focusInfoList, zoneID);
2647 EXPECT_EQ(ret, ERR_UNKNOWN);
2648
2649 server->interruptService_ = std::make_shared<AudioInterruptService>();
2650 ret = server->GetAudioFocusInfoList(focusInfoList, zoneID);
2651 EXPECT_EQ(ret, SUCCESS);
2652 }
2653
2654 #ifdef TEMP_DISABLE
2655 /**
2656 * @tc.name : Test AudioPolicyServer.
2657 * @tc.number: AudioPolicyServer_125
2658 * @tc.desc : Test AdjustSystemVolumeByStep.
2659 */
2660 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_125, TestSize.Level1)
2661 {
2662 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2663 ASSERT_TRUE(server != nullptr);
2664
2665 auto ret = server->AdjustSystemVolumeByStep(AudioVolumeType::STREAM_ALL, VolumeAdjustType::VOLUME_UP);
2666 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
2667 }
2668 #endif
2669
2670 /**
2671 * @tc.name : Test AudioPolicyServer.
2672 * @tc.number: AudioPolicyServer_126
2673 * @tc.desc : Test SetStreamMuteInternal.
2674 */
2675 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_126, TestSize.Level1)
2676 {
2677 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2678 ASSERT_TRUE(server != nullptr);
2679
2680 DeviceType deviceType = DEVICE_TYPE_EARPIECE;
2681 auto ret = server->SetStreamMuteInternal(AudioStreamType::STREAM_ALARM, false, true, deviceType);
2682 EXPECT_EQ(ret, SUCCESS);
2683
2684 ret = server->SetStreamMuteInternal(AudioStreamType::STREAM_ALL, false, true, deviceType);
2685 EXPECT_EQ(ret, SUCCESS);
2686 }
2687
2688 /**
2689 * @tc.name : Test AudioPolicyServer.
2690 * @tc.number: AudioPolicyServer_127
2691 * @tc.desc : Test UpdateSystemMuteStateAccordingMusicState.
2692 */
2693 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_127, TestSize.Level1)
2694 {
2695 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2696 ASSERT_TRUE(server != nullptr);
2697
2698 server->UpdateSystemMuteStateAccordingMusicState(AudioStreamType::STREAM_VOICE_CALL_ASSISTANT, false, true);
2699 }
2700
2701 /**
2702 * @tc.name : Test AudioPolicyServer.
2703 * @tc.number: AudioPolicyServer_128
2704 * @tc.desc : Test SendMuteKeyEventCbWithUpdateUiOrNot.
2705 */
2706 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_128, TestSize.Level1)
2707 {
2708 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2709 ASSERT_TRUE(server != nullptr);
2710
2711 bool isUpdateUi = true;
2712 server->audioPolicyServerHandler_ = nullptr;
2713 server->SendMuteKeyEventCbWithUpdateUiOrNot(AudioStreamType::STREAM_VOICE_CALL_ASSISTANT, isUpdateUi);
2714
2715 server->audioPolicyServerHandler_ = std::make_shared<AudioPolicyServerHandler>();
2716 server->SendMuteKeyEventCbWithUpdateUiOrNot(AudioStreamType::STREAM_VOICE_CALL_ASSISTANT, isUpdateUi);
2717 }
2718
2719 /**
2720 * @tc.name : Test AudioPolicyServer.
2721 * @tc.number: AudioPolicyServer_129
2722 * @tc.desc : Test SetSingleStreamMute.
2723 */
2724 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_129, TestSize.Level1)
2725 {
2726 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2727 ASSERT_TRUE(server != nullptr);
2728
2729 DeviceType deviceType = DEVICE_TYPE_EARPIECE;
2730 server->SetSingleStreamMute(AudioStreamType::STREAM_MUSIC, false, true, deviceType);
2731 server->SetSingleStreamMute(AudioStreamType::STREAM_RING, false, true, deviceType);
2732 server->SetSingleStreamMute(AudioStreamType::STREAM_RING, true, true, deviceType);
2733 server->SetSingleStreamMute(AudioStreamType::STREAM_RING, true, false, deviceType);
2734 }
2735
2736 /**
2737 * @tc.name : Test AudioPolicyServer.
2738 * @tc.number: AudioPolicyServer_130
2739 * @tc.desc : Test ProcUpdateRingerModeForMute.
2740 */
2741 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_130, TestSize.Level1)
2742 {
2743 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2744 ASSERT_TRUE(server != nullptr);
2745
2746 server->coreService_ = std::make_shared<AudioCoreService>();
2747 server->ProcUpdateRingerModeForMute(false, true);
2748 server->supportVibrator_ = false;
2749 server->ProcUpdateRingerModeForMute(true, true);
2750
2751 server->supportVibrator_ = true;
2752 server->ProcUpdateRingerModeForMute(true, true);
2753 }
2754
2755 /**
2756 * @tc.name : Test AudioPolicyServer.
2757 * @tc.number: AudioPolicyServer_131
2758 * @tc.desc : Test SetSelfAppVolumeLevel.
2759 */
2760 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_131, TestSize.Level1)
2761 {
2762 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2763 ASSERT_TRUE(server != nullptr);
2764
2765 int32_t volumeLevel = 0;
2766 int32_t volumeFlag = 0;
2767 auto ret = server->SetSelfAppVolumeLevel(volumeLevel, volumeFlag);
2768 EXPECT_EQ(ret, SUCCESS);
2769 }
2770
2771 #ifdef TEMP_DISABLE
2772 /**
2773 * @tc.name : Test AudioPolicyServer.
2774 * @tc.number: AudioPolicyServer_132
2775 * @tc.desc : Test IsAppVolumeMute.
2776 */
2777 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_132, TestSize.Level1)
2778 {
2779 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2780 ASSERT_TRUE(server != nullptr);
2781
2782 int32_t appUid = 0;
2783 bool owned = true;
2784 bool isMute = false;
2785 auto ret = server->IsAppVolumeMute(appUid, owned, isMute);
2786 EXPECT_EQ(ret, SUCCESS);
2787 }
2788 #endif
2789
2790 /**
2791 * @tc.name : Test AudioPolicyServer.
2792 * @tc.number: AudioPolicyServer_133
2793 * @tc.desc : Test SendVolumeKeyEventCbWithUpdateUiOrNot.
2794 */
2795 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_133, TestSize.Level1)
2796 {
2797 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2798 ASSERT_TRUE(server != nullptr);
2799
2800 bool isUpdateUi = true;
2801 server->audioPolicyServerHandler_ = nullptr;
2802 server->SendVolumeKeyEventCbWithUpdateUiOrNot(AudioStreamType::STREAM_VOICE_CALL_ASSISTANT, isUpdateUi);
2803
2804 server->audioPolicyServerHandler_ = std::make_shared<AudioPolicyServerHandler>();
2805 server->SendVolumeKeyEventCbWithUpdateUiOrNot(AudioStreamType::STREAM_VOICE_CALL_ASSISTANT, isUpdateUi);
2806 }
2807
2808 /**
2809 * @tc.name : Test AudioPolicyServer.
2810 * @tc.number: AudioPolicyServer_134
2811 * @tc.desc : Test ProcUpdateRingerMode.
2812 */
2813 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_134, TestSize.Level1)
2814 {
2815 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2816 ASSERT_TRUE(server != nullptr);
2817
2818 server->coreService_ = std::make_shared<AudioCoreService>();
2819 server->supportVibrator_ = true;
2820 server->ProcUpdateRingerMode();
2821
2822 server->supportVibrator_ = false;
2823 server->ProcUpdateRingerMode();
2824 }
2825
2826 /**
2827 * @tc.name : Test AudioPolicyServer.
2828 * @tc.number: AudioPolicyServer_135
2829 * @tc.desc : Test SetAppSingleStreamVolume.
2830 */
2831 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_135, TestSize.Level1)
2832 {
2833 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2834 ASSERT_TRUE(server != nullptr);
2835
2836 int32_t appUid = 0;
2837 int32_t volumeLevel = 1;
2838 server->audioPolicyServerHandler_ = nullptr;
2839 auto ret = server->SetAppSingleStreamVolume(appUid, volumeLevel, true);
2840 EXPECT_EQ(ret, SUCCESS);
2841
2842 server->audioPolicyServerHandler_ = std::make_shared<AudioPolicyServerHandler>();
2843 ret = server->SetAppSingleStreamVolume(appUid, volumeLevel, true);
2844 EXPECT_EQ(ret, SUCCESS);
2845 }
2846
2847 /**
2848 * @tc.name : Test AudioPolicyServer.
2849 * @tc.number: AudioPolicyServer_136
2850 * @tc.desc : Test SetSingleStreamVolume.
2851 */
2852 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_136, TestSize.Level1)
2853 {
2854 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2855 ASSERT_TRUE(server != nullptr);
2856
2857 int32_t volumeLevel = 1;
2858 auto ret = server->SetSingleStreamVolume(AudioStreamType::STREAM_VOICE_ASSISTANT, volumeLevel, true, false);
2859 EXPECT_EQ(ret, SUCCESS);
2860
2861 ret = server->SetSingleStreamVolume(AudioStreamType::STREAM_RING, volumeLevel, true, false);
2862 EXPECT_EQ(ret, SUCCESS);
2863
2864 ret = server->SetSingleStreamVolume(AudioStreamType::STREAM_VOICE_RING, volumeLevel, true, false);
2865 EXPECT_EQ(ret, SUCCESS);
2866 }
2867
2868 /**
2869 * @tc.name : Test AudioPolicyServer.
2870 * @tc.number: AudioPolicyServer_138
2871 * @tc.desc : Test GetStreamMuteInternal.
2872 */
2873 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_138, TestSize.Level1)
2874 {
2875 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2876 ASSERT_TRUE(server != nullptr);
2877
2878 auto ret = server->GetStreamMuteInternal(AudioStreamType::STREAM_ALL);
2879 EXPECT_EQ(ret, false);
2880
2881 ret = server->GetStreamMuteInternal(AudioStreamType::STREAM_RING);
2882 EXPECT_EQ(ret, true);
2883 }
2884
2885 /**
2886 * @tc.name : Test AudioPolicyServer.
2887 * @tc.number: AudioPolicyServer_139
2888 * @tc.desc : Test GetDevices.
2889 */
2890 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_139, TestSize.Level1)
2891 {
2892 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2893 ASSERT_TRUE(server != nullptr);
2894
2895 server->coreService_ = AudioCoreService::GetCoreService();
2896 server->eventEntry_ = std::make_shared<AudioCoreService::EventEntry>(server->coreService_);
2897 std::vector<std::shared_ptr<AudioDeviceDescriptor>> ret;
2898 server->GetDevices(DeviceFlag::NONE_DEVICES_FLAG, ret);
2899 EXPECT_EQ(ret.size(), 0);
2900
2901 DeviceFlag deviceFlag = static_cast<DeviceFlag>(-1);
2902 server->GetDevices(DeviceFlag::NONE_DEVICES_FLAG, ret);
2903 EXPECT_EQ(ret.size(), 0);
2904 }
2905
2906 /**
2907 * @tc.name : Test AudioPolicyServer.
2908 * @tc.number: AudioPolicyServer_140
2909 * @tc.desc : Test GetDevicesInner.
2910 */
2911 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_140, TestSize.Level1)
2912 {
2913 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2914 ASSERT_TRUE(server != nullptr);
2915
2916 std::vector<std::shared_ptr<AudioDeviceDescriptor>> ret;
2917 server->GetDevicesInner(DeviceFlag::ALL_DEVICES_FLAG, ret);
2918 EXPECT_EQ(ret.size(), 0);
2919 }
2920
2921 /**
2922 * @tc.name : Test AudioPolicyServer.
2923 * @tc.number: AudioPolicyServer_141
2924 * @tc.desc : Test GetDevicesInner.
2925 */
2926 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_141, TestSize.Level1)
2927 {
2928 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2929 ASSERT_TRUE(server != nullptr);
2930
2931 sptr<AudioRendererFilter> audioRendererFilter = new AudioRendererFilter();
2932 std::vector<std::shared_ptr<AudioDeviceDescriptor>> ret;
2933 server->GetOutputDevice(audioRendererFilter, ret);
2934 EXPECT_EQ(ret.size(), 0);
2935 }
2936
2937 /**
2938 * @tc.name : Test AudioPolicyServer.
2939 * @tc.number: AudioPolicyServer_142
2940 * @tc.desc : Test GetDevicesInner.
2941 */
2942 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_142, TestSize.Level1)
2943 {
2944 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2945 ASSERT_TRUE(server != nullptr);
2946
2947 sptr<AudioRendererFilter> audioRendererFilter = new AudioRendererFilter();
2948 std::vector<std::shared_ptr<AudioDeviceDescriptor>> ret;
2949 server->GetOutputDevice(audioRendererFilter, ret);
2950 EXPECT_EQ(ret.size(), 0);
2951 }
2952
2953 /**
2954 * @tc.name : Test AudioPolicyServer.
2955 * @tc.number: AudioPolicyServer_143
2956 * @tc.desc : Test GetDevicesInner.
2957 */
2958 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_143, TestSize.Level1)
2959 {
2960 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2961 ASSERT_TRUE(server != nullptr);
2962
2963 sptr<AudioCapturerFilter> audioCapturerFilter = new AudioCapturerFilter();
2964 std::vector<std::shared_ptr<AudioDeviceDescriptor>> ret;
2965 server->GetInputDevice(audioCapturerFilter, ret);
2966 EXPECT_EQ(ret.size(), 0);
2967 }
2968
2969 /**
2970 * @tc.name : Test AudioPolicyServer.
2971 * @tc.number: AudioPolicyServer_144
2972 * @tc.desc : Test SubscribePowerStateChangeEvents.
2973 */
2974 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_144, TestSize.Level1)
2975 {
2976 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2977 ASSERT_TRUE(server != nullptr);
2978
2979 server->SubscribePowerStateChangeEvents();
2980 }
2981
2982 /**
2983 * @tc.name : Test AudioPolicyServer.
2984 * @tc.number: AudioPolicyServer_145
2985 * @tc.desc : Test OnReceiveEvent.
2986 */
2987 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_145, TestSize.Level1)
2988 {
2989 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
2990 ASSERT_TRUE(server != nullptr);
2991
2992 EventFwk::CommonEventData eventData;
2993 const AAFwk::Want& want = eventData.GetWant();
2994 std::string action = want.GetAction();
2995 server->OnReceiveEvent(eventData);
2996 }
2997
2998 /**
2999 * @tc.name : Test AudioPolicyServer.
3000 * @tc.number: AudioPolicyServer_146
3001 * @tc.desc : Test SubscribeCommonEventExecute.
3002 */
3003 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_146, TestSize.Level1)
3004 {
3005 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3006 ASSERT_TRUE(server != nullptr);
3007
3008 server->SubscribeCommonEventExecute();
3009 }
3010
3011 /**
3012 * @tc.name : Test AudioPolicyServer.
3013 * @tc.number: AudioPolicyServer_147
3014 * @tc.desc : Test CheckSubscribePowerStateChange.
3015 */
3016 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_147, TestSize.Level1)
3017 {
3018 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3019 ASSERT_TRUE(server != nullptr);
3020
3021 server->powerStateCallbackRegister_ = true;
3022 server->CheckSubscribePowerStateChange();
3023 server->powerStateCallbackRegister_ = false;
3024 server->CheckSubscribePowerStateChange();
3025 EXPECT_TRUE(server->powerStateCallbackRegister_);
3026 }
3027
3028 /**
3029 * @tc.name : Test AudioPolicyServer.
3030 * @tc.number: AudioPolicyServer_148
3031 * @tc.desc : Test CheckSubscribePowerStateChange.
3032 */
3033 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_148, TestSize.Level1)
3034 {
3035 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3036 ASSERT_TRUE(server != nullptr);
3037
3038 int32_t volumeLevel = 1;
3039 auto ret = server->SetSystemVolumeLevelLegacy(AudioStreamType::STREAM_TTS, volumeLevel);
3040 EXPECT_EQ(ret, ERR_NOT_SUPPORTED);
3041
3042 volumeLevel = -1;
3043 ret = server->SetSystemVolumeLevelLegacy(AudioStreamType::STREAM_MUSIC, volumeLevel);
3044 EXPECT_EQ(ret, ERR_NOT_SUPPORTED);
3045
3046 volumeLevel = server->audioVolumeManager_.GetMinVolumeLevel(AudioStreamType::STREAM_RING);
3047 ret = server->SetSystemVolumeLevelLegacy(AudioStreamType::STREAM_RING, volumeLevel);
3048 EXPECT_EQ(ret, SUCCESS);
3049 }
3050
3051 #ifdef TEMP_DISABLE
3052 /**
3053 * @tc.name : Test AudioPolicyServer.
3054 * @tc.number: AudioPolicyServer_149
3055 * @tc.desc : Test SetAppVolumeMuted.
3056 */
3057 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_149, TestSize.Level1)
3058 {
3059 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3060 ASSERT_TRUE(server != nullptr);
3061
3062 int32_t appUid = 0;
3063 int32_t volumeFlag = VolumeFlag::FLAG_SHOW_SYSTEM_UI;
3064 auto ret = server->SetAppVolumeMuted(appUid, true, volumeFlag);
3065 EXPECT_EQ(ret, SUCCESS);
3066 }
3067
3068 /**
3069 * @tc.name : Test AudioPolicyServer.
3070 * @tc.number: AudioPolicyServer_150
3071 * @tc.desc : Test SetAppVolumeLevel.
3072 */
3073 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_150, TestSize.Level1)
3074 {
3075 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3076 ASSERT_TRUE(server != nullptr);
3077
3078 int32_t appUid = 0;
3079 int32_t volumeLevel = 1;
3080 int32_t volumeFlag = VolumeFlag::FLAG_SHOW_SYSTEM_UI;
3081 auto ret = server->SetAppVolumeLevel(appUid, volumeLevel, volumeFlag);
3082 EXPECT_EQ(ret, ERR_PERMISSION_DENIED);
3083
3084 volumeLevel = server->audioVolumeManager_.GetMinVolumeLevel(AudioStreamType::STREAM_APP);
3085 ret = server->SetAppVolumeLevel(appUid, volumeLevel, volumeFlag);
3086 EXPECT_EQ(ret, SUCCESS);
3087 }
3088
3089 /**
3090 * @tc.name : Test AudioPolicyServer.
3091 * @tc.number: AudioPolicyServer_151
3092 * @tc.desc : Test SetSystemVolumeLevel.
3093 */
3094 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_151, TestSize.Level1)
3095 {
3096 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3097 ASSERT_TRUE(server != nullptr);
3098
3099 int32_t volumeLevel = 1;
3100 int32_t volumeFlag = VolumeFlag::FLAG_SHOW_SYSTEM_UI;
3101
3102 auto ret = server->SetSystemVolumeLevel(AudioStreamType::STREAM_WAKEUP, volumeLevel, volumeFlag);
3103 EXPECT_EQ(ret, ERR_NOT_SUPPORTED);
3104
3105 volumeLevel = -1;
3106 ret = server->SetSystemVolumeLevel(AudioStreamType::STREAM_MUSIC, volumeLevel, volumeFlag);
3107 EXPECT_EQ(ret, ERR_NOT_SUPPORTED);
3108
3109 volumeLevel = server->audioVolumeManager_.GetMinVolumeLevel(AudioStreamType::STREAM_MUSIC);
3110 ret = server->SetSystemVolumeLevel(AudioStreamType::STREAM_MUSIC, volumeLevel, volumeFlag);
3111 EXPECT_EQ(ret, SUCCESS);
3112 }
3113
3114 /**
3115 * @tc.name : Test AudioPolicyServer.
3116 * @tc.number: AudioPolicyServer_152
3117 * @tc.desc : Test SetSystemVolumeLevelWithDevice.
3118 */
3119 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_152, TestSize.Level1)
3120 {
3121 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3122 ASSERT_TRUE(server != nullptr);
3123
3124 int32_t volumeLevel = 1;
3125 int32_t volumeFlag = VolumeFlag::FLAG_SHOW_SYSTEM_UI;
3126
3127 auto ret = server->SetSystemVolumeLevelWithDevice(AudioStreamType::STREAM_WAKEUP, volumeLevel,
3128 DeviceType::DEVICE_TYPE_EARPIECE, volumeFlag);
3129 EXPECT_EQ(ret, ERR_NOT_SUPPORTED);
3130
3131 volumeLevel = -1;
3132 ret = server->SetSystemVolumeLevelWithDevice(AudioStreamType::STREAM_MUSIC, volumeLevel,
3133 DeviceType::DEVICE_TYPE_EARPIECE, volumeFlag);
3134 EXPECT_EQ(ret, ERR_NOT_SUPPORTED);
3135 }
3136
3137 /**
3138 * @tc.name : Test AudioPolicyServer.
3139 * @tc.number: AudioPolicyServer_153
3140 * @tc.desc : Test GetSystemActiveVolumeTypeInternal.
3141 */
3142 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_153, TestSize.Level1)
3143 {
3144 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3145 ASSERT_TRUE(server != nullptr);
3146
3147 int32_t clientUid = 0;
3148 auto ret = server->GetSystemActiveVolumeTypeInternal(clientUid);
3149 EXPECT_EQ(ret, AudioStreamType::STREAM_MUSIC);
3150
3151 clientUid = 1;
3152 ret = server->GetSystemActiveVolumeTypeInternal(clientUid);
3153 EXPECT_EQ(ret, AudioStreamType::STREAM_MUSIC);
3154 }
3155
3156 /**
3157 * @tc.name : Test AudioPolicyServer.
3158 * @tc.number: AudioPolicyServer_154
3159 * @tc.desc : Test GetAppVolumeLevel.
3160 */
3161 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_154, TestSize.Level1)
3162 {
3163 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3164 ASSERT_TRUE(server != nullptr);
3165
3166 int32_t appUid = 0;
3167 int32_t volumeLevel = 1;
3168 auto ret = server->GetAppVolumeLevel(appUid, volumeLevel);
3169 EXPECT_EQ(ret, SUCCESS);
3170 }
3171 #endif
3172
3173 /**
3174 * @tc.name : Test AudioPolicyServer.
3175 * @tc.number: AudioPolicyServer_155
3176 * @tc.desc : Test GetSystemVolumeLevelInternal.
3177 */
3178 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_155, TestSize.Level1)
3179 {
3180 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3181 ASSERT_TRUE(server != nullptr);
3182
3183 server->GetSystemVolumeLevelInternal(AudioStreamType::STREAM_ALL);
3184 server->GetSystemVolumeLevelInternal(AudioStreamType::STREAM_VOICE_RING);
3185 }
3186
3187 /**
3188 * @tc.name : Test AudioPolicyServer.
3189 * @tc.number: AudioPolicyServer_156
3190 * @tc.desc : Test SetLowPowerVolume.
3191 */
3192 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_156, TestSize.Level1)
3193 {
3194 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3195 ASSERT_TRUE(server != nullptr);
3196
3197 int32_t streamId = 0;
3198 float volume = 0.5f;
3199 auto ret = server->SetLowPowerVolume(streamId, volume);
3200 EXPECT_EQ(ret, ERROR);
3201 }
3202
3203 /**
3204 * @tc.name : Test AudioPolicyServer.
3205 * @tc.number: AudioPolicyServer_157
3206 * @tc.desc : Test CheckCanMuteVolumeTypeByStep.
3207 */
3208 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_157, TestSize.Level1)
3209 {
3210 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3211 ASSERT_TRUE(server != nullptr);
3212
3213 int32_t volumeLevel = 1;
3214 server->volumeStep_ = 1;
3215 auto ret = server->CheckCanMuteVolumeTypeByStep(AudioVolumeType::STREAM_VOICE_ASSISTANT, volumeLevel);
3216 EXPECT_EQ(ret, false);
3217
3218 server->volumeStep_ = 0;
3219 ret = server->CheckCanMuteVolumeTypeByStep(AudioVolumeType::STREAM_VOICE_ASSISTANT, volumeLevel);
3220 EXPECT_EQ(ret, true);
3221
3222 ret = server->CheckCanMuteVolumeTypeByStep(AudioVolumeType::STREAM_MUSIC, volumeLevel);
3223 EXPECT_EQ(ret, true);
3224
3225 server->volumeStep_ = 1;
3226 ret = server->CheckCanMuteVolumeTypeByStep(AudioVolumeType::STREAM_MUSIC, volumeLevel);
3227 EXPECT_EQ(ret, true);
3228 }
3229
3230 /**
3231 * @tc.name : Test AudioPolicyServer.
3232 * @tc.number: AudioPolicyServer_158
3233 * @tc.desc : Test CheckCanMuteVolumeTypeByStep.
3234 */
3235 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_158, TestSize.Level1)
3236 {
3237 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3238 ASSERT_TRUE(server != nullptr);
3239
3240 int32_t volumeLevel = 1;
3241 server->volumeStep_ = 1;
3242 auto ret = server->CheckCanMuteVolumeTypeByStep(AudioVolumeType::STREAM_VOICE_CALL, volumeLevel);
3243 EXPECT_EQ(ret, false);
3244
3245 ret = server->CheckCanMuteVolumeTypeByStep(AudioVolumeType::STREAM_ALARM, volumeLevel);
3246 EXPECT_EQ(ret, false);
3247
3248 ret = server->CheckCanMuteVolumeTypeByStep(AudioVolumeType::STREAM_VOICE_COMMUNICATION, volumeLevel);
3249 EXPECT_EQ(ret, false);
3250 }
3251
3252 #ifdef TEMP_DISABLE
3253 /**
3254 * @tc.name : Test AudioPolicyServer.
3255 * @tc.number: AudioPolicyServer_159
3256 * @tc.desc : Test AdjustVolumeByStep.
3257 */
3258 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_159, TestSize.Level1)
3259 {
3260 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3261 ASSERT_TRUE(server != nullptr);
3262
3263 auto ret = server->AdjustVolumeByStep(VolumeAdjustType::VOLUME_UP);
3264 EXPECT_EQ(ret, SUCCESS);
3265
3266 ret = server->AdjustVolumeByStep(VolumeAdjustType::VOLUME_DOWN);
3267 EXPECT_EQ(ret, SUCCESS);
3268 }
3269 #endif
3270
3271 /**
3272 * @tc.name : Test AudioPolicyServer.
3273 * @tc.number: AudioPolicyServer_160
3274 * @tc.desc : Test TranslateKeyEvent.
3275 */
3276 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_160, TestSize.Level1)
3277 {
3278 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3279 ASSERT_TRUE(server != nullptr);
3280
3281 int32_t keyType = OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP;
3282 int32_t resultOfVolumeKey = 0;
3283 server->SendMonitrtEvent(keyType, resultOfVolumeKey);
3284
3285 keyType = OHOS::MMI::KeyEvent::KEYCODE_VOLUME_DOWN;
3286 server->SendMonitrtEvent(keyType, resultOfVolumeKey);
3287
3288 keyType = OHOS::MMI::KeyEvent::KEYCODE_MUTE;
3289 server->SendMonitrtEvent(keyType, resultOfVolumeKey);
3290
3291 keyType = -1;
3292 server->SendMonitrtEvent(keyType, resultOfVolumeKey);
3293 }
3294
3295 /**
3296 * @tc.name : Test AudioPolicyServer.
3297 * @tc.number: AudioPolicyServer_161
3298 * @tc.desc : Test OnAddSystemAbilityExtract.
3299 */
3300 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_161, TestSize.Level1)
3301 {
3302 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3303 ASSERT_TRUE(server != nullptr);
3304
3305 int32_t systemAbilityId = APP_MGR_SERVICE_ID;
3306 std::string deviceId = "test";
3307 server->OnAddSystemAbilityExtract(systemAbilityId, deviceId);
3308
3309 systemAbilityId = -1;
3310 server->OnAddSystemAbilityExtract(systemAbilityId, deviceId);
3311 }
3312
3313 /**
3314 * @tc.name : Test AudioPolicyServer.
3315 * @tc.number: AudioPolicyServer_162
3316 * @tc.desc : Test HandleKvDataShareEvent.
3317 */
3318 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_162, TestSize.Level1)
3319 {
3320 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3321 ASSERT_TRUE(server != nullptr);
3322
3323 server->isInitMuteState_.store(false);
3324 server->HandleKvDataShareEvent();
3325
3326 server->isInitMuteState_.store(true);
3327 server->HandleKvDataShareEvent();
3328 }
3329
3330 #ifdef FEATURE_MULTIMODALINPUT_INPUT
3331 /**
3332 * @tc.name : Test AudioPolicyServer.
3333 * @tc.number: AudioPolicyServer_163
3334 * @tc.desc : Test SubscribeVolumeKeyEvents.
3335 */
3336 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_163, TestSize.Level1)
3337 {
3338 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3339 ASSERT_TRUE(server != nullptr);
3340
3341 server->hasSubscribedVolumeKeyEvents_.store(false);
3342 server->SubscribeVolumeKeyEvents();
3343
3344 server->hasSubscribedVolumeKeyEvents_.store(true);
3345 server->SubscribeVolumeKeyEvents();
3346 }
3347 #endif
3348
3349 /**
3350 * @tc.name : Test AudioPolicyServer.
3351 * @tc.number: AudioPolicyServer_164
3352 * @tc.desc : Test SubscribeOsAccountChangeEvents.
3353 */
3354 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_164, TestSize.Level1)
3355 {
3356 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3357 ASSERT_TRUE(server != nullptr);
3358
3359 server->accountObserver_ = nullptr;
3360 server->SubscribeOsAccountChangeEvents();
3361 }
3362
3363 /**
3364 * @tc.name : Test AudioPolicyServer.
3365 * @tc.number: AudioPolicyServer_165
3366 * @tc.desc : Test AddAudioServiceOnStart.
3367 */
3368 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_165, TestSize.Level1)
3369 {
3370 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3371 ASSERT_TRUE(server != nullptr);
3372
3373 server->isFirstAudioServiceStart_.store(true);
3374 server->AddAudioServiceOnStart();
3375
3376 server->coreService_ = AudioCoreService::GetCoreService();
3377 server->eventEntry_ = std::make_shared<AudioCoreService::EventEntry>(server->coreService_);
3378 server->isFirstAudioServiceStart_.store(false);
3379 server->AddAudioServiceOnStart();
3380 }
3381
3382 /**
3383 * @tc.name : Test AudioPolicyServer.
3384 * @tc.number: AudioPolicyServer_0166
3385 * @tc.desc : Test SetDeviceConnectionStatus.
3386 */
3387 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_166, TestSize.Level1)
3388 {
3389 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3390 ASSERT_TRUE(server != nullptr);
3391
3392 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
3393 desc->deviceType_ = DEVICE_TYPE_SPEAKER;
3394 desc->deviceName_ = "Speaker_Out";
3395 desc->deviceRole_ = OUTPUT_DEVICE;
3396
3397 bool isConnected = true;
3398 int32_t ret = server->SetDeviceConnectionStatus(desc, isConnected);
3399 EXPECT_EQ(ERR_PERMISSION_DENIED, ret);
3400 }
3401
3402 /**
3403 * @tc.name : Test AudioPolicyServer.
3404 * @tc.number: AudioPolicyServer_167
3405 * @tc.desc : Test GetDirectPlaybackSupport.
3406 */
3407 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_167, TestSize.Level1)
3408 {
3409 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3410 ASSERT_TRUE(server != nullptr);
3411
3412 AudioStreamInfo streamInfo;
3413 streamInfo.samplingRate = SAMPLE_RATE_48000;
3414 streamInfo.encoding = ENCODING_PCM;
3415 streamInfo.format = SAMPLE_S24LE;
3416 streamInfo.channels = STEREO;
3417 StreamUsage streamUsage = STREAM_USAGE_MEDIA;
3418 int32_t result = 0;
3419 server->GetDirectPlaybackSupport(streamInfo, streamUsage, result);
3420 EXPECT_EQ(result, DIRECT_PLAYBACK_NOT_SUPPORTED);
3421 }
3422
3423 /**
3424 * @tc.name : Test AudioPolicyServer.
3425 * @tc.number: AudioPolicyServer_168
3426 * @tc.desc : Test ActivatePreemptMode.
3427 */
3428 HWTEST(AudioPolicyUnitTest, AudioPolicyServer_168, TestSize.Level1)
3429 {
3430 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3431 ASSERT_TRUE(server != nullptr);
3432
3433 int32_t result = server->ActivatePreemptMode();
3434 EXPECT_EQ(result, ERROR);
3435 }
3436
3437 /**
3438 * @tc.name : Test AudioPolicyServer
3439 * @tc.number: IsStreamActiveByStreamUsage_001
3440 * @tc.desc : AudioPolicyServer::IsStreamActiveByStreamUsage
3441 */
3442 HWTEST(AudioPolicyUnitTest, IsStreamActiveByStreamUsage_001, TestSize.Level1)
3443 {
3444 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3445 ASSERT_TRUE(server != nullptr);
3446
3447 int32_t streamUsage = static_cast<int32_t>(StreamUsage::STREAM_USAGE_MUSIC);
3448 bool isStreamActive = true;
3449
3450 int32_t ret = server->IsStreamActiveByStreamUsage(streamUsage, isStreamActive);
3451 EXPECT_EQ(ret, SUCCESS);
3452 }
3453
3454 /**
3455 * @tc.name : Test AudioPolicyServer
3456 * @tc.number: GetVolumeInDbByStream_001
3457 * @tc.desc : AudioPolicyServer::GetVolumeInDbByStream
3458 */
3459 HWTEST(AudioPolicyUnitTest, GetVolumeInDbByStream_001, TestSize.Level1)
3460 {
3461 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3462 ASSERT_TRUE(server != nullptr);
3463
3464 int32_t streamUsage = static_cast<int32_t>(StreamUsage::STREAM_USAGE_MUSIC);
3465 int32_t volLevel = 5;
3466 int32_t deviceType = static_cast<int32_t>(DeviceType::DEVICE_TYPE_SPEAKER);
3467 float volDb = 0;
3468
3469 int32_t ret = server->GetVolumeInDbByStream(streamUsage, volLevel, deviceType, volDb);
3470 EXPECT_EQ(ret, SUCCESS);
3471 }
3472
3473 /**
3474 * @tc.name : Test AudioPolicyServer
3475 * @tc.number: GetSupportedAudioVolumeTypes_001
3476 * @tc.desc : AudioPolicyServer::GetSupportedAudioVolumeTypes
3477 */
3478 HWTEST(AudioPolicyUnitTest, GetSupportedAudioVolumeTypes_001, TestSize.Level1)
3479 {
3480 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3481 ASSERT_TRUE(server != nullptr);
3482
3483 std::vector<int32_t> audioVolumeTypes = {};
3484
3485 int32_t ret = server->GetSupportedAudioVolumeTypes(audioVolumeTypes);
3486 EXPECT_EQ(ret, SUCCESS);
3487 }
3488
3489 /**
3490 * @tc.name : Test AudioPolicyServer
3491 * @tc.number: GetAudioVolumeTypeByStreamUsage_001
3492 * @tc.desc : AudioPolicyServer::GetAudioVolumeTypeByStreamUsage
3493 */
3494 HWTEST(AudioPolicyUnitTest, GetAudioVolumeTypeByStreamUsage_001, TestSize.Level1)
3495 {
3496 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3497 ASSERT_TRUE(server != nullptr);
3498
3499 int32_t streamUsage = static_cast<int32_t>(StreamUsage::STREAM_USAGE_MUSIC);
3500 int32_t audioVolumeType = static_cast<int32_t>(AudioVolumeType::STREAM_DEFAULT);
3501
3502 int32_t ret = server->GetAudioVolumeTypeByStreamUsage(streamUsage, audioVolumeType);
3503 EXPECT_EQ(ret, SUCCESS);
3504 }
3505
3506 /**
3507 * @tc.name : Test AudioPolicyServer
3508 * @tc.number: GetStreamUsagesByVolumeType_001
3509 * @tc.desc : AudioPolicyServer::GetStreamUsagesByVolumeType
3510 */
3511 HWTEST(AudioPolicyUnitTest, GetStreamUsagesByVolumeType_001, TestSize.Level1)
3512 {
3513 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3514 ASSERT_TRUE(server != nullptr);
3515
3516 int32_t volType = static_cast<int32_t>(AudioVolumeType::STREAM_MUSIC);
3517 std::vector<int32_t> streamUsages = {};
3518
3519 int32_t ret = server->GetStreamUsagesByVolumeType(volType, streamUsages);
3520 EXPECT_EQ(ret, SUCCESS);
3521 }
3522
3523 /**
3524 * @tc.name : Test AudioPolicyServer
3525 * @tc.number: SetQueryDeviceVolumeBehaviorCallback_001
3526 * @tc.desc : AudioPolicyServer::SetQueryDeviceVolumeBehaviorCallback
3527 */
3528 HWTEST(AudioPolicyUnitTest, SetQueryDeviceVolumeBehaviorCallback_001, TestSize.Level1)
3529 {
3530 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3531 ASSERT_TRUE(server != nullptr);
3532
3533 sptr<IRemoteObject> object = nullptr;
3534
3535 int32_t ret = server->SetQueryDeviceVolumeBehaviorCallback(object);
3536 EXPECT_EQ(ERR_INVALID_PARAM, ret);
3537
3538 object = new RemoteObjectTestStub();
3539
3540 ret = server->SetQueryDeviceVolumeBehaviorCallback(object);
3541 EXPECT_EQ(SUCCESS, ret);
3542 }
3543
3544 /**
3545 * @tc.name : Test AudioDeviceManager.
3546 * @tc.number: SetDeviceVolumeBehavior_001
3547 * @tc.desc : Test SetDeviceVolumeBehavior.
3548 */
3549 HWTEST(AudioPolicyUnitTest, SetDeviceVolumeBehavior_001, TestSize.Level1)
3550 {
3551 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3552 ASSERT_TRUE(server != nullptr);
3553
3554 std::string networkId = "test";
3555 DeviceType deviceType = DeviceType::DEVICE_TYPE_SPEAKER;
3556 VolumeBehavior volumeBehavior;
3557 int32_t result = server->audioDeviceManager_.SetDeviceVolumeBehavior(networkId, deviceType, volumeBehavior);
3558 EXPECT_EQ(result, SUCCESS);
3559 }
3560
3561 /**
3562 * @tc.name : Test AudioDeviceManager.
3563 * @tc.number: GetDeviceVolumeBehavior_001
3564 * @tc.desc : Test GetDeviceVolumeBehavior.
3565 */
3566 HWTEST(AudioPolicyUnitTest, GetDeviceVolumeBehavior_001, TestSize.Level1)
3567 {
3568 sptr<AudioPolicyServer> server = GetPolicyServerUnitTest();
3569 ASSERT_TRUE(server != nullptr);
3570
3571 std::string networkId = "test";
3572 DeviceType deviceType = DeviceType::DEVICE_TYPE_SPEAKER;
3573 VolumeBehavior volumeBehavior = server->audioDeviceManager_.GetDeviceVolumeBehavior(networkId, deviceType);
3574 EXPECT_EQ(volumeBehavior.isReady, false);
3575 }
3576 } // AudioStandard
3577 } // OHOS
3578