1 /*
2 * Copyright (c) 2021-2024 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_errors.h"
17 #include "audio_policy_manager_unit_test.h"
18 #include "audio_utils.h"
19
20 using namespace testing::ext;
21
22 namespace OHOS {
23 namespace AudioStandard {
24
SetUpTestCase(void)25 void AudioPolicyManagerUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)26 void AudioPolicyManagerUnitTest::TearDownTestCase(void) {}
SetUp(void)27 void AudioPolicyManagerUnitTest::SetUp(void) {}
TearDown(void)28 void AudioPolicyManagerUnitTest::TearDown(void) {}
29
30 /**
31 * @tc.name : Test AudioPolicyManager.
32 * @tc.number: AudioPolicyManagerUnitTest_001.
33 * @tc.desc : Test GetOutputDevice.
34 */
35 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_001, TestSize.Level1)
36 {
37 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
38 sptr<AudioRendererFilter> audioRendererFilter = new(std::nothrow) AudioRendererFilter();
39 audioPolicyManager_->GetOutputDevice(audioRendererFilter);
40 EXPECT_NE(audioPolicyManager_, nullptr);
41 }
42
43 /**
44 * @tc.name : Test AudioPolicyManager.
45 * @tc.number: AudioPolicyManagerUnitTest_002.
46 * @tc.desc : Test GetInputDevice.
47 */
48 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_002, TestSize.Level1)
49 {
50 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
51 sptr<AudioCapturerFilter> audioCapturerFilter = new(std::nothrow) AudioCapturerFilter();
52 audioPolicyManager_->GetInputDevice(audioCapturerFilter);
53 EXPECT_NE(audioPolicyManager_, nullptr);
54 }
55
56 /**
57 * @tc.name : Test AudioPolicyManager.
58 * @tc.number: AudioPolicyManagerUnitTest_003.
59 * @tc.desc : Test SetRingerModeCallback.
60 */
61 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_003, TestSize.Level1)
62 {
63 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
64 int32_t clientId = getpid();
65 std::shared_ptr<AudioRingerModeCallback> callback = std::make_shared<ConcreteAudioRingerModeCallback>();
66 audioPolicyManager_->SetRingerModeCallback(clientId, callback, API_VERSION::API_9);
67 EXPECT_NE(audioPolicyManager_, nullptr);
68 }
69
70 /**
71 * @tc.name : Test AudioPolicyManager.
72 * @tc.number: AudioPolicyManagerUnitTest_004.
73 * @tc.desc : Test SetMicrophoneBlockedCallback.
74 */
75 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_004, TestSize.Level1)
76 {
77 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
78 int32_t clientId = getpid();
79 std::shared_ptr<AudioManagerMicrophoneBlockedCallback> callback =
80 std::make_shared<ConcreteAudioManagerMicrophoneBlockedCallback>();
81 audioPolicyManager_->SetMicrophoneBlockedCallback(clientId, callback);
82 EXPECT_NE(audioPolicyManager_, nullptr);
83
84 audioPolicyManager_->isAudioPolicyClientRegisted_.store(true);
85 audioPolicyManager_->SetMicrophoneBlockedCallback(clientId, callback);
86 EXPECT_NE(audioPolicyManager_, nullptr);
87
88 audioPolicyManager_->audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
89 audioPolicyManager_->SetMicrophoneBlockedCallback(clientId, callback);
90 EXPECT_NE(audioPolicyManager_, nullptr);
91 }
92
93 /**
94 * @tc.name : Test AudioPolicyManager.
95 * @tc.number: AudioPolicyManagerUnitTest_005.
96 * @tc.desc : Test UnsetPreferredInputDeviceChangeCallback.
97 */
98 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_005, TestSize.Level1)
99 {
100 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
101 audioPolicyManager_->audioPolicyClientStubCB_ = nullptr;
102 int32_t result = audioPolicyManager_->UnsetPreferredInputDeviceChangeCallback();
103 EXPECT_EQ(result, SUCCESS);
104 }
105
106 /**
107 * @tc.name : Test AudioPolicyManager.
108 * @tc.number: AudioPolicyManagerUnitTest_006.
109 * @tc.desc : Test UnsetMicrophoneBlockedCallback.
110 */
111 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_006, TestSize.Level1)
112 {
113 int32_t clientId = getpid();
114 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
115 std::shared_ptr<AudioManagerMicrophoneBlockedCallback> callback =
116 std::make_shared<ConcreteAudioManagerMicrophoneBlockedCallback>();
117 audioPolicyManager_->audioPolicyClientStubCB_ = nullptr;
118 int32_t result = audioPolicyManager_->UnsetMicrophoneBlockedCallback(clientId, callback);
119 EXPECT_EQ(result, SUCCESS);
120
121 audioPolicyManager_->audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
122 result = audioPolicyManager_->UnsetMicrophoneBlockedCallback(clientId, callback);
123 EXPECT_EQ(result, SUCCESS);
124 }
125
126 /**
127 * @tc.name : Test AudioPolicyManager.
128 * @tc.number: AudioPolicyManagerUnitTest_007.
129 * @tc.desc : Test UnregisterAudioRendererEventListener.
130 */
131 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_007, TestSize.Level1)
132 {
133 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
134 std::shared_ptr<AudioRendererStateChangeCallback> callback;
135 auto audioPolicyClient_ = std::make_shared<AudioPolicyClientStubImpl>();
136 audioPolicyClient_->AddRendererStateChangeCallback(callback);
137 audioPolicyManager_->audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
138 audioPolicyManager_->isAudioRendererEventListenerRegistered = true;
139 audioPolicyManager_->UnregisterAudioRendererEventListener(callback);
140 EXPECT_NE(audioPolicyManager_, nullptr);
141 }
142
143 /**
144 * @tc.name : Test AudioPolicyManager.
145 * @tc.number: AudioPolicyManagerUnitTest_008.
146 * @tc.desc : Test UnregisterAudioRendererEventListener.
147 */
148 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_008, TestSize.Level1)
149 {
150 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
151 std::shared_ptr<AudioRendererStateChangeCallback> callback =
152 std::make_shared<ConcreteAudioRendererStateChange>();
153 audioPolicyManager_->audioPolicyClientStubCB_ = nullptr;
154 audioPolicyManager_->isAudioRendererEventListenerRegistered = true;
155 audioPolicyManager_->UnregisterAudioRendererEventListener(callback);
156 EXPECT_NE(audioPolicyManager_, nullptr);
157
158 audioPolicyManager_->audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
159 audioPolicyManager_->isAudioRendererEventListenerRegistered = false;
160 audioPolicyManager_->UnregisterAudioRendererEventListener(callback);
161 EXPECT_NE(audioPolicyManager_, nullptr);
162
163 auto audioPolicyClient_ = std::make_shared<AudioPolicyClientStubImpl>();
164 audioPolicyClient_->AddRendererStateChangeCallback(callback);
165 audioPolicyManager_->audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
166 audioPolicyManager_->isAudioRendererEventListenerRegistered = true;
167 audioPolicyManager_->UnregisterAudioRendererEventListener(callback);
168 EXPECT_NE(audioPolicyManager_, nullptr);
169 }
170
171 /**
172 * @tc.name : Test AudioPolicyManager.
173 * @tc.number: AudioPolicyManagerUnitTest_009.
174 * @tc.desc : Test UnregisterAudioCapturerEventListener.
175 */
176 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_009, TestSize.Level1)
177 {
178 int32_t clientId = getpid();
179 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
180 auto audioPolicyClient_ = std::make_shared<AudioPolicyClientStubImpl>();
181 auto cb = std::make_shared<ConcreteAudioCapturerStateChangeCallback>();
182 audioPolicyClient_->AddCapturerStateChangeCallback(cb);
183 audioPolicyManager_->audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
184 audioPolicyManager_->isAudioCapturerEventListenerRegistered = false;
185 audioPolicyManager_->UnregisterAudioCapturerEventListener(clientId);
186 EXPECT_NE(audioPolicyManager_, nullptr);
187 }
188
189 /**
190 * @tc.name : Test AudioPolicyManager.
191 * @tc.number: AudioPolicyManagerUnitTest_010.
192 * @tc.desc : Test SetDistributedRoutingRoleCallback.
193 */
194 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_010, TestSize.Level1)
195 {
196 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
197 int result = audioPolicyManager_->SetDistributedRoutingRoleCallback(nullptr);
198 EXPECT_EQ(result, ERR_INVALID_PARAM);
199 }
200
201 /**
202 * @tc.name : Test AudioPolicyManager.
203 * @tc.number: AudioPolicyManagerUnitTest_012.
204 * @tc.desc : Test GetConverterConfig.
205 */
206 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_012, TestSize.Level1)
207 {
208 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
209 audioPolicyManager_->GetConverterConfig();
210 EXPECT_NE(audioPolicyManager_, nullptr);
211 }
212
213 /**
214 * @tc.name : Test AudioPolicyManager.
215 * @tc.number: AudioPolicyManagerUnitTest_013.
216 * @tc.desc : Test ActivateAudioSession.
217 */
218 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_013, TestSize.Level1)
219 {
220 AudioSessionStrategy strategy;
221 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
222 audioPolicyManager_->ActivateAudioSession(strategy);
223 EXPECT_NE(audioPolicyManager_, nullptr);
224
225 audioPolicyManager_->isAudioPolicyClientRegisted_.store(true);
226 audioPolicyManager_->ActivateAudioSession(strategy);
227 EXPECT_NE(audioPolicyManager_, nullptr);
228 }
229
230 /**
231 * @tc.name : Test AudioPolicyManager.
232 * @tc.number: AudioPolicyManagerUnitTest_014.
233 * @tc.desc : Test SetAudioSessionCallback.
234 */
235 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_014, TestSize.Level1)
236 {
237 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
238 auto audioSessionCallback = std::make_shared<ConcreteAudioSessionCallback>();
239 audioPolicyManager_->isAudioPolicyClientRegisted_.store(true);
240 audioPolicyManager_->audioPolicyClientStubCB_ = nullptr;
241 int32_t result = audioPolicyManager_->SetAudioSessionCallback(audioSessionCallback);
242 EXPECT_EQ(result, ERROR_ILLEGAL_STATE);
243
244 audioPolicyManager_->audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
245 audioPolicyManager_->isAudioPolicyClientRegisted_.store(false);
246 result = audioPolicyManager_->SetAudioSessionCallback(audioSessionCallback);
247 EXPECT_NE(audioPolicyManager_, nullptr);
248
249 audioPolicyManager_->isAudioPolicyClientRegisted_.store(true);
250 std::shared_ptr<AudioSessionCallback> cb = std::make_shared<ConcreteAudioSessionCallback>();
251 audioPolicyManager_->audioPolicyClientStubCB_->audioSessionCallbackList_.push_back(cb);
252 result = audioPolicyManager_->SetAudioSessionCallback(audioSessionCallback);
253 EXPECT_EQ(result, SUCCESS);
254 }
255
256 /**
257 * @tc.name : Test AudioPolicyManager.
258 * @tc.number: AudioPolicyManagerUnitTest_015.
259 * @tc.desc : Test UnsetAudioSessionCallback.
260 */
261 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_015, TestSize.Level1)
262 {
263 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
264 audioPolicyManager_->audioPolicyClientStubCB_ = nullptr;
265 int32_t result = audioPolicyManager_->UnsetAudioSessionCallback();
266 EXPECT_EQ(result, ERROR_ILLEGAL_STATE);
267
268 audioPolicyManager_->audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
269 result = audioPolicyManager_->UnsetAudioSessionCallback();
270 EXPECT_EQ(result, SUCCESS);
271
272 std::shared_ptr<AudioSessionCallback> cb = std::make_shared<ConcreteAudioSessionCallback>();
273 audioPolicyManager_->audioPolicyClientStubCB_->audioSessionCallbackList_.push_back(cb);
274 result = audioPolicyManager_->UnsetAudioSessionCallback();
275 EXPECT_EQ(result, SUCCESS);
276 }
277
278 /**
279 * @tc.name : Test AudioPolicyManager.
280 * @tc.number: AudioPolicyManagerUnitTest_016.
281 * @tc.desc : Test UnsetAudioSessionCallback.
282 */
283 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_016, TestSize.Level1)
284 {
285 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
286 std::shared_ptr<AudioSessionCallback> audioSessionCallback =
287 std::make_shared<ConcreteAudioSessionCallback>();
288 audioPolicyManager_->audioPolicyClientStubCB_ = nullptr;
289 int32_t result = audioPolicyManager_->UnsetAudioSessionCallback(audioSessionCallback);
290 EXPECT_EQ(result, ERROR_ILLEGAL_STATE);
291
292 audioPolicyManager_->audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
293 result = audioPolicyManager_->UnsetAudioSessionCallback(audioSessionCallback);
294 EXPECT_EQ(result, SUCCESS);
295
296 std::shared_ptr<AudioSessionCallback> cb = std::make_shared<ConcreteAudioSessionCallback>();
297 audioPolicyManager_->audioPolicyClientStubCB_->audioSessionCallbackList_.push_back(cb);
298 result = audioPolicyManager_->UnsetAudioSessionCallback(audioSessionCallback);
299 EXPECT_EQ(result, SUCCESS);
300 }
301
302 /**
303 * @tc.name : Test AudioPolicyManager.
304 * @tc.number: AudioPolicyManagerUnitTest_017.
305 * @tc.desc : Test RegisterHeadTrackingDataRequestedEventListener.
306 */
307 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_017, TestSize.Level1)
308 {
309 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
310 std::string macAddress = "macAddress";
311 auto callback = std::make_shared<ConcreteHeadTrackingDataRequestedChangeCallback>();
312 audioPolicyManager_->RegisterHeadTrackingDataRequestedEventListener(macAddress, callback);
313 EXPECT_NE(audioPolicyManager_, nullptr);
314
315 audioPolicyManager_->isAudioPolicyClientRegisted_ = true;
316 audioPolicyManager_->RegisterHeadTrackingDataRequestedEventListener(macAddress, callback);
317 EXPECT_NE(audioPolicyManager_, nullptr);
318 }
319
320 /**
321 * @tc.name : Test AudioPolicyManager.
322 * @tc.number: AudioPolicyManagerUnitTest_018.
323 * @tc.desc : Test UnregisterHeadTrackingDataRequestedEventListener.
324 */
325 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_018, TestSize.Level1)
326 {
327 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
328 std::string macAddress = "macAddress";
329 audioPolicyManager_->audioPolicyClientStubCB_ = nullptr;
330 audioPolicyManager_->UnregisterHeadTrackingDataRequestedEventListener(macAddress);
331 EXPECT_NE(audioPolicyManager_, nullptr);
332
333 audioPolicyManager_->audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
334 audioPolicyManager_->UnregisterHeadTrackingDataRequestedEventListener(macAddress);
335 EXPECT_NE(audioPolicyManager_, nullptr);
336 }
337
338 /**
339 * @tc.name : Test AudioPolicyManager.
340 * @tc.number: AudioPolicyManagerUnitTest_019.
341 * @tc.desc : Test SetAudioDeviceRefinerCallback.
342 */
343 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_019, TestSize.Level1)
344 {
345 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
346 int32_t result = audioPolicyManager_->SetAudioDeviceRefinerCallback(nullptr);
347 EXPECT_EQ(result, ERR_INVALID_PARAM);
348
349 std::shared_ptr<AudioDeviceRefiner> callback = std::make_shared<ConcreteAudioDeviceRefiner>();
350 audioPolicyManager_->SetAudioDeviceRefinerCallback(callback);
351 EXPECT_NE(audioPolicyManager_, nullptr);
352 EXPECT_EQ(callback->OnDistributedOutputChange(true), SUCCESS);
353 }
354
355 /**
356 * @tc.name : Test AudioPolicyManager.
357 * @tc.number: AudioPolicyManagerUnitTest_020.
358 * @tc.desc : Test SetAudioDeviceRefinerCallback.
359 */
360 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_020, TestSize.Level1)
361 {
362 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
363 int32_t result = audioPolicyManager_->SetAudioDeviceAnahsCallback(nullptr);
364 EXPECT_EQ(result, ERR_INVALID_PARAM);
365
366 std::shared_ptr<AudioDeviceAnahs> callback = std::make_shared<ConcreteAudioDeviceAnahs>();
367 audioPolicyManager_->SetAudioDeviceAnahsCallback(nullptr);
368 EXPECT_NE(audioPolicyManager_, nullptr);
369 }
370
371 /**
372 * @tc.name : Test GetOutputDevice.
373 * @tc.number: GetOutputDevice.
374 * @tc.desc : Test GetOutputDevice.
375 */
376 HWTEST(AudioPolicyManager, GetOutputDevice_001, TestSize.Level1)
377 {
378 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
379
380 sptr<AudioRendererFilter> audioRendererFilter = new AudioRendererFilter();
381 audioPolicyManager_->GetOutputDevice(audioRendererFilter);
382 EXPECT_NE(audioPolicyManager_, nullptr);
383 }
384
385 /**
386 * @tc.name : Test GetInputDevice.
387 * @tc.number: GetInputDevice.
388 * @tc.desc : Test GetInputDevice.
389 */
390 HWTEST(AudioPolicyManager, GetInputDevice_001, TestSize.Level1)
391 {
392 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
393
394 sptr<AudioCapturerFilter> audioRendererFilter = new AudioCapturerFilter();
395 audioPolicyManager_->GetInputDevice(audioRendererFilter);
396 EXPECT_NE(audioPolicyManager_, nullptr);
397 }
398
399 /**
400 * @tc.name : Test GetFastStreamInfo.
401 * @tc.number: GetFastStreamInfo.
402 * @tc.desc : Test GetFastStreamInfo.
403 */
404 HWTEST(AudioPolicyManager, GetFastStreamInfo_001, TestSize.Level2)
405 {
406 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
407
408 AudioStreamInfo streamInfo = audioPolicyManager_->GetFastStreamInfo();
409
410 EXPECT_EQ(streamInfo.samplingRate, SAMPLE_RATE_48000);
411 EXPECT_EQ(streamInfo.encoding, ENCODING_PCM);
412 EXPECT_EQ(streamInfo.channels, STEREO);
413 }
414
415 /**
416 * @tc.name : Test SetMicrophoneBlockedCallback.
417 * @tc.number: SetMicrophoneBlockedCallback.
418 * @tc.desc : Test SetMicrophoneBlockedCallback.
419 */
420 HWTEST(AudioPolicyManager, SetMicrophoneBlockedCallback_001, TestSize.Level1)
421 {
422 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
423
424 const int32_t clientId = 111;
425 std::shared_ptr<AudioManagerMicrophoneBlockedCallback> callback_ =
426 std::make_shared<ConcreteAudioManagerMicrophoneBlockedCallback>();
427 const std::shared_ptr<AudioManagerMicrophoneBlockedCallback> callback = callback_;
428 int32_t ret = audioPolicyManager_->SetMicrophoneBlockedCallback(clientId, callback);
429 EXPECT_EQ(ret, SUCCESS);
430 }
431
432 /**
433 * @tc.name : Test UnsetMicrophoneBlockedCallback.
434 * @tc.number: UnsetMicrophoneBlockedCallback.
435 * @tc.desc : Test UnsetMicrophoneBlockedCallback.
436 */
437 HWTEST(AudioPolicyManager, UnsetMicrophoneBlockedCallback_001, TestSize.Level1)
438 {
439 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
440
441 const int32_t clientId = 111;
442 std::shared_ptr<AudioManagerMicrophoneBlockedCallback> callback_ =
443 std::make_shared<ConcreteAudioManagerMicrophoneBlockedCallback>();
444 const std::shared_ptr<AudioManagerMicrophoneBlockedCallback> callback = callback_;
445 int32_t ret = audioPolicyManager_->UnsetMicrophoneBlockedCallback(clientId, callback);
446 EXPECT_EQ(ret, SUCCESS);
447 }
448
449 /**
450 * @tc.name : Test ActivateAudioSession.
451 * @tc.number: ActivateAudioSession.
452 * @tc.desc : Test ActivateAudioSession.
453 */
454 HWTEST(AudioPolicyManager, ActivateAudioSession_001, TestSize.Level1)
455 {
456 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
457
458 const AudioSessionStrategy strategy;
459 int32_t ret = audioPolicyManager_->ActivateAudioSession(strategy);
460 EXPECT_EQ(ret, SUCCESS);
461 }
462
463 /**
464 * @tc.name : Test SetAudioSessionCallback.
465 * @tc.number: SetAudioSessionCallback.
466 * @tc.desc : Test SetAudioSessionCallback.
467 */
468 HWTEST(AudioPolicyManager, SetAudioSessionCallback_001, TestSize.Level1)
469 {
470 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
471
472 const std::shared_ptr<AudioSessionCallback> audioSessionCallback =
473 std::make_shared<ConcreteAudioSessionCallback>();
474 int32_t ret = audioPolicyManager_->SetAudioSessionCallback(audioSessionCallback);
475 EXPECT_EQ(ret, 0);
476 }
477
478 /**
479 * @tc.name : Test SetAudioSessionCallback.
480 * @tc.number: SetAudioSessionCallback.
481 * @tc.desc : Test SetAudioSessionCallback.
482 */
483 HWTEST(AudioPolicyManager, SetAudioSessionCallback_002, TestSize.Level1)
484 {
485 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
486
487 const std::shared_ptr<AudioSessionCallback> audioSessionCallback =
488 std::make_shared<ConcreteAudioSessionCallback>();
489 audioPolicyManager_->isAudioPolicyClientRegisted_ = true;
490 int32_t ret = audioPolicyManager_->SetAudioSessionCallback(audioSessionCallback);
491 EXPECT_EQ(ret, ERROR_ILLEGAL_STATE);
492 }
493
494 /**
495 * @tc.name : Test SetAudioSessionCallback.
496 * @tc.number: SetAudioSessionCallback.
497 * @tc.desc : Test SetAudioSessionCallback.
498 */
499 HWTEST(AudioPolicyManager, SetAudioSessionCallback_003, TestSize.Level1)
500 {
501 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
502
503 const std::shared_ptr<AudioSessionCallback> audioSessionCallback =
504 std::make_shared<ConcreteAudioSessionCallback>();
505 audioPolicyManager_->isAudioPolicyClientRegisted_ = true;
506 audioPolicyManager_->audioPolicyClientStubCB_ = new AudioPolicyClientStubImpl();
507 int32_t ret = audioPolicyManager_->SetAudioSessionCallback(audioSessionCallback);
508 EXPECT_EQ(ret, SUCCESS);
509 }
510
511 /**
512 * @tc.name : Test UnsetAudioSessionCallback.
513 * @tc.number: UnsetAudioSessionCallback.
514 * @tc.desc : Test UnsetAudioSessionCallback.
515 */
516 HWTEST(AudioPolicyManager, UnsetAudioSessionCallback_001, TestSize.Level1)
517 {
518 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
519
520 int32_t ret = audioPolicyManager_->UnsetAudioSessionCallback();
521 EXPECT_EQ(ret, ERROR_ILLEGAL_STATE);
522 }
523
524 /**
525 * @tc.name : Test UnsetAudioSessionCallback.
526 * @tc.number: UnsetAudioSessionCallback.
527 * @tc.desc : Test UnsetAudioSessionCallback.
528 */
529 HWTEST(AudioPolicyManager, UnsetAudioSessionCallback_002, TestSize.Level1)
530 {
531 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
532
533 audioPolicyManager_->audioPolicyClientStubCB_ = new AudioPolicyClientStubImpl();
534 int32_t ret = audioPolicyManager_->UnsetAudioSessionCallback();
535 EXPECT_EQ(ret, SUCCESS);
536 }
537
538 /**
539 * @tc.name : Test UnsetAudioSessionCallback.
540 * @tc.number: UnsetAudioSessionCallback.
541 * @tc.desc : Test UnsetAudioSessionCallback.
542 */
543 HWTEST(AudioPolicyManager, UnsetAudioSessionCallback_ptr_001, TestSize.Level1)
544 {
545 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
546 const std::shared_ptr<AudioSessionCallback> audioSessionCallback =
547 std::make_shared<ConcreteAudioSessionCallback>();
548
549 int32_t ret = audioPolicyManager_->UnsetAudioSessionCallback(audioSessionCallback);
550 EXPECT_EQ(ret, ERROR_ILLEGAL_STATE);
551 }
552
553 /**
554 * @tc.name : Test UnsetAudioSessionCallback.
555 * @tc.number: UnsetAudioSessionCallback.
556 * @tc.desc : Test UnsetAudioSessionCallback.
557 */
558 HWTEST(AudioPolicyManager, UnsetAudioSessionCallback_ptr_002, TestSize.Level1)
559 {
560 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
561 const std::shared_ptr<AudioSessionCallback> audioSessionCallback =
562 std::make_shared<ConcreteAudioSessionCallback>();
563
564 audioPolicyManager_->audioPolicyClientStubCB_ = new AudioPolicyClientStubImpl();
565 int32_t ret = audioPolicyManager_->UnsetAudioSessionCallback(audioSessionCallback);
566 EXPECT_EQ(ret, SUCCESS);
567 }
568
569 /**
570 * @tc.name : Test AudioPolicyManager.
571 * @tc.number: SetAudioSceneChangeCallbackTest_001.
572 * @tc.desc : Test SetAudioSceneChangeCallback.
573 */
574 HWTEST(AudioPolicyManager, SetAudioSceneChangeCallbackTest_001, TestSize.Level1)
575 {
576 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
577 int32_t clientId = getpid();
578 std::shared_ptr<AudioManagerAudioSceneChangedCallback> callback =
579 std::make_shared<ConcreteAudioManagerAudioSceneChangedCallback>();
580 audioPolicyManager_->SetAudioSceneChangeCallback(clientId, callback);
581 EXPECT_NE(audioPolicyManager_, nullptr);
582 }
583
584 /**
585 * @tc.name : Test AudioPolicyManager.
586 * @tc.number: UnsetAudioSceneChangeCallbackTest_001.
587 * @tc.desc : Test UnsetAudioSceneChangeCallback.
588 */
589 HWTEST(AudioPolicyManager, UnsetAudioSceneChangeCallbackTest_001, TestSize.Level1)
590 {
591 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
592 std::shared_ptr<AudioManagerAudioSceneChangedCallback> callback =
593 std::make_shared<ConcreteAudioManagerAudioSceneChangedCallback>();
594 audioPolicyManager_->audioPolicyClientStubCB_ = nullptr;
595 int32_t result = audioPolicyManager_->UnsetAudioSceneChangeCallback(callback);
596 EXPECT_EQ(result, SUCCESS);
597
598 audioPolicyManager_->audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
599 result = audioPolicyManager_->UnsetAudioSceneChangeCallback(callback);
600 EXPECT_EQ(result, SUCCESS);
601 }
602
603 /**
604 * @tc.name : Test AudioPolicyManager.
605 * @tc.number: CreateRenderClient_001.
606 * @tc.desc : Test CreateRendererClient.
607 */
608 HWTEST(AudioPolicyManager, CreateRendererClient_001, TestSize.Level1)
609 {
610 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
611 std::shared_ptr<AudioStreamDescriptor> streamDesc = std::make_shared<AudioStreamDescriptor>();
612 streamDesc->streamInfo_.format = AudioSampleFormat::SAMPLE_S32LE;
613 streamDesc->streamInfo_.samplingRate = AudioSamplingRate::SAMPLE_RATE_48000;
614 streamDesc->streamInfo_.channels = AudioChannel::STEREO;
615 streamDesc->streamInfo_.encoding = AudioEncodingType::ENCODING_PCM;
616 streamDesc->streamInfo_.channelLayout = AudioChannelLayout::CH_LAYOUT_MONO;
617
618 streamDesc->audioMode_ = AUDIO_MODE_PLAYBACK;
619 streamDesc->createTimeStamp_ = ClockTime::GetCurNano();
620 streamDesc->callerUid_ = getuid();
621 uint32_t flag = AUDIO_OUTPUT_FLAG_NORMAL;
622 uint32_t originalSessionId = 123;
623 std::string networkId = LOCAL_NETWORK_ID;
624 auto result = audioPolicyManager_->CreateRendererClient(streamDesc, flag, originalSessionId, networkId);
625 EXPECT_EQ(result, SUCCESS);
626 }
627
628 /**
629 * @tc.name : Test AudioPolicyManager.
630 * @tc.number: CreateRenderClient_002.
631 * @tc.desc : Test CreateRendererClient.
632 */
633 HWTEST(AudioPolicyManager, CreateRendererClient_002, TestSize.Level1)
634 {
635 auto audioPolicyManager = std::make_shared<AudioPolicyManager>();
636 ASSERT_NE(audioPolicyManager, nullptr);
637 std::shared_ptr<AudioStreamDescriptor> streamDesc = std::make_shared<AudioStreamDescriptor>();
638 ASSERT_NE(streamDesc, nullptr);
639 streamDesc->streamInfo_.format = AudioSampleFormat::SAMPLE_S32LE;
640 streamDesc->streamInfo_.samplingRate = AudioSamplingRate::SAMPLE_RATE_48000;
641 streamDesc->streamInfo_.channels = AudioChannel::STEREO;
642 streamDesc->streamInfo_.encoding = AudioEncodingType::ENCODING_PCM;
643 streamDesc->streamInfo_.channelLayout = AudioChannelLayout::CH_LAYOUT_MONO;
644
645 streamDesc->audioMode_ = AUDIO_MODE_PLAYBACK;
646 streamDesc->createTimeStamp_ = ClockTime::GetCurNano();
647 streamDesc->callerUid_ = getuid();
648 uint32_t flag = AUDIO_OUTPUT_FLAG_NORMAL;
649 uint32_t originalSessionId = 0;
650 std::string networkId = LOCAL_NETWORK_ID;
651 auto result = audioPolicyManager->CreateRendererClient(streamDesc, flag, originalSessionId, networkId);
652 EXPECT_EQ(result, SUCCESS);
653 EXPECT_NE(originalSessionId, 0);
654
655 uint32_t oldSessionId = originalSessionId;
656 result = audioPolicyManager->CreateRendererClient(streamDesc, flag, originalSessionId, networkId);
657 EXPECT_EQ(result, SUCCESS);
658 EXPECT_EQ(originalSessionId, oldSessionId);
659 }
660
661 /**
662 * @tc.name : Test AudioPolicyManager.
663 * @tc.number: CreateRenderClient_001.
664 * @tc.desc : Test CreateRendererClient.
665 */
666 HWTEST(AudioPolicyManager, CreateCapturerClient_001, TestSize.Level1)
667 {
668 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
669 std::shared_ptr<AudioStreamDescriptor> streamDesc = std::make_shared<AudioStreamDescriptor>();
670 streamDesc->streamInfo_.format = AudioSampleFormat::SAMPLE_S32LE;
671 streamDesc->streamInfo_.samplingRate = AudioSamplingRate::SAMPLE_RATE_48000;
672 streamDesc->streamInfo_.channels = AudioChannel::STEREO;
673 streamDesc->streamInfo_.encoding = AudioEncodingType::ENCODING_PCM;
674 streamDesc->streamInfo_.channelLayout = AudioChannelLayout::CH_LAYOUT_MONO;
675
676 streamDesc->audioMode_ = AUDIO_MODE_PLAYBACK;
677 streamDesc->createTimeStamp_ = ClockTime::GetCurNano();
678 streamDesc->callerUid_ = getuid();
679 uint32_t flag = AUDIO_OUTPUT_FLAG_NORMAL;
680 uint32_t originalSessionId = 123;
681 auto result = audioPolicyManager_->CreateCapturerClient(streamDesc, flag, originalSessionId);
682 EXPECT_EQ(result, SUCCESS);
683 }
684
685 /**
686 * @tc.name : Test AudioPolicyManager.
687 * @tc.number: CreateCapturerClient_002.
688 * @tc.desc : Test CreateCapturerClient.
689 */
690 HWTEST(AudioPolicyManager, CreateCapturerClient_002, TestSize.Level1)
691 {
692 auto audioPolicyManager = std::make_shared<AudioPolicyManager>();
693 ASSERT_NE(audioPolicyManager, nullptr);
694 std::shared_ptr<AudioStreamDescriptor> streamDesc = std::make_shared<AudioStreamDescriptor>();
695 ASSERT_NE(streamDesc, nullptr);
696 streamDesc->streamInfo_.format = AudioSampleFormat::SAMPLE_S32LE;
697 streamDesc->streamInfo_.samplingRate = AudioSamplingRate::SAMPLE_RATE_48000;
698 streamDesc->streamInfo_.channels = AudioChannel::STEREO;
699 streamDesc->streamInfo_.encoding = AudioEncodingType::ENCODING_PCM;
700 streamDesc->streamInfo_.channelLayout = AudioChannelLayout::CH_LAYOUT_MONO;
701
702 streamDesc->audioMode_ = AUDIO_MODE_PLAYBACK;
703 streamDesc->createTimeStamp_ = ClockTime::GetCurNano();
704 streamDesc->callerUid_ = getuid();
705 uint32_t flag = AUDIO_OUTPUT_FLAG_NORMAL;
706 uint32_t originalSessionId = 0;
707 auto result = audioPolicyManager->CreateCapturerClient(streamDesc, flag, originalSessionId);
708 EXPECT_EQ(result, SUCCESS);
709 EXPECT_NE(originalSessionId, 0);
710
711 uint32_t oldSessionId = originalSessionId;
712 result = audioPolicyManager->CreateCapturerClient(streamDesc, flag, originalSessionId);
713 EXPECT_EQ(result, SUCCESS);
714 EXPECT_EQ(oldSessionId, originalSessionId);
715 }
716
717 /**
718 * @tc.name : Test AudioPolicyManager.
719 * @tc.number: SetSystemVolumeDegree_001.
720 * @tc.desc : Test SetSystemVolumeDegree.
721 */
722 HWTEST(AudioPolicyManager, SetSystemVolumeDegree_001, TestSize.Level1)
723 {
724 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
725 ASSERT_TRUE(audioPolicyManager_ != nullptr);
726
727 AudioVolumeType volumeType = AudioVolumeType::STREAM_MUSIC;
728 int32_t volumeDegree = 4;
729 auto result = audioPolicyManager_->SetSystemVolumeDegree(volumeType, volumeDegree, 0, 0);
730 EXPECT_EQ(result, SUCCESS);
731
732 result = audioPolicyManager_->GetSystemVolumeDegree(volumeType, 0);
733 EXPECT_EQ(result, volumeDegree);
734
735 result = audioPolicyManager_->GetMinVolumeDegree(volumeType);
736 EXPECT_EQ(result, 0);
737 }
738
739 /**
740 * @tc.name : Test AudioPolicyManager.
741 * @tc.number: GetDirectPlaybackSupport_001.
742 * @tc.desc : Test GetDirectPlaybackSupport. Returns DIRECT_PLAYBACK_NOT_SUPPORTED when xml not supported.
743 */
744 HWTEST(AudioPolicyManager, GetDirectPlaybackSupport_001, TestSize.Level1)
745 {
746 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
747 AudioStreamInfo streamInfo;
748 streamInfo.samplingRate = SAMPLE_RATE_48000;
749 streamInfo.encoding = ENCODING_PCM;
750 streamInfo.format = SAMPLE_S24LE;
751 streamInfo.channels = STEREO;
752 StreamUsage streamUsage = STREAM_USAGE_MEDIA;
753 auto result = audioPolicyManager_->GetDirectPlaybackSupport(streamInfo, streamUsage);
754 EXPECT_EQ(result, DIRECT_PLAYBACK_NOT_SUPPORTED);
755 }
756
757 /**
758 * @tc.name : Test AudioPolicyManager.
759 * @tc.number: GetDirectPlaybackSupport_002.
760 * @tc.desc : Test GetDirectPlaybackSupport. Returns DIRECT_PLAYBACK_NOT_SUPPORTED when xml not supported.
761 */
762 HWTEST(AudioPolicyManager, GetDirectPlaybackSupport_002, TestSize.Level1)
763 {
764 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
765 AudioStreamInfo streamInfo;
766 streamInfo.samplingRate = SAMPLE_RATE_24000;
767 streamInfo.encoding = ENCODING_EAC3;
768 streamInfo.format = SAMPLE_F32LE;
769 streamInfo.channels = STEREO;
770 StreamUsage streamUsage = STREAM_USAGE_MEDIA;
771 auto result = audioPolicyManager_->GetDirectPlaybackSupport(streamInfo, streamUsage);
772 EXPECT_EQ(result, DIRECT_PLAYBACK_NOT_SUPPORTED);
773 }
774
775 /**
776 * @tc.name : Test AudioPolicyManager.
777 * @tc.number: SetNearlinkDeviceVolume_001.
778 * @tc.desc : Test SetNearlinkDeviceVolume.
779 */
780 HWTEST(AudioPolicyManager, SetNearlinkDeviceVolume_001, TestSize.Level1)
781 {
782 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
783 ASSERT_TRUE(audioPolicyManager_ != nullptr);
784
785 std::string macAddress = "";
786 AudioVolumeType volumeType = AudioVolumeType::STREAM_MUSIC;
787 int32_t volume = 4;
788 bool updateUi = false;
789
790 auto result = audioPolicyManager_->SetNearlinkDeviceVolume(macAddress, volumeType, volume, updateUi);
791 EXPECT_EQ(result, ERR_PERMISSION_DENIED);
792 }
793
794 /**
795 * @tc.name : Test AudioPolicyManager.
796 * @tc.number: SetNearlinkDeviceVolume_002.
797 * @tc.desc : Test SetNearlinkDeviceVolume.
798 */
799 HWTEST(AudioPolicyManager, SetNearlinkDeviceVolume_002, TestSize.Level1)
800 {
801 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
802 ASSERT_TRUE(audioPolicyManager_ != nullptr);
803
804 std::string macAddress = "A1:B2:C3:D4:E5:F6";
805 AudioVolumeType volumeType = AudioVolumeType::STREAM_MUSIC;
806 int32_t volume = 4;
807 bool updateUi = true;
808
809 auto result = audioPolicyManager_->SetNearlinkDeviceVolume(macAddress, volumeType, volume, updateUi);
810 EXPECT_EQ(result, ERR_PERMISSION_DENIED);
811 }
812 } // namespace AudioStandard
813 } // namespace OHOS
814