1 /*
2 * Copyright (c) 2022 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 <thread>
17 #include "audio_errors.h"
18 #include "audio_info.h"
19 #include "parcel.h"
20 #include "audio_policy_unit_test.h"
21 #include "audio_system_manager.h"
22 #include "iservice_registry.h"
23 #include "system_ability_definition.h"
24 #include "audio_capturer_state_change_listener_stub.h"
25 #include "audio_renderer_state_change_listener_stub.h"
26 #include "audio_ringermode_update_listener_stub.h"
27 #include "audio_routing_manager_listener_stub.h"
28 #include "audio_client_tracker_callback_stub.h"
29
30 using namespace std;
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace AudioStandard {
35 const int32_t FAILURE = -1;
SetUpTestCase(void)36 void AudioPolicyUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)37 void AudioPolicyUnitTest::TearDownTestCase(void) {}
SetUp(void)38 void AudioPolicyUnitTest::SetUp(void) {}
TearDown(void)39 void AudioPolicyUnitTest::TearDown(void) {}
InitAudioPolicyProxy(std::shared_ptr<AudioPolicyProxy> & audioPolicyProxy)40 void AudioPolicyUnitTest::InitAudioPolicyProxy(std::shared_ptr<AudioPolicyProxy> &audioPolicyProxy)
41 {
42 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
43 if (samgr == nullptr) {
44 AUDIO_ERR_LOG("InitAudioPolicyProxy::GetSystemAbilityManager failed");
45 return;
46 }
47
48 sptr<IRemoteObject> object = samgr->GetSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID);
49 if (object == nullptr) {
50 AUDIO_ERR_LOG("InitAudioPolicyProxy::object is NULL.");
51 return;
52 }
53 audioPolicyProxy = std::make_shared<AudioPolicyProxy>(object);
54 }
55
GetIRemoteObject(sptr<IRemoteObject> & object)56 void AudioPolicyUnitTest::GetIRemoteObject(sptr<IRemoteObject> &object)
57 {
58 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
59 if (samgr == nullptr) {
60 AUDIO_ERR_LOG("GetIRemoteObject::GetSystemAbilityManager failed");
61 return;
62 }
63
64 object = samgr->GetSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID);
65 if (object == nullptr) {
66 AUDIO_ERR_LOG("GetIRemoteObject::object is NULL.");
67 return;
68 }
69 }
70
InitAudioStream(std::shared_ptr<AudioStream> & audioStream)71 void AudioPolicyUnitTest::InitAudioStream(std::shared_ptr<AudioStream> &audioStream)
72 {
73 AppInfo appInfo_ = {};
74 if (!(appInfo_.appPid)) {
75 appInfo_.appPid = getpid();
76 }
77
78 if (appInfo_.appUid < 0) {
79 appInfo_.appUid = static_cast<int32_t>(getuid());
80 }
81
82 audioStream = std::make_shared<AudioStream>(STREAM_NOTIFICATION, AUDIO_MODE_PLAYBACK, appInfo_.appUid);
83 if (audioStream) {
84 AUDIO_DEBUG_LOG("InitAudioStream::Audio stream created");
85 }
86 }
87
GetSessionId(std::shared_ptr<AudioStream> & audioStream)88 uint32_t AudioPolicyUnitTest::GetSessionId(std::shared_ptr<AudioStream> &audioStream)
89 {
90 uint32_t sessionID_ = static_cast<uint32_t>(-1);
91 if (audioStream->GetAudioSessionID(sessionID_) != 0) {
92 AUDIO_ERR_LOG("AudioPolicyUnitTest::GetSessionId Failed");
93 }
94 return sessionID_;
95 }
96
97 /**
98 * @tc.name : Test Audio_Policy_SetMicrophoneMuteAudioConfig_001 via illegal state
99 * @tc.number: Audio_Policy_SetMicrophoneMuteAudioConfig_001
100 * @tc.desc : Test SetMicrophoneMuteAudioConfig interface. Returns success.
101 */
102 HWTEST(AudioPolicyUnitTest, Audio_Policy_SetMicrophoneMuteAudioConfig_001, TestSize.Level1)
103 {
104 std::shared_ptr<AudioPolicyProxy> audioPolicyProxy;
105 AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy);
106 ASSERT_NE(nullptr, audioPolicyProxy);
107
108 bool isMute = true;
109 int32_t ret = audioPolicyProxy->SetMicrophoneMuteAudioConfig(isMute);
110 EXPECT_EQ(FAILURE, ret);
111 }
112
113 /**
114 * @tc.name : Test Audio_Policy_GetSupportedTones_001 via legal state
115 * @tc.number: Audio_Policy_GetSupportedTones_001
116 * @tc.desc : Test GetSupportedTones interface. Returns success.
117 */
118 HWTEST(AudioPolicyUnitTest, Audio_Policy_GetSupportedTones_001, TestSize.Level1)
119 {
120 std::shared_ptr<AudioPolicyProxy> audioPolicyProxy;
121 AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy);
122 ASSERT_NE(nullptr, audioPolicyProxy);
123
124 audioPolicyProxy->GetSupportedTones();
125 }
126
127 /**
128 * @tc.name : Test Audio_Policy_GetToneConfig_001 via legal state
129 * @tc.number: Audio_Policy_GetToneConfig_001
130 * @tc.desc : Test GetToneConfig interface. Returns success.
131 */
132 HWTEST(AudioPolicyUnitTest, Audio_Policy_GetToneConfig_001, TestSize.Level1)
133 {
134 std::shared_ptr<AudioPolicyProxy> audioPolicyProxy;
135 AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy);
136 ASSERT_NE(nullptr, audioPolicyProxy);
137
138 int32_t ltonetype = 0;
139 std::shared_ptr<ToneInfo> toneInfo = audioPolicyProxy->GetToneConfig(ltonetype);
140 ASSERT_NE(nullptr, toneInfo);
141 }
142
143 /**
144 * @tc.name : Test Audio_Policy_IsStreamActive_001 via legal state
145 * @tc.number: Audio_Policy_IsStreamActive_001
146 * @tc.desc : Test IsStreamActive interface. Returns success.
147 */
148 HWTEST(AudioPolicyUnitTest, Audio_Policy_IsStreamActive_001, TestSize.Level1)
149 {
150 std::shared_ptr<AudioPolicyProxy> audioPolicyProxy;
151 AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy);
152 ASSERT_NE(nullptr, audioPolicyProxy);
153
154 AudioStreamType streamType = AudioStreamType::STREAM_MUSIC;
155 bool isStreamActive = audioPolicyProxy->IsStreamActive(streamType);
156 EXPECT_EQ(false, isStreamActive);
157 }
158
159 /**
160 * @tc.name : Test Audio_Policy_SelectInputDevice_001 via illegal state
161 * @tc.number: Audio_Policy_SelectInputDevice_001
162 * @tc.desc : Test SelectInputDevice interface. Returns success.
163 */
164 HWTEST(AudioPolicyUnitTest, Audio_Policy_SelectInputDevice_001, TestSize.Level1)
165 {
166 std::shared_ptr<AudioPolicyProxy> audioPolicyProxy;
167 AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy);
168 ASSERT_NE(nullptr, audioPolicyProxy);
169
170 AudioSystemManager *audioSystemMgr = AudioSystemManager::GetInstance();
171 DeviceFlag deviceFlag = DeviceFlag::INPUT_DEVICES_FLAG;
172 std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptorsVector;
173 audioDeviceDescriptorsVector = audioSystemMgr->GetDevices(deviceFlag);
174
175 sptr<AudioCapturerFilter> audioCapturerFilter = new(std::nothrow) AudioCapturerFilter();
176 audioCapturerFilter->uid = DeviceFlag::INPUT_DEVICES_FLAG;
177
178 int32_t ret = audioPolicyProxy->SelectInputDevice(audioCapturerFilter, audioDeviceDescriptorsVector);
179 EXPECT_EQ(FAILURE, ret);
180 }
181
182 /**
183 * @tc.name : Test Audio_Policy_DeviceChangeCallback_001 via illegal state
184 * @tc.number: Audio_Policy_DeviceChangeCallback_001
185 * @tc.desc : Test SetDeviceChangeCallback and UnsetDeviceChangeCallback interface. Returns success.
186 */
187 HWTEST(AudioPolicyUnitTest, Audio_Policy_DeviceChangeCallback_001, TestSize.Level1)
188 {
189 std::shared_ptr<AudioPolicyProxy> audioPolicyProxy;
190 AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy);
191 ASSERT_NE(nullptr, audioPolicyProxy);
192
193 int32_t clientId = getpid();
194 DeviceFlag flag = DeviceFlag::OUTPUT_DEVICES_FLAG;
195 sptr<IRemoteObject> object;
196 AudioPolicyUnitTest::GetIRemoteObject(object);
197
198 int32_t ret = audioPolicyProxy->SetDeviceChangeCallback(clientId, flag, object);
199 EXPECT_EQ(FAILURE, ret);
200
201 ret = audioPolicyProxy->UnsetDeviceChangeCallback(clientId);
202 EXPECT_EQ(FAILURE, ret);
203 }
204
205 /**
206 * @tc.name : Test Audio_Policy_GetStreamInFocus_001 via legal state
207 * @tc.number: Audio_Policy_GetStreamInFocus_001
208 * @tc.desc : Test GetStreamInFocus interface. Returns success.
209 */
210 HWTEST(AudioPolicyUnitTest, Audio_Policy_GetStreamInFocus_001, TestSize.Level1)
211 {
212 std::shared_ptr<AudioPolicyProxy> audioPolicyProxy;
213 AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy);
214 ASSERT_NE(nullptr, audioPolicyProxy);
215
216 audioPolicyProxy->GetStreamInFocus();
217 }
218
219 /**
220 * @tc.name : Test Audio_Policy_IsAudioRendererLowLatencySupported_001 via legal state
221 * @tc.number: Audio_Policy_IsAudioRendererLowLatencySupported_001
222 * @tc.desc : Test IsAudioRendererLowLatencySupported interface. Returns success.
223 */
224 HWTEST(AudioPolicyUnitTest, Audio_Policy_IsAudioRendererLowLatencySupported_001, TestSize.Level1)
225 {
226 std::shared_ptr<AudioPolicyProxy> audioPolicyProxy;
227 AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy);
228 ASSERT_NE(nullptr, audioPolicyProxy);
229
230 AudioStreamInfo audioStreamInfo;
231 audioStreamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
232 audioStreamInfo.encoding = AudioEncodingType::ENCODING_PCM;
233 audioStreamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
234 audioStreamInfo.channels = AudioChannel::MONO;
235 bool ret = audioPolicyProxy->IsAudioRendererLowLatencySupported(audioStreamInfo);
236 EXPECT_EQ(true, ret);
237 }
238
239 /**
240 * @tc.name : Test Audio_Policy_RegisterAudioRendererEventListener_001 via illegal state
241 * @tc.number: Audio_Policy_RegisterAudioRendererEventListener_001
242 * @tc.desc : Test RegisterAudioRendererEventListener interface. Returns success.
243 */
244 HWTEST(AudioPolicyUnitTest, Audio_Policy_RegisterAudioRendererEventListener_001, TestSize.Level1)
245 {
246 std::shared_ptr<AudioPolicyProxy> audioPolicyProxy;
247 AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy);
248 ASSERT_NE(nullptr, audioPolicyProxy);
249
250 int32_t clientId = getpid();
251 sptr<IRemoteObject> object;
252 AudioPolicyUnitTest::GetIRemoteObject(object);
253 int32_t ret = audioPolicyProxy->RegisterAudioRendererEventListener(clientId, object);
254 EXPECT_EQ(ERROR, ret);
255
256 ret = audioPolicyProxy->UnregisterAudioRendererEventListener(clientId);
257 EXPECT_EQ(ERROR, ret);
258 }
259
260 /**
261 * @tc.name : Test Audio_Policy_RegisterAudioCapturerEventListener_001 via illegal state
262 * @tc.number: Audio_Policy_RegisterAudioCapturerEventListener_001
263 * @tc.desc : Test RegisterAudioCapturerEventListener interface. Returns success.
264 */
265 HWTEST(AudioPolicyUnitTest, Audio_Policy_RegisterAudioCapturerEventListener_001, TestSize.Level1)
266 {
267 std::shared_ptr<AudioPolicyProxy> audioPolicyProxy;
268 AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy);
269 ASSERT_NE(nullptr, audioPolicyProxy);
270
271 sptr<IRemoteObject> object;
272 AudioPolicyUnitTest::GetIRemoteObject(object);
273 int32_t clientId = getpid();
274
275 int32_t ret = audioPolicyProxy->RegisterAudioCapturerEventListener(clientId, object);
276 EXPECT_EQ(ERROR, ret);
277
278 ret = audioPolicyProxy->UnregisterAudioCapturerEventListener(clientId);
279 EXPECT_EQ(ERROR, ret);
280 }
281
282 /**
283 * @tc.name : Test Audio_Policy_Manager_IsStreamActive_001 via illegal state
284 * @tc.number: Audio_Policy_Manager_IsStreamActive_001
285 * @tc.desc : Test RegisterAudioCapturerEventListener interface. Returns success.
286 */
287 HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_IsStreamActive_001, TestSize.Level1)
288 {
289 bool isStreamActive = AudioPolicyManager::GetInstance().IsStreamActive(AudioStreamType::STREAM_MUSIC);
290 EXPECT_EQ(false, isStreamActive);
291 }
292
293 /**
294 * @tc.name : Test Audio_Policy_Manager_SetMicrophoneMuteAudioConfig_001 via legal state
295 * @tc.number: Audio_Policy_Manager_SetMicrophoneMuteAudioConfig_001
296 * @tc.desc : Test SetMicrophoneMuteAudioConfig interface. Returns success.
297 */
298 HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_SetMicrophoneMuteAudioConfig_001, TestSize.Level1)
299 {
300 bool isMute = true;
301 bool ret = AudioPolicyManager::GetInstance().SetMicrophoneMuteAudioConfig(isMute);
302 EXPECT_EQ(SUCCESS, ret);
303 }
304
305 /**
306 * @tc.name : Test Audio_Policy_Manager_GetSupportedTones_001 via legal state
307 * @tc.number: Audio_Policy_Manager_GetSupportedTones_001
308 * @tc.desc : Test GetSupportedTones interface. Returns success.
309 */
310 HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_GetSupportedTones_001, TestSize.Level1)
311 {
312 AudioPolicyManager::GetInstance().GetSupportedTones();
313 }
314
315 /**
316 * @tc.name : Test Audio_Policy_Manager_GetToneConfig_001 via legal state
317 * @tc.number: Audio_Policy_Manager_GetToneConfig_001
318 * @tc.desc : Test GetToneConfig interface. Returns success.
319 */
320 HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_GetToneConfig_001, TestSize.Level1)
321 {
322 int32_t ltonetype = 0;
323 std::shared_ptr<ToneInfo> toneInfo = AudioPolicyManager::GetInstance().GetToneConfig(ltonetype);
324 ASSERT_NE(nullptr, toneInfo);
325 }
326
327 /**
328 * @tc.name : Test Audio_Policy_Manager_SetDeviceChangeCallback_001 via legal state
329 * @tc.number: Audio_Policy_Manager_SetDeviceChangeCallback_001
330 * @tc.desc : Test SetDeviceChangeCallback interface. Returns success.
331 */
332 HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_SetDeviceChangeCallback_001, TestSize.Level1)
333 {
334 int32_t clientId = getpid();
335 DeviceFlag flag = DeviceFlag::OUTPUT_DEVICES_FLAG;
336 std::shared_ptr<AudioManagerDeviceChangeCallback> callback =
337 std::make_shared<AudioManagerDeviceChangeCallbackTest>();
338
339 int32_t ret = AudioPolicyManager::GetInstance().SetDeviceChangeCallback(clientId, flag, callback);
340 EXPECT_EQ(SUCCESS, ret);
341
342 ret = AudioPolicyManager::GetInstance().UnsetDeviceChangeCallback(clientId);
343 EXPECT_EQ(SUCCESS, ret);
344 }
345
346 /**
347 * @tc.name : Test Audio_Policy_Manager_GetStreamInFocus_001 via legal state
348 * @tc.number: Audio_Policy_Manager_GetStreamInFocus_001
349 * @tc.desc : Test GetStreamInFocus interface. Returns success.
350 */
351 HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_GetStreamInFocus_001, TestSize.Level1)
352 {
353 AudioPolicyManager::GetInstance().GetStreamInFocus();
354 }
355
356 /**
357 * @tc.name : Test Audio_Policy_Manager_GetSessionInfoInFocus_001 via legal state
358 * @tc.number: Audio_Policy_Manager_GetSessionInfoInFocus_001
359 * @tc.desc : Test GetSessionInfoInFocus interface. Returns success.
360 */
361 HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_GetSessionInfoInFocus_001, TestSize.Level1)
362 {
363 AudioInterrupt audioInterrupt;
364 audioInterrupt.contentType = CONTENT_TYPE_RINGTONE;
365 audioInterrupt.streamUsage = STREAM_USAGE_NOTIFICATION_RINGTONE;
366 audioInterrupt.streamType = STREAM_ACCESSIBILITY;
367
368 std::shared_ptr<AudioStream> audioStream;
369 AudioPolicyUnitTest::InitAudioStream(audioStream);
370 ASSERT_NE(nullptr, audioStream);
371
372 uint32_t sessionID_ = AudioPolicyUnitTest::GetSessionId(audioStream);
373 audioInterrupt.sessionID = sessionID_;
374 int32_t ret = AudioPolicyManager::GetInstance().GetSessionInfoInFocus(audioInterrupt);
375 EXPECT_EQ(SUCCESS, ret);
376 }
377
378 /**
379 * @tc.name : Test Audio_Policy_Manager_RegisterAudioRendererEventListener_001 via legal state
380 * @tc.number: Audio_Policy_Manager_RegisterAudioRendererEventListener_001
381 * @tc.desc : Test registerAudioRendererEventListener interface. Returns success.
382 */
383 HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_RegisterAudioRendererEventListener_001, TestSize.Level1)
384 {
385 int32_t clientId = getpid();
386 std::shared_ptr<AudioRendererStateChangeCallback> callback =
387 std::make_shared<AudioRendererStateChangeCallbackTest>();
388 int32_t ret = AudioPolicyManager::GetInstance().RegisterAudioRendererEventListener(clientId, callback);
389 EXPECT_EQ(SUCCESS, ret);
390
391 ret = AudioPolicyManager::GetInstance().UnregisterAudioRendererEventListener(clientId);
392 EXPECT_EQ(SUCCESS, ret);
393 }
394
395 /**
396 * @tc.name : Test Audio_Policy_Manager_RegisterAudioCapturerEventListener_001 via legal state
397 * @tc.number: Audio_Policy_Manager_RegisterAudioCapturerEventListener_001
398 * @tc.desc : Test RegisterAudioCapturerEventListener interface. Returns success.
399 */
400 HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_RegisterAudioCapturerEventListener_001, TestSize.Level1)
401 {
402 int32_t clientId = getpid();
403 std::shared_ptr<AudioCapturerStateChangeCallback> callback =
404 std::make_shared<AudioCapturerStateChangeCallbackTest>();
405 int32_t ret = AudioPolicyManager::GetInstance().RegisterAudioCapturerEventListener(clientId, callback);
406 EXPECT_EQ(SUCCESS, ret);
407
408 ret = AudioPolicyManager::GetInstance().UnregisterAudioCapturerEventListener(clientId);
409 EXPECT_EQ(SUCCESS, ret);
410 }
411
412 /**
413 * @tc.name : Test Audio_Policy_Manager_IsAudioRendererLowLatencySupported_001 via legal state
414 * @tc.number: Audio_Policy_Manager_IsAudioRendererLowLatencySupported_001
415 * @tc.desc : Test IsAudioRendererLowLatencySupported interface. Returns success.
416 */
417 HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_IsAudioRendererLowLatencySupported_001, TestSize.Level1)
418 {
419 AudioStreamInfo audioStreamInfo;
420 audioStreamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
421 audioStreamInfo.encoding = AudioEncodingType::ENCODING_PCM;
422 audioStreamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
423 audioStreamInfo.channels = AudioChannel::MONO;
424 bool ret = AudioPolicyManager::GetInstance().IsAudioRendererLowLatencySupported(audioStreamInfo);
425 EXPECT_EQ(true, ret);
426 }
427
428 /**
429 * @tc.name : Test Audio_Policy_GetActiveOutputDeviceDescriptors_001 via legal state
430 * @tc.number: Audio_Policy_GetActiveOutputDeviceDescriptors_001
431 * @tc.desc : Test GetActiveOutputDeviceDescriptors interface. Returns success.
432 */
433 HWTEST(AudioPolicyUnitTest, Audio_Policy_GetActiveOutputDeviceDescriptors_001, TestSize.Level1)
434 {
435 std::shared_ptr<AudioPolicyProxy> audioPolicyProxy;
436 AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy);
437 ASSERT_NE(nullptr, audioPolicyProxy);
438
439 std::vector<sptr<AudioDeviceDescriptor>> deviceInfo;
440 deviceInfo = audioPolicyProxy->GetActiveOutputDeviceDescriptors();
441 EXPECT_EQ(true, deviceInfo.size() >= 0);
442 }
443
444 /**
445 * @tc.name : Test Audio_Policy_SetMicStateChangeCallback_001 via legal state
446 * @tc.number: Audio_Policy_SetMicStateChangeCallback_001
447 * @tc.desc : Test SetMicStateChangeCallback interface. Returns success.
448 */
449 HWTEST(AudioPolicyUnitTest, Audio_Policy_SetMicStateChangeCallback_001, TestSize.Level1)
450 {
451 std::shared_ptr<AudioPolicyProxy> audioPolicyProxy;
452 AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy);
453 ASSERT_NE(nullptr, audioPolicyProxy);
454
455 int32_t clientId = getpid();
456 sptr<IRemoteObject> object;
457 AudioPolicyUnitTest::GetIRemoteObject(object);
458 int32_t ret = audioPolicyProxy->SetMicStateChangeCallback(clientId, object);
459 EXPECT_EQ(true, ret <= 0);
460 }
461
462 /**
463 * @tc.name : Test Audio_Policy_SetMicStateChangeCallback_002 via illegal state
464 * @tc.number: Audio_Policy_SetMicStateChangeCallback_002
465 * @tc.desc : Test SetMicStateChangeCallback interface. Returns invalid.
466 */
467 HWTEST(AudioPolicyUnitTest, Audio_Policy_SetMicStateChangeCallback_002, TestSize.Level1)
468 {
469 std::shared_ptr<AudioPolicyProxy> audioPolicyProxy;
470 AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy);
471 ASSERT_NE(nullptr, audioPolicyProxy);
472
473 int32_t clientId = getpid();
474 sptr<IRemoteObject> object = nullptr;
475 int32_t ret = audioPolicyProxy->SetMicStateChangeCallback(clientId, object);
476 EXPECT_EQ(ERR_NULL_OBJECT, ret);
477 }
478
479 /**
480 * @tc.name : Test Audio_Policy_SetAudioInterruptCallback_001 via illegal state
481 * @tc.number: Audio_Policy_SetAudioInterruptCallback_001
482 * @tc.desc : Test SetAudioInterruptCallback interface. Returns invalid.
483 */
484 HWTEST(AudioPolicyUnitTest, Audio_Policy_SetAudioInterruptCallback_001, TestSize.Level1)
485 {
486 std::shared_ptr<AudioPolicyProxy> audioPolicyProxy;
487 AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy);
488 ASSERT_NE(nullptr, audioPolicyProxy);
489
490 AudioInterrupt audioInterrupt;
491 audioInterrupt.contentType = CONTENT_TYPE_RINGTONE;
492 audioInterrupt.streamUsage = STREAM_USAGE_NOTIFICATION_RINGTONE;
493 audioInterrupt.streamType = STREAM_ACCESSIBILITY;
494
495 std::shared_ptr<AudioStream> audioStream;
496 AudioPolicyUnitTest::InitAudioStream(audioStream);
497 ASSERT_NE(nullptr, audioStream);
498
499 uint32_t sessionID_ = AudioPolicyUnitTest::GetSessionId(audioStream);
500 sptr<IRemoteObject> object = nullptr;
501 int32_t ret = audioPolicyProxy->SetAudioInterruptCallback(sessionID_, object);
502 EXPECT_EQ(ERR_NULL_OBJECT, ret);
503 }
504
505 /**
506 * @tc.name : Test Audio_Policy_SetAudioManagerInterruptCallback_001 via illegal state
507 * @tc.number: Audio_Policy_SetAudioManagerInterruptCallback_001
508 * @tc.desc : Test SetAudioManagerInterruptCallback interface. Returns invalid.
509 */
510 HWTEST(AudioPolicyUnitTest, Audio_Policy_SetAudioManagerInterruptCallback_001, TestSize.Level1)
511 {
512 std::shared_ptr<AudioPolicyProxy> audioPolicyProxy;
513 AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy);
514 ASSERT_NE(nullptr, audioPolicyProxy);
515
516 int32_t clientId = getpid();
517 sptr<IRemoteObject> object = nullptr;
518 int32_t ret = audioPolicyProxy->SetAudioManagerInterruptCallback(clientId, object);
519 EXPECT_EQ(ERR_NULL_OBJECT, ret);
520 }
521
522 /**
523 * @tc.name : Test Audio_Policy_RegisterTracker_001 via illegal state
524 * @tc.number: Audio_Policy_RegisterTracker_001
525 * @tc.desc : Test RegisterTracker interface. Returns invalid.
526 */
527 HWTEST(AudioPolicyUnitTest, Audio_Policy_RegisterTracker_001, TestSize.Level1)
528 {
529 std::shared_ptr<AudioPolicyProxy> audioPolicyProxy;
530 AudioPolicyUnitTest::InitAudioPolicyProxy(audioPolicyProxy);
531 ASSERT_NE(nullptr, audioPolicyProxy);
532
533 AudioMode mode = AudioMode::AUDIO_MODE_PLAYBACK;
534 AudioStreamChangeInfo streamChangeInfo;
535 sptr<IRemoteObject> object = nullptr;
536 int32_t ret = audioPolicyProxy->RegisterTracker(mode, streamChangeInfo, object);
537 EXPECT_EQ(ERR_NULL_OBJECT, ret);
538 }
539
540 /**
541 * @tc.name : Test Audio_Policy_Manager_SetRingerModeCallback_001 via illegal state
542 * @tc.number: Audio_Policy_Manager_SetRingerModeCallback_001
543 * @tc.desc : Test SetRingerModeCallback interface. Returns invalid.
544 */
545 HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_SetRingerModeCallback_001, TestSize.Level1)
546 {
547 int32_t clientId = getpid();
548 std::shared_ptr<AudioRingerModeCallback> callback = nullptr;
549 int32_t ret = AudioPolicyManager::GetInstance().SetRingerModeCallback(clientId, callback);
550 EXPECT_EQ(ERR_INVALID_PARAM, ret);
551 }
552
553 /**
554 * @tc.name : Test Audio_Policy_Manager_SetDeviceChangeCallback_002 via illegal state
555 * @tc.number: Audio_Policy_Manager_SetDeviceChangeCallback_002
556 * @tc.desc : Test SetDeviceChangeCallback interface. Returns invalid.
557 */
558 HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_SetDeviceChangeCallback_002, TestSize.Level1)
559 {
560 int32_t clientId = getpid();
561 DeviceFlag flag = DeviceFlag::INPUT_DEVICES_FLAG;
562 std::shared_ptr<AudioManagerDeviceChangeCallback> callback = nullptr;
563 int32_t ret = AudioPolicyManager::GetInstance().SetDeviceChangeCallback(clientId, flag, callback);
564 EXPECT_EQ(ERR_INVALID_PARAM, ret);
565 }
566
567 /**
568 * @tc.name : Test Audio_Policy_Manager_SetAudioInterruptCallback_001 via illegal state
569 * @tc.number: Audio_Policy_Manager_SetAudioInterruptCallback_001
570 * @tc.desc : Test SetAudioInterruptCallback interface. Returns invalid.
571 */
572 HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_SetAudioInterruptCallback_001, TestSize.Level1)
573 {
574 AudioInterrupt audioInterrupt;
575 audioInterrupt.contentType = CONTENT_TYPE_RINGTONE;
576 audioInterrupt.streamUsage = STREAM_USAGE_NOTIFICATION_RINGTONE;
577 audioInterrupt.streamType = STREAM_ACCESSIBILITY;
578
579 std::shared_ptr<AudioStream> audioStream;
580 AudioPolicyUnitTest::InitAudioStream(audioStream);
581 ASSERT_NE(nullptr, audioStream);
582
583 uint32_t sessionID_ = AudioPolicyUnitTest::GetSessionId(audioStream);
584 std::shared_ptr<AudioInterruptCallback> callback = nullptr;
585 int32_t ret = AudioPolicyManager::GetInstance().SetAudioInterruptCallback(sessionID_, callback);
586 EXPECT_EQ(ERR_INVALID_PARAM, ret);
587 }
588
589 /**
590 * @tc.name : Test Audio_Policy_Manager_SetAudioManagerInterruptCallback_001 via illegal state
591 * @tc.number: Audio_Policy_Manager_SetAudioManagerInterruptCallback_001
592 * @tc.desc : Test SetAudioManagerInterruptCallback interface. Returns invalid.
593 */
594 HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_SetAudioManagerInterruptCallback_001, TestSize.Level1)
595 {
596 int32_t clientId = getpid();
597 std::shared_ptr<AudioInterruptCallback> callback = nullptr;
598 int32_t ret = AudioPolicyManager::GetInstance().SetAudioManagerInterruptCallback(clientId, callback);
599 EXPECT_EQ(ERR_INVALID_PARAM, ret);
600 }
601
602 /**
603 * @tc.name : Test Audio_Policy_Manager_SetVolumeKeyEventCallback_001 via illegal state
604 * @tc.number: Audio_Policy_Manager_SetVolumeKeyEventCallback_001
605 * @tc.desc : Test SetVolumeKeyEventCallback interface. Returns invalid.
606 */
607 HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_SetVolumeKeyEventCallback_001, TestSize.Level1)
608 {
609 int32_t clientPid = getpid();
610 std::shared_ptr<VolumeKeyEventCallback> callback = nullptr;
611 int32_t ret = AudioPolicyManager::GetInstance().SetVolumeKeyEventCallback(clientPid, callback);
612 EXPECT_EQ(ERR_INVALID_PARAM, ret);
613 }
614
615 /**
616 * @tc.name : Test Audio_Policy_Manager_RegisterAudioRendererEventListener_002 via illegal state
617 * @tc.number: Audio_Policy_Manager_RegisterAudioRendererEventListener_002
618 * @tc.desc : Test RegisterAudioRendererEventListener interface. Returns invalid.
619 */
620 HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_RegisterAudioRendererEventListener_002, TestSize.Level1)
621 {
622 int32_t clientUID = getpid();
623 std::shared_ptr<AudioRendererStateChangeCallback> callback = nullptr;
624 int32_t ret = AudioPolicyManager::GetInstance().RegisterAudioRendererEventListener(clientUID, callback);
625 EXPECT_EQ(ERR_INVALID_PARAM, ret);
626 }
627
628 /**
629 * @tc.name : Test Audio_Policy_Manager_GetCurrentCapturerChangeInfos_001 via illegal state
630 * @tc.number: Audio_Policy_Manager_GetCurrentCapturerChangeInfos_001
631 * @tc.desc : Test GetCurrentCapturerChangeInfos interface. Returns invalid.
632 */
633 HWTEST(AudioPolicyUnitTest, Audio_Policy_Manager_GetCurrentCapturerChangeInfos_001, TestSize.Level1)
634 {
635 vector<unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
636 int32_t ret = AudioPolicyManager::GetInstance().GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
637 EXPECT_EQ(true, audioCapturerChangeInfos.size() <= 0);
638 EXPECT_EQ(SUCCESS, ret);
639 }
640
641 /**
642 * @tc.name : Test Audio_Capturer_State_Change_001 via legal state
643 * @tc.number: Audio_Capturer_State_Change_001
644 * @tc.desc : Test AudioCapturerStateChangeListenerStub interface. Returns invalid.
645 */
646 HWTEST(AudioPolicyUnitTest, Audio_Capturer_State_Change_001, TestSize.Level1)
647 {
648 std::shared_ptr<AudioCapturerStateChangeListenerStub> capturerStub =
649 std::make_shared<AudioCapturerStateChangeListenerStub>();
650
651 vector<unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
652 capturerStub->OnCapturerStateChange(audioCapturerChangeInfos);
653
654 weak_ptr<AudioCapturerStateChangeCallbackTest> callback =
655 std::make_shared<AudioCapturerStateChangeCallbackTest>();
656 capturerStub->SetCallback(callback);
657
658 uint32_t code = capturerStub->ON_CAPTURERSTATE_CHANGE;
659 MessageParcel data;
660 MessageParcel reply;
661 MessageOption option;
662 int ret = capturerStub->OnRemoteRequest(code, data, reply, option);
663 EXPECT_EQ(true, ret <= 0);
664
665 code = capturerStub->ON_ERROR;
666 capturerStub->OnRemoteRequest(code, data, reply, option);
667 }
668
669 /**
670 * @tc.name : Test Audio_Renderer_State_Change_001 via legal state
671 * @tc.number: Audio_Renderer_State_Change_001
672 * @tc.desc : Test AudioRendererStateChangeListenerStub interface. Returns success.
673 */
674 HWTEST(AudioPolicyUnitTest, Audio_Renderer_State_Change_001, TestSize.Level1)
675 {
676 std::shared_ptr<AudioRendererStateChangeListenerStub> rendererStub =
677 std::make_shared<AudioRendererStateChangeListenerStub>();
678
679 vector<unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
680 rendererStub->OnRendererStateChange(audioRendererChangeInfos);
681
682 weak_ptr<AudioRendererStateChangeCallbackTest> callback =
683 std::make_shared<AudioRendererStateChangeCallbackTest>();
684 rendererStub->SetCallback(callback);
685
686 uint32_t code = rendererStub->ON_RENDERERSTATE_CHANGE;
687 MessageParcel data;
688 MessageParcel reply;
689 MessageOption option;
690 int ret = rendererStub->OnRemoteRequest(code, data, reply, option);
691 EXPECT_EQ(true, ret <= 0);
692
693 code = rendererStub->ON_ERROR;
694 rendererStub->OnRemoteRequest(code, data, reply, option);
695 }
696
697 /**
698 * @tc.name : Test Audio_Ringermode_Update_Listener_001 via legal state
699 * @tc.number: Audio_Ringermode_Update_Listener_001
700 * @tc.desc : Test AudioRingerModeUpdateListenerStub interface. Returns success.
701 */
702 HWTEST(AudioPolicyUnitTest, Audio_Ringermode_Update_Listener_001, TestSize.Level1)
703 {
704 std::shared_ptr<AudioRingerModeUpdateListenerStub> ringermodeStub =
705 std::make_shared<AudioRingerModeUpdateListenerStub>();
706 std::weak_ptr<AudioRingerModeCallbackTest> callback = std::make_shared<AudioRingerModeCallbackTest>();
707 AudioRingerMode ringerMode = AudioRingerMode::RINGER_MODE_SILENT;
708
709 ringermodeStub->OnRingerModeUpdated(ringerMode);
710
711 ringermodeStub->SetCallback(callback);
712
713 ringermodeStub->OnRingerModeUpdated(ringerMode);
714
715 uint32_t code = ringermodeStub->ON_RINGERMODE_UPDATE;
716 MessageParcel data;
717 MessageParcel reply;
718 MessageOption option;
719 int ret = ringermodeStub->OnRemoteRequest(code, data, reply, option);
720
721 code = ringermodeStub->ON_ERROR;
722 ret = ringermodeStub->OnRemoteRequest(code, data, reply, option);
723 EXPECT_EQ(true, ret <= 0);
724 }
725
726 /**
727 * @tc.name : Test Audio_Rounting_Manager_Listener_001 via legal state
728 * @tc.number: Audio_Rounting_Manager_Listener_001
729 * @tc.desc : Test AudioRoutingManagerListenerStub interface. Returns success.
730 */
731 HWTEST(AudioPolicyUnitTest, Audio_Rounting_Manager_Listener_001, TestSize.Level1)
732 {
733 std::shared_ptr<AudioRoutingManagerListenerStub> routingManagerStub =
734 std::make_shared<AudioRoutingManagerListenerStub>();
735 std::weak_ptr<AudioManagerMicStateChangeCallbackTest> callback =
736 std::make_shared<AudioManagerMicStateChangeCallbackTest>();
737 MicStateChangeEvent micStateChangeEvent;
738 micStateChangeEvent.mute = true;
739
740 routingManagerStub->OnMicStateUpdated(micStateChangeEvent);
741
742 routingManagerStub->SetMicStateChangeCallback(callback);
743
744 routingManagerStub->OnMicStateUpdated(micStateChangeEvent);
745
746 uint32_t code = routingManagerStub->ON_MIC_STATE_UPDATED;
747 MessageParcel data;
748 MessageParcel reply;
749 MessageOption option;
750 int ret = routingManagerStub->OnRemoteRequest(code, data, reply, option);
751
752 code = routingManagerStub->ON_ERROR;
753 ret = routingManagerStub->OnRemoteRequest(code, data, reply, option);
754 EXPECT_EQ(true, ret <= 0);
755 }
756
757 /**
758 * @tc.name : Test Audio_Volume_Group_Info_001 via legal state
759 * @tc.number: Audio_Volume_Group_Info_001
760 * @tc.desc : Test VolumeGroupInfo interface. Returns success.
761 */
762 HWTEST(AudioPolicyUnitTest, Audio_Volume_Group_Info_001, TestSize.Level1)
763 {
764 int32_t volumeGroupId = 1;
765 int32_t mappingId = 1;
766 std::string groupName = "TEST_UNIT";
767 std::string networkId = "UNIT";
768 ConnectType type = ConnectType::CONNECT_TYPE_LOCAL;
769
770 std::shared_ptr<VolumeGroupInfo> volumeGroupInfo =
771 std::make_shared<VolumeGroupInfo>(volumeGroupId, mappingId, groupName, networkId, type);
772
773 Parcel parcel;
774 bool ret = volumeGroupInfo->Marshalling(parcel);
775 EXPECT_EQ(true, ret);
776 }
777
778 /**
779 * @tc.name : Test Audio_Client_Tracker_Callback_Stub_001 via legal state
780 * @tc.number: Audio_Client_Tracker_Callback_Stub_001
781 * @tc.desc : Test AudioClientTrackerCallbackStub interface. Returns success.
782 */
783 HWTEST(AudioPolicyUnitTest, Audio_Client_Tracker_Callback_Stub_001, TestSize.Level1)
784 {
785 std::shared_ptr<AudioClientTrackerCallbackStub> audioClientTrackerCallbackStub =
786 std::make_shared<AudioClientTrackerCallbackStub>();
787
788 StreamSetStateEventInternal streamSetStateEventInternal = {};
789 streamSetStateEventInternal.audioStreamType = AudioStreamType::STREAM_MUSIC;
790 std::weak_ptr<AudioClientTrackerTest> callback = std::make_shared<AudioClientTrackerTest>();
791
792 float volume = 0.5;
793 audioClientTrackerCallbackStub->SetLowPowerVolumeImpl(volume);
794 audioClientTrackerCallbackStub->GetLowPowerVolumeImpl(volume);
795 audioClientTrackerCallbackStub->GetSingleStreamVolumeImpl(volume);
796
797 streamSetStateEventInternal.streamSetState= StreamSetState::STREAM_RESUME;
798 audioClientTrackerCallbackStub->ResumeStreamImpl(streamSetStateEventInternal);
799
800 streamSetStateEventInternal.streamSetState= StreamSetState::STREAM_PAUSE;
801 audioClientTrackerCallbackStub->PausedStreamImpl(streamSetStateEventInternal);
802
803 audioClientTrackerCallbackStub->SetClientTrackerCallback(callback);
804
805 streamSetStateEventInternal.streamSetState= StreamSetState::STREAM_RESUME;
806 audioClientTrackerCallbackStub->ResumeStreamImpl(streamSetStateEventInternal);
807
808 streamSetStateEventInternal.streamSetState= StreamSetState::STREAM_PAUSE;
809 audioClientTrackerCallbackStub->PausedStreamImpl(streamSetStateEventInternal);
810 }
811 } // namespace AudioStandard
812 } // namespace OHOS