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
19 using namespace testing::ext;
20
21 namespace OHOS {
22 namespace AudioStandard {
23
SetUpTestCase(void)24 void AudioPolicyManagerUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)25 void AudioPolicyManagerUnitTest::TearDownTestCase(void) {}
SetUp(void)26 void AudioPolicyManagerUnitTest::SetUp(void) {}
TearDown(void)27 void AudioPolicyManagerUnitTest::TearDown(void) {}
28
29 /**
30 * @tc.name : Test AudioPolicyManager.
31 * @tc.number: AudioPolicyManagerUnitTest_001.
32 * @tc.desc : Test GetOutputDevice.
33 */
34 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_001, TestSize.Level1)
35 {
36 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
37 sptr<AudioRendererFilter> audioRendererFilter = new(std::nothrow) AudioRendererFilter();
38 audioPolicyManager_->GetOutputDevice(audioRendererFilter);
39 EXPECT_NE(audioPolicyManager_, nullptr);
40 }
41
42 /**
43 * @tc.name : Test AudioPolicyManager.
44 * @tc.number: AudioPolicyManagerUnitTest_002.
45 * @tc.desc : Test GetInputDevice.
46 */
47 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_002, TestSize.Level1)
48 {
49 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
50 sptr<AudioCapturerFilter> audioCapturerFilter = new(std::nothrow) AudioCapturerFilter();
51 audioPolicyManager_->GetInputDevice(audioCapturerFilter);
52 EXPECT_NE(audioPolicyManager_, nullptr);
53 }
54
55 /**
56 * @tc.name : Test AudioPolicyManager.
57 * @tc.number: AudioPolicyManagerUnitTest_003.
58 * @tc.desc : Test SetRingerModeCallback.
59 */
60 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_003, TestSize.Level1)
61 {
62 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
63 int32_t clientId = getpid();
64 std::shared_ptr<AudioRingerModeCallback> callback = std::make_shared<ConcreteAudioRingerModeCallback>();
65 audioPolicyManager_->SetRingerModeCallback(clientId, callback, API_VERSION::API_9);
66 EXPECT_NE(audioPolicyManager_, nullptr);
67 }
68
69 /**
70 * @tc.name : Test AudioPolicyManager.
71 * @tc.number: AudioPolicyManagerUnitTest_004.
72 * @tc.desc : Test SetMicrophoneBlockedCallback.
73 */
74 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_004, TestSize.Level1)
75 {
76 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
77 int32_t clientId = getpid();
78 std::shared_ptr<AudioManagerMicrophoneBlockedCallback> callback =
79 std::make_shared<ConcreteAudioManagerMicrophoneBlockedCallback>();
80 audioPolicyManager_->SetMicrophoneBlockedCallback(clientId, callback);
81 EXPECT_NE(audioPolicyManager_, nullptr);
82
83 audioPolicyManager_->isAudioPolicyClientRegisted_.store(true);
84 audioPolicyManager_->SetMicrophoneBlockedCallback(clientId, callback);
85 EXPECT_NE(audioPolicyManager_, nullptr);
86
87 audioPolicyManager_->audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
88 audioPolicyManager_->SetMicrophoneBlockedCallback(clientId, callback);
89 EXPECT_NE(audioPolicyManager_, nullptr);
90 }
91
92 /**
93 * @tc.name : Test AudioPolicyManager.
94 * @tc.number: AudioPolicyManagerUnitTest_005.
95 * @tc.desc : Test UnsetPreferredInputDeviceChangeCallback.
96 */
97 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_005, TestSize.Level1)
98 {
99 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
100 audioPolicyManager_->audioPolicyClientStubCB_ = nullptr;
101 int32_t result = audioPolicyManager_->UnsetPreferredInputDeviceChangeCallback();
102 EXPECT_EQ(result, SUCCESS);
103 }
104
105 /**
106 * @tc.name : Test AudioPolicyManager.
107 * @tc.number: AudioPolicyManagerUnitTest_006.
108 * @tc.desc : Test UnsetMicrophoneBlockedCallback.
109 */
110 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_006, TestSize.Level1)
111 {
112 int32_t clientId = getpid();
113 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
114 std::shared_ptr<AudioManagerMicrophoneBlockedCallback> callback =
115 std::make_shared<ConcreteAudioManagerMicrophoneBlockedCallback>();
116 audioPolicyManager_->audioPolicyClientStubCB_ = nullptr;
117 int32_t result = audioPolicyManager_->UnsetMicrophoneBlockedCallback(clientId, callback);
118 EXPECT_EQ(result, SUCCESS);
119
120 audioPolicyManager_->audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
121 result = audioPolicyManager_->UnsetMicrophoneBlockedCallback(clientId, callback);
122 EXPECT_EQ(result, SUCCESS);
123 }
124
125 /**
126 * @tc.name : Test AudioPolicyManager.
127 * @tc.number: AudioPolicyManagerUnitTest_007.
128 * @tc.desc : Test UnregisterAudioRendererEventListener.
129 */
130 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_007, TestSize.Level1)
131 {
132 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
133 std::shared_ptr<AudioRendererStateChangeCallback> callback;
134 auto audioPolicyClient_ = std::make_shared<AudioPolicyClientStubImpl>();
135 audioPolicyClient_->AddRendererStateChangeCallback(callback);
136 audioPolicyManager_->audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
137 audioPolicyManager_->isAudioRendererEventListenerRegistered = true;
138 audioPolicyManager_->UnregisterAudioRendererEventListener(callback);
139 EXPECT_NE(audioPolicyManager_, nullptr);
140 }
141
142 /**
143 * @tc.name : Test AudioPolicyManager.
144 * @tc.number: AudioPolicyManagerUnitTest_008.
145 * @tc.desc : Test UnregisterAudioRendererEventListener.
146 */
147 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_008, TestSize.Level1)
148 {
149 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
150 std::shared_ptr<AudioRendererStateChangeCallback> callback =
151 std::make_shared<ConcreteAudioRendererStateChange>();
152 audioPolicyManager_->audioPolicyClientStubCB_ = nullptr;
153 audioPolicyManager_->isAudioRendererEventListenerRegistered = true;
154 audioPolicyManager_->UnregisterAudioRendererEventListener(callback);
155 EXPECT_NE(audioPolicyManager_, nullptr);
156
157 audioPolicyManager_->audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
158 audioPolicyManager_->isAudioRendererEventListenerRegistered = false;
159 audioPolicyManager_->UnregisterAudioRendererEventListener(callback);
160 EXPECT_NE(audioPolicyManager_, nullptr);
161
162 auto audioPolicyClient_ = std::make_shared<AudioPolicyClientStubImpl>();
163 audioPolicyClient_->AddRendererStateChangeCallback(callback);
164 audioPolicyManager_->audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
165 audioPolicyManager_->isAudioRendererEventListenerRegistered = true;
166 audioPolicyManager_->UnregisterAudioRendererEventListener(callback);
167 EXPECT_NE(audioPolicyManager_, nullptr);
168 }
169
170 /**
171 * @tc.name : Test AudioPolicyManager.
172 * @tc.number: AudioPolicyManagerUnitTest_009.
173 * @tc.desc : Test UnregisterAudioCapturerEventListener.
174 */
175 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_009, TestSize.Level1)
176 {
177 int32_t clientId = getpid();
178 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
179 auto audioPolicyClient_ = std::make_shared<AudioPolicyClientStubImpl>();
180 auto cb = std::make_shared<ConcreteAudioCapturerStateChangeCallback>();
181 audioPolicyClient_->AddCapturerStateChangeCallback(cb);
182 audioPolicyManager_->audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
183 audioPolicyManager_->isAudioCapturerEventListenerRegistered = false;
184 audioPolicyManager_->UnregisterAudioCapturerEventListener(clientId);
185 EXPECT_NE(audioPolicyManager_, nullptr);
186 }
187
188 /**
189 * @tc.name : Test AudioPolicyManager.
190 * @tc.number: AudioPolicyManagerUnitTest_010.
191 * @tc.desc : Test SetDistributedRoutingRoleCallback.
192 */
193 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_010, TestSize.Level1)
194 {
195 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
196 int result = audioPolicyManager_->SetDistributedRoutingRoleCallback(nullptr);
197 EXPECT_EQ(result, ERR_INVALID_PARAM);
198 }
199
200 /**
201 * @tc.name : Test AudioPolicyManager.
202 * @tc.number: AudioPolicyManagerUnitTest_012.
203 * @tc.desc : Test GetConverterConfig.
204 */
205 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_012, TestSize.Level1)
206 {
207 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
208 audioPolicyManager_->GetConverterConfig();
209 EXPECT_NE(audioPolicyManager_, nullptr);
210 }
211
212 /**
213 * @tc.name : Test AudioPolicyManager.
214 * @tc.number: AudioPolicyManagerUnitTest_013.
215 * @tc.desc : Test ActivateAudioSession.
216 */
217 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_013, TestSize.Level1)
218 {
219 AudioSessionStrategy strategy;
220 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
221 audioPolicyManager_->ActivateAudioSession(strategy);
222 EXPECT_NE(audioPolicyManager_, nullptr);
223
224 audioPolicyManager_->isAudioPolicyClientRegisted_.store(true);
225 audioPolicyManager_->ActivateAudioSession(strategy);
226 EXPECT_NE(audioPolicyManager_, nullptr);
227 }
228
229 /**
230 * @tc.name : Test AudioPolicyManager.
231 * @tc.number: AudioPolicyManagerUnitTest_014.
232 * @tc.desc : Test SetAudioSessionCallback.
233 */
234 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_014, TestSize.Level1)
235 {
236 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
237 auto audioSessionCallback = std::make_shared<ConcreteAudioSessionCallback>();
238 audioPolicyManager_->isAudioPolicyClientRegisted_.store(true);
239 audioPolicyManager_->audioPolicyClientStubCB_ = nullptr;
240 int32_t result = audioPolicyManager_->SetAudioSessionCallback(audioSessionCallback);
241 EXPECT_EQ(result, ERROR_ILLEGAL_STATE);
242
243 audioPolicyManager_->audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
244 audioPolicyManager_->isAudioPolicyClientRegisted_.store(false);
245 result = audioPolicyManager_->SetAudioSessionCallback(audioSessionCallback);
246 EXPECT_NE(audioPolicyManager_, nullptr);
247
248 audioPolicyManager_->isAudioPolicyClientRegisted_.store(true);
249 std::shared_ptr<AudioSessionCallback> cb = std::make_shared<ConcreteAudioSessionCallback>();
250 audioPolicyManager_->audioPolicyClientStubCB_->audioSessionCallbackList_.push_back(cb);
251 result = audioPolicyManager_->SetAudioSessionCallback(audioSessionCallback);
252 EXPECT_EQ(result, SUCCESS);
253 }
254
255 /**
256 * @tc.name : Test AudioPolicyManager.
257 * @tc.number: AudioPolicyManagerUnitTest_015.
258 * @tc.desc : Test UnsetAudioSessionCallback.
259 */
260 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_015, TestSize.Level1)
261 {
262 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
263 audioPolicyManager_->audioPolicyClientStubCB_ = nullptr;
264 int32_t result = audioPolicyManager_->UnsetAudioSessionCallback();
265 EXPECT_EQ(result, ERROR_ILLEGAL_STATE);
266
267 audioPolicyManager_->audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
268 result = audioPolicyManager_->UnsetAudioSessionCallback();
269 EXPECT_EQ(result, SUCCESS);
270
271 std::shared_ptr<AudioSessionCallback> cb = std::make_shared<ConcreteAudioSessionCallback>();
272 audioPolicyManager_->audioPolicyClientStubCB_->audioSessionCallbackList_.push_back(cb);
273 result = audioPolicyManager_->UnsetAudioSessionCallback();
274 EXPECT_EQ(result, SUCCESS);
275 }
276
277 /**
278 * @tc.name : Test AudioPolicyManager.
279 * @tc.number: AudioPolicyManagerUnitTest_016.
280 * @tc.desc : Test UnsetAudioSessionCallback.
281 */
282 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_016, TestSize.Level1)
283 {
284 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
285 std::shared_ptr<AudioSessionCallback> audioSessionCallback =
286 std::make_shared<ConcreteAudioSessionCallback>();
287 audioPolicyManager_->audioPolicyClientStubCB_ = nullptr;
288 int32_t result = audioPolicyManager_->UnsetAudioSessionCallback(audioSessionCallback);
289 EXPECT_EQ(result, ERROR_ILLEGAL_STATE);
290
291 audioPolicyManager_->audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
292 result = audioPolicyManager_->UnsetAudioSessionCallback(audioSessionCallback);
293 EXPECT_EQ(result, SUCCESS);
294
295 std::shared_ptr<AudioSessionCallback> cb = std::make_shared<ConcreteAudioSessionCallback>();
296 audioPolicyManager_->audioPolicyClientStubCB_->audioSessionCallbackList_.push_back(cb);
297 result = audioPolicyManager_->UnsetAudioSessionCallback(audioSessionCallback);
298 EXPECT_EQ(result, SUCCESS);
299 }
300
301 /**
302 * @tc.name : Test AudioPolicyManager.
303 * @tc.number: AudioPolicyManagerUnitTest_017.
304 * @tc.desc : Test RegisterHeadTrackingDataRequestedEventListener.
305 */
306 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_017, TestSize.Level1)
307 {
308 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
309 std::string macAddress = "macAddress";
310 auto callback = std::make_shared<ConcreteHeadTrackingDataRequestedChangeCallback>();
311 audioPolicyManager_->RegisterHeadTrackingDataRequestedEventListener(macAddress, callback);
312 EXPECT_NE(audioPolicyManager_, nullptr);
313
314 audioPolicyManager_->isAudioPolicyClientRegisted_ = true;
315 audioPolicyManager_->RegisterHeadTrackingDataRequestedEventListener(macAddress, callback);
316 EXPECT_NE(audioPolicyManager_, nullptr);
317 }
318
319 /**
320 * @tc.name : Test AudioPolicyManager.
321 * @tc.number: AudioPolicyManagerUnitTest_018.
322 * @tc.desc : Test UnregisterHeadTrackingDataRequestedEventListener.
323 */
324 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_018, TestSize.Level1)
325 {
326 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
327 std::string macAddress = "macAddress";
328 audioPolicyManager_->audioPolicyClientStubCB_ = nullptr;
329 audioPolicyManager_->UnregisterHeadTrackingDataRequestedEventListener(macAddress);
330 EXPECT_NE(audioPolicyManager_, nullptr);
331
332 audioPolicyManager_->audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
333 audioPolicyManager_->UnregisterHeadTrackingDataRequestedEventListener(macAddress);
334 EXPECT_NE(audioPolicyManager_, nullptr);
335 }
336
337 /**
338 * @tc.name : Test AudioPolicyManager.
339 * @tc.number: AudioPolicyManagerUnitTest_019.
340 * @tc.desc : Test SetAudioDeviceRefinerCallback.
341 */
342 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_019, TestSize.Level1)
343 {
344 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
345 int32_t result = audioPolicyManager_->SetAudioDeviceRefinerCallback(nullptr);
346 EXPECT_EQ(result, ERR_INVALID_PARAM);
347
348 std::shared_ptr<AudioDeviceRefiner> callback = std::make_shared<ConcreteAudioDeviceRefiner>();
349 audioPolicyManager_->SetAudioDeviceRefinerCallback(callback);
350 EXPECT_NE(audioPolicyManager_, nullptr);
351 }
352
353 /**
354 * @tc.name : Test AudioPolicyManager.
355 * @tc.number: AudioPolicyManagerUnitTest_020.
356 * @tc.desc : Test SetAudioDeviceRefinerCallback.
357 */
358 HWTEST(AudioPolicyManager, AudioPolicyManagerUnitTest_020, TestSize.Level1)
359 {
360 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
361 int32_t result = audioPolicyManager_->SetAudioDeviceAnahsCallback(nullptr);
362 EXPECT_EQ(result, ERR_INVALID_PARAM);
363
364 std::shared_ptr<AudioDeviceAnahs> callback = std::make_shared<ConcreteAudioDeviceAnahs>();
365 audioPolicyManager_->SetAudioDeviceAnahsCallback(nullptr);
366 EXPECT_NE(audioPolicyManager_, nullptr);
367 }
368
369 /**
370 * @tc.name : Test GetOutputDevice.
371 * @tc.number: GetOutputDevice.
372 * @tc.desc : Test GetOutputDevice.
373 */
374 HWTEST(AudioPolicyManager, GetOutputDevice_001, TestSize.Level1)
375 {
376 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
377
378 sptr<AudioRendererFilter> audioRendererFilter = new AudioRendererFilter();
379 audioPolicyManager_->GetOutputDevice(audioRendererFilter);
380 EXPECT_NE(audioPolicyManager_, nullptr);
381 }
382
383 /**
384 * @tc.name : Test GetInputDevice.
385 * @tc.number: GetInputDevice.
386 * @tc.desc : Test GetInputDevice.
387 */
388 HWTEST(AudioPolicyManager, GetInputDevice_001, TestSize.Level1)
389 {
390 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
391
392 sptr<AudioCapturerFilter> audioRendererFilter = new AudioCapturerFilter();
393 audioPolicyManager_->GetInputDevice(audioRendererFilter);
394 EXPECT_NE(audioPolicyManager_, nullptr);
395 }
396
397 /**
398 * @tc.name : Test SetMicrophoneBlockedCallback.
399 * @tc.number: SetMicrophoneBlockedCallback.
400 * @tc.desc : Test SetMicrophoneBlockedCallback.
401 */
402 HWTEST(AudioPolicyManager, SetMicrophoneBlockedCallback_001, TestSize.Level1)
403 {
404 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
405
406 const int32_t clientId = 111;
407 std::shared_ptr<AudioManagerMicrophoneBlockedCallback> callback_ =
408 std::make_shared<ConcreteAudioManagerMicrophoneBlockedCallback>();
409 const std::shared_ptr<AudioManagerMicrophoneBlockedCallback> callback = callback_;
410 int32_t ret = audioPolicyManager_->SetMicrophoneBlockedCallback(clientId, callback);
411 EXPECT_EQ(ret, SUCCESS);
412 }
413
414 /**
415 * @tc.name : Test UnsetMicrophoneBlockedCallback.
416 * @tc.number: UnsetMicrophoneBlockedCallback.
417 * @tc.desc : Test UnsetMicrophoneBlockedCallback.
418 */
419 HWTEST(AudioPolicyManager, UnsetMicrophoneBlockedCallback_001, TestSize.Level1)
420 {
421 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
422
423 const int32_t clientId = 111;
424 std::shared_ptr<AudioManagerMicrophoneBlockedCallback> callback_ =
425 std::make_shared<ConcreteAudioManagerMicrophoneBlockedCallback>();
426 const std::shared_ptr<AudioManagerMicrophoneBlockedCallback> callback = callback_;
427 int32_t ret = audioPolicyManager_->UnsetMicrophoneBlockedCallback(clientId, callback);
428 EXPECT_EQ(ret, SUCCESS);
429 }
430
431 /**
432 * @tc.name : Test ActivateAudioSession.
433 * @tc.number: ActivateAudioSession.
434 * @tc.desc : Test ActivateAudioSession.
435 */
436 HWTEST(AudioPolicyManager, ActivateAudioSession_001, TestSize.Level1)
437 {
438 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
439
440 const AudioSessionStrategy strategy;
441 int32_t ret = audioPolicyManager_->ActivateAudioSession(strategy);
442 EXPECT_EQ(ret, SUCCESS);
443 }
444
445 /**
446 * @tc.name : Test SetAudioSessionCallback.
447 * @tc.number: SetAudioSessionCallback.
448 * @tc.desc : Test SetAudioSessionCallback.
449 */
450 HWTEST(AudioPolicyManager, SetAudioSessionCallback_001, TestSize.Level1)
451 {
452 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
453
454 const std::shared_ptr<AudioSessionCallback> audioSessionCallback =
455 std::make_shared<ConcreteAudioSessionCallback>();
456 int32_t ret = audioPolicyManager_->SetAudioSessionCallback(audioSessionCallback);
457 EXPECT_EQ(ret, 0);
458 }
459
460 /**
461 * @tc.name : Test SetAudioSessionCallback.
462 * @tc.number: SetAudioSessionCallback.
463 * @tc.desc : Test SetAudioSessionCallback.
464 */
465 HWTEST(AudioPolicyManager, SetAudioSessionCallback_002, TestSize.Level1)
466 {
467 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
468
469 const std::shared_ptr<AudioSessionCallback> audioSessionCallback =
470 std::make_shared<ConcreteAudioSessionCallback>();
471 audioPolicyManager_->isAudioPolicyClientRegisted_ = true;
472 int32_t ret = audioPolicyManager_->SetAudioSessionCallback(audioSessionCallback);
473 EXPECT_EQ(ret, ERROR_ILLEGAL_STATE);
474 }
475
476 /**
477 * @tc.name : Test SetAudioSessionCallback.
478 * @tc.number: SetAudioSessionCallback.
479 * @tc.desc : Test SetAudioSessionCallback.
480 */
481 HWTEST(AudioPolicyManager, SetAudioSessionCallback_003, TestSize.Level1)
482 {
483 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
484
485 const std::shared_ptr<AudioSessionCallback> audioSessionCallback =
486 std::make_shared<ConcreteAudioSessionCallback>();
487 audioPolicyManager_->isAudioPolicyClientRegisted_ = true;
488 audioPolicyManager_->audioPolicyClientStubCB_ = new AudioPolicyClientStubImpl();
489 int32_t ret = audioPolicyManager_->SetAudioSessionCallback(audioSessionCallback);
490 EXPECT_EQ(ret, SUCCESS);
491 }
492
493 /**
494 * @tc.name : Test UnsetAudioSessionCallback.
495 * @tc.number: UnsetAudioSessionCallback.
496 * @tc.desc : Test UnsetAudioSessionCallback.
497 */
498 HWTEST(AudioPolicyManager, UnsetAudioSessionCallback_001, TestSize.Level1)
499 {
500 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
501
502 int32_t ret = audioPolicyManager_->UnsetAudioSessionCallback();
503 EXPECT_EQ(ret, ERROR_ILLEGAL_STATE);
504 }
505
506 /**
507 * @tc.name : Test UnsetAudioSessionCallback.
508 * @tc.number: UnsetAudioSessionCallback.
509 * @tc.desc : Test UnsetAudioSessionCallback.
510 */
511 HWTEST(AudioPolicyManager, UnsetAudioSessionCallback_002, TestSize.Level1)
512 {
513 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
514
515 audioPolicyManager_->audioPolicyClientStubCB_ = new AudioPolicyClientStubImpl();
516 int32_t ret = audioPolicyManager_->UnsetAudioSessionCallback();
517 EXPECT_EQ(ret, SUCCESS);
518 }
519
520 /**
521 * @tc.name : Test UnsetAudioSessionCallback.
522 * @tc.number: UnsetAudioSessionCallback.
523 * @tc.desc : Test UnsetAudioSessionCallback.
524 */
525 HWTEST(AudioPolicyManager, UnsetAudioSessionCallback_ptr_001, TestSize.Level1)
526 {
527 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
528 const std::shared_ptr<AudioSessionCallback> audioSessionCallback =
529 std::make_shared<ConcreteAudioSessionCallback>();
530
531 int32_t ret = audioPolicyManager_->UnsetAudioSessionCallback(audioSessionCallback);
532 EXPECT_EQ(ret, ERROR_ILLEGAL_STATE);
533 }
534
535 /**
536 * @tc.name : Test UnsetAudioSessionCallback.
537 * @tc.number: UnsetAudioSessionCallback.
538 * @tc.desc : Test UnsetAudioSessionCallback.
539 */
540 HWTEST(AudioPolicyManager, UnsetAudioSessionCallback_ptr_002, TestSize.Level1)
541 {
542 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
543 const std::shared_ptr<AudioSessionCallback> audioSessionCallback =
544 std::make_shared<ConcreteAudioSessionCallback>();
545
546 audioPolicyManager_->audioPolicyClientStubCB_ = new AudioPolicyClientStubImpl();
547 int32_t ret = audioPolicyManager_->UnsetAudioSessionCallback(audioSessionCallback);
548 EXPECT_EQ(ret, SUCCESS);
549 }
550
551 /**
552 * @tc.name : Test AudioPolicyManager.
553 * @tc.number: SetAudioSceneChangeCallbackTest_001.
554 * @tc.desc : Test SetAudioSceneChangeCallback.
555 */
556 HWTEST(AudioPolicyManager, SetAudioSceneChangeCallbackTest_001, TestSize.Level1)
557 {
558 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
559 int32_t clientId = getpid();
560 std::shared_ptr<AudioManagerAudioSceneChangedCallback> callback =
561 std::make_shared<ConcreteAudioManagerAudioSceneChangedCallback>();
562 audioPolicyManager_->SetAudioSceneChangeCallback(clientId, callback);
563 EXPECT_NE(audioPolicyManager_, nullptr);
564 }
565
566 /**
567 * @tc.name : Test AudioPolicyManager.
568 * @tc.number: UnsetAudioSceneChangeCallbackTest_001.
569 * @tc.desc : Test UnsetAudioSceneChangeCallback.
570 */
571 HWTEST(AudioPolicyManager, UnsetAudioSceneChangeCallbackTest_001, TestSize.Level1)
572 {
573 auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
574 std::shared_ptr<AudioManagerAudioSceneChangedCallback> callback =
575 std::make_shared<ConcreteAudioManagerAudioSceneChangedCallback>();
576 audioPolicyManager_->audioPolicyClientStubCB_ = nullptr;
577 int32_t result = audioPolicyManager_->UnsetAudioSceneChangeCallback(callback);
578 EXPECT_EQ(result, SUCCESS);
579
580 audioPolicyManager_->audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
581 result = audioPolicyManager_->UnsetAudioSceneChangeCallback(callback);
582 EXPECT_EQ(result, SUCCESS);
583 }
584 } // namespace AudioStandard
585 } // namespace OHOS
586