1 /*
2 * Copyright (c) 2021-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 "audio_manager_unit_test.h"
17
18 #include "audio_errors.h"
19 #include "audio_info.h"
20 #include "audio_renderer.h"
21 #include "audio_capturer.h"
22 #include "audio_stream_manager.h"
23
24 using namespace std;
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace AudioStandard {
29 namespace {
30 constexpr uint32_t MIN_DEVICE_COUNT = 2;
31 constexpr uint32_t MIN_DEVICE_ID = 1;
32 constexpr uint32_t MIN_DEVICE_NUM = 1;
33 constexpr uint32_t CONTENT_TYPE_UPPER_INVALID = 6;
34 constexpr uint32_t STREAM_USAGE_UPPER_INVALID = 7;
35 constexpr uint32_t STREAM_TYPE_UPPER_INVALID = 100;
36 constexpr uint32_t CONTENT_TYPE_LOWER_INVALID = -1;
37 constexpr uint32_t STREAM_USAGE_LOWER_INVALID = -1;
38 constexpr uint32_t STREAM_TYPE_LOWER_INVALID = -1;
39 constexpr int32_t MAX_VOL = 15;
40 constexpr int32_t MIN_VOL = 0;
41 constexpr int32_t INV_CHANNEL = -1;
42 constexpr int32_t CHANNEL_10 = 10;
43 constexpr float DISCOUNT_VOLUME = 0.5;
44 constexpr float INVALID_VOLUME = -1.0;
45 constexpr float VOLUME_MIN = 0;
46 constexpr float VOLUME_MAX = 1.0;
47 constexpr int32_t CAPTURER_FLAG = 0;
48 }
49
SetUpTestCase(void)50 void AudioManagerUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)51 void AudioManagerUnitTest::TearDownTestCase(void) {}
SetUp(void)52 void AudioManagerUnitTest::SetUp(void) {}
TearDown(void)53 void AudioManagerUnitTest::TearDown(void) {}
54
55 /**
56 * @tc.name : Test GetDevices API
57 * @tc.number: GetConnectedDevicesList_001
58 * @tc.desc : Test GetDevices interface. Returns list of all input and output devices
59 */
60 HWTEST(AudioManagerUnitTest, GetConnectedDevicesList_001, TestSize.Level1)
61 {
62 auto audioDeviceDescriptors = AudioSystemManager::GetInstance()->GetDevices(DeviceFlag::ALL_DEVICES_FLAG);
63 auto deviceCount = audioDeviceDescriptors.size();
64 EXPECT_GE(deviceCount, MIN_DEVICE_COUNT);
65 }
66
67 /**
68 * @tc.name : Test GetDevices API
69 * @tc.number: GetConnectedDevicesList_002
70 * @tc.desc : Test GetDevices interface. Returns list of input devices
71 */
72 HWTEST(AudioManagerUnitTest, GetConnectedDevicesList_002, TestSize.Level1)
73 {
74 auto audioDeviceDescriptors = AudioSystemManager::GetInstance()->GetDevices(DeviceFlag::INPUT_DEVICES_FLAG);
75 auto inputDevice = audioDeviceDescriptors[0];
76
77 EXPECT_EQ(inputDevice->deviceRole_, DeviceRole::INPUT_DEVICE);
78 EXPECT_EQ(inputDevice->deviceType_, DeviceType::DEVICE_TYPE_MIC);
79 EXPECT_GE(inputDevice->deviceId_, MIN_DEVICE_ID);
80 EXPECT_EQ(true, (inputDevice->audioStreamInfo_.samplingRate >= SAMPLE_RATE_8000)
81 || ((inputDevice->audioStreamInfo_.samplingRate <= SAMPLE_RATE_96000)));
82 EXPECT_EQ(inputDevice->audioStreamInfo_.encoding, AudioEncodingType::ENCODING_PCM);
83 EXPECT_EQ(true, (inputDevice->audioStreamInfo_.channels >= MONO)
84 && ((inputDevice->audioStreamInfo_.channels <= CHANNEL_8)));
85 EXPECT_EQ(true, (inputDevice->audioStreamInfo_.format >= SAMPLE_U8)
86 && ((inputDevice->audioStreamInfo_.format <= SAMPLE_F32LE)));
87 }
88
89 /**
90 * @tc.name : Test GetDevices API
91 * @tc.number: GetConnectedDevicesList_003
92 * @tc.desc : Test GetDevices interface. Returns list of output devices
93 */
94 HWTEST(AudioManagerUnitTest, GetConnectedDevicesList_003, TestSize.Level1)
95 {
96 auto audioDeviceDescriptors = AudioSystemManager::GetInstance()->GetDevices(DeviceFlag::OUTPUT_DEVICES_FLAG);
97 auto outputDevice = audioDeviceDescriptors[0];
98
99 EXPECT_EQ(outputDevice->deviceRole_, DeviceRole::OUTPUT_DEVICE);
100 EXPECT_EQ(outputDevice->deviceType_, DeviceType::DEVICE_TYPE_SPEAKER);
101 EXPECT_GE(outputDevice->deviceId_, MIN_DEVICE_ID);
102 EXPECT_EQ(true, (outputDevice->audioStreamInfo_.samplingRate >= SAMPLE_RATE_8000)
103 && ((outputDevice->audioStreamInfo_.samplingRate <= SAMPLE_RATE_96000)));
104 EXPECT_EQ(outputDevice->audioStreamInfo_.encoding, AudioEncodingType::ENCODING_PCM);
105 EXPECT_EQ(true, (outputDevice->audioStreamInfo_.channels >= MONO)
106 && ((outputDevice->audioStreamInfo_.channels <= CHANNEL_8)));
107 EXPECT_EQ(true, (outputDevice->audioStreamInfo_.format >= SAMPLE_U8)
108 && ((outputDevice->audioStreamInfo_.format <= SAMPLE_F32LE)));
109 }
110
111 /**
112 * @tc.name : Test SelectOutputDevice API
113 * @tc.number: SelectOutputDevice_001
114 * @tc.desc : Test SelectOutputDevice interface.
115 * @tc.require: issueI5NZAQ
116 */
117 HWTEST(AudioManagerUnitTest, SelectOutputDevice_001, TestSize.Level1)
118 {
119 vector<sptr<AudioDeviceDescriptor>> deviceDescriptorVector;
120
121 auto audioDeviceDescriptors = AudioSystemManager::GetInstance()->GetDevices(DeviceFlag::OUTPUT_DEVICES_FLAG);
122 auto outputDevice = audioDeviceDescriptors[0];
123 outputDevice->deviceRole_ = DeviceRole::OUTPUT_DEVICE;
124 outputDevice->networkId_ = LOCAL_NETWORK_ID;
125 deviceDescriptorVector.push_back(outputDevice);
126 auto ret = AudioSystemManager::GetInstance()->SelectOutputDevice(deviceDescriptorVector);
127 EXPECT_EQ(SUCCESS, ret);
128 }
129
130 /**
131 * @tc.name : Test SelectOutputDevice API
132 * @tc.number: SelectOutputDevice_002
133 * @tc.desc : Test SelectOutputDevice interface.
134 * @tc.require: issueI5NZAQ
135 */
136 HWTEST(AudioManagerUnitTest, SelectOutputDevice_002, TestSize.Level1)
137 {
138 vector<sptr<AudioDeviceDescriptor>> deviceDescriptorVector;
139
140 auto audioDeviceDescriptors = AudioSystemManager::GetInstance()->GetDevices(DeviceFlag::OUTPUT_DEVICES_FLAG);
141 auto outputDevice = audioDeviceDescriptors[0];
142 outputDevice->deviceRole_ = DeviceRole::OUTPUT_DEVICE;
143 outputDevice->networkId_ = std::string("");
144 deviceDescriptorVector.push_back(outputDevice);
145 auto ret = AudioSystemManager::GetInstance()->SelectOutputDevice(deviceDescriptorVector);
146 EXPECT_TRUE(ret < 0);
147 }
148
149 /**
150 * @tc.name : Test SelectOutputDevice API
151 * @tc.number: SelectOutputDevice_003
152 * @tc.desc : Test SelectOutputDevice interface.
153 * @tc.require: issueI5NZAQ
154 */
155 HWTEST(AudioManagerUnitTest, SelectOutputDevice_003, TestSize.Level1)
156 {
157 sptr<AudioRendererFilter> audioRendererFilter = new(std::nothrow) AudioRendererFilter();
158 audioRendererFilter->uid = 20010041;
159 audioRendererFilter->rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
160 audioRendererFilter->rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
161 audioRendererFilter->rendererInfo.rendererFlags = 0;
162 audioRendererFilter->streamId = 0;
163
164 vector<sptr<AudioDeviceDescriptor>> deviceDescriptorVector;
165
166 auto audioDeviceDescriptors = AudioSystemManager::GetInstance()->GetDevices(DeviceFlag::OUTPUT_DEVICES_FLAG);
167 auto outputDevice = audioDeviceDescriptors[0];
168 outputDevice->deviceRole_ = DeviceRole::OUTPUT_DEVICE;
169 outputDevice->networkId_ = LOCAL_NETWORK_ID;
170 deviceDescriptorVector.push_back(outputDevice);
171 auto ret = AudioSystemManager::GetInstance()->SelectOutputDevice(audioRendererFilter, deviceDescriptorVector);
172 EXPECT_EQ(SUCCESS, ret);
173 }
174
175 /**
176 * @tc.name : Test SelectOutputDevice API
177 * @tc.number: SelectOutputDevice_004
178 * @tc.desc : Test SelectOutputDevice interface.
179 * @tc.require: issueI5NZAQ
180 */
181 HWTEST(AudioManagerUnitTest, SelectOutputDevice_004, TestSize.Level1)
182 {
183 sptr<AudioRendererFilter> audioRendererFilter = new(std::nothrow) AudioRendererFilter();
184 audioRendererFilter->uid = -1;
185 audioRendererFilter->rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
186 audioRendererFilter->rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
187 audioRendererFilter->rendererInfo.rendererFlags = 0;
188 audioRendererFilter->streamId = 0;
189
190 vector<sptr<AudioDeviceDescriptor>> deviceDescriptorVector;
191
192 auto audioDeviceDescriptors = AudioSystemManager::GetInstance()->GetDevices(DeviceFlag::OUTPUT_DEVICES_FLAG);
193 auto outputDevice = audioDeviceDescriptors[0];
194 outputDevice->deviceRole_ = DeviceRole::OUTPUT_DEVICE;
195 outputDevice->networkId_ = LOCAL_NETWORK_ID;
196 deviceDescriptorVector.push_back(outputDevice);
197 auto ret = AudioSystemManager::GetInstance()->SelectOutputDevice(audioRendererFilter, deviceDescriptorVector);
198 EXPECT_LT(ret, SUCCESS);
199 }
200
201 /**
202 * @tc.name : Test SelectOutputDevice API
203 * @tc.number: SelectOutputDevice_005
204 * @tc.desc : Test SelectOutputDevice interface, set deviceDescriptorVector.size() to zero.
205 * @tc.require: issueI5NZAQ
206 */
207 HWTEST(AudioManagerUnitTest, SelectOutputDevice_005, TestSize.Level1)
208 {
209 vector<sptr<AudioDeviceDescriptor>> deviceDescriptorVector;
210 auto ret = AudioSystemManager::GetInstance()->SelectOutputDevice(deviceDescriptorVector);
211 EXPECT_LT(ret, SUCCESS);
212 }
213
214 /**
215 * @tc.name : Test SelectOutputDevice API
216 * @tc.number: SelectOutputDevice_006
217 * @tc.desc : Test SelectOutputDevice interface, set networkId_ to "".
218 * @tc.require: issueI5NZAQ
219 */
220 HWTEST(AudioManagerUnitTest, SelectOutputDevice_006, TestSize.Level1)
221 {
222 vector<sptr<AudioDeviceDescriptor>> deviceDescriptorVector;
223
224 auto audioDeviceDescriptors = AudioSystemManager::GetInstance()->GetDevices(DeviceFlag::OUTPUT_DEVICES_FLAG);
225 auto outputDevice = audioDeviceDescriptors[0];
226 outputDevice->deviceRole_ = DeviceRole::INPUT_DEVICE;
227 outputDevice->networkId_ = std::string("");
228 deviceDescriptorVector.push_back(outputDevice);
229 auto ret = AudioSystemManager::GetInstance()->SelectOutputDevice(deviceDescriptorVector);
230 EXPECT_LT(ret, SUCCESS);
231 }
232
233 /**
234 * @tc.name : Test SelectOutputDevice API
235 * @tc.number: SelectOutputDevice_007
236 * @tc.desc : Test SelectOutputDevice interface, set audioRendererFilter to nullptr.
237 * @tc.require: issueI5NZAQ
238 */
239 HWTEST(AudioManagerUnitTest, SelectOutputDevice_007, TestSize.Level1)
240 {
241 sptr<AudioRendererFilter> audioRendererFilter = nullptr;
242 vector<sptr<AudioDeviceDescriptor>> deviceDescriptorVector;
243
244 auto audioDeviceDescriptors = AudioSystemManager::GetInstance()->GetDevices(DeviceFlag::OUTPUT_DEVICES_FLAG);
245 auto outputDevice = audioDeviceDescriptors[0];
246 outputDevice->deviceRole_ = DeviceRole::OUTPUT_DEVICE;
247 outputDevice->networkId_ = LOCAL_NETWORK_ID;
248 deviceDescriptorVector.push_back(outputDevice);
249 auto ret = AudioSystemManager::GetInstance()->SelectOutputDevice(audioRendererFilter, deviceDescriptorVector);
250 EXPECT_LT(ret, SUCCESS);
251 }
252
253 /**
254 * @tc.name : Test SelectOutputDevice API
255 * @tc.number: SelectOutputDevice_008
256 * @tc.desc : Test SelectOutputDevice interface, set audioDeviceDescriptors[0] to nullptr.
257 * @tc.require: issueI5NZAQ
258 */
259 HWTEST(AudioManagerUnitTest, SelectOutputDevice_008, TestSize.Level1)
260 {
261 sptr<AudioRendererFilter> audioRendererFilter = new(std::nothrow) AudioRendererFilter();
262 audioRendererFilter->uid = 20010041;
263 audioRendererFilter->rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
264 audioRendererFilter->rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
265 audioRendererFilter->rendererInfo.rendererFlags = 0;
266 audioRendererFilter->streamId = 0;
267
268 vector<sptr<AudioDeviceDescriptor>> deviceDescriptorVector;
269 deviceDescriptorVector.push_back(nullptr);
270 auto ret = AudioSystemManager::GetInstance()->SelectOutputDevice(audioRendererFilter, deviceDescriptorVector);
271 EXPECT_LT(ret, SUCCESS);
272 }
273
274 /**
275 * @tc.name : Test SelectOutputDevice API
276 * @tc.number: SelectOutputDevice_009
277 * @tc.desc : Test SelectOutputDevice interface, set deviceRole_ to INPUT_DEVICE.
278 * @tc.require: issueI5NZAQ
279 */
280 HWTEST(AudioManagerUnitTest, SelectOutputDevice_009, TestSize.Level1)
281 {
282 sptr<AudioRendererFilter> audioRendererFilter = new(std::nothrow) AudioRendererFilter();
283 audioRendererFilter->uid = 20010041;
284 audioRendererFilter->rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
285 audioRendererFilter->rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
286 audioRendererFilter->rendererInfo.rendererFlags = 0;
287 audioRendererFilter->streamId = 0;
288
289 vector<sptr<AudioDeviceDescriptor>> deviceDescriptorVector;
290 auto audioDeviceDescriptors = AudioSystemManager::GetInstance()->GetDevices(DeviceFlag::OUTPUT_DEVICES_FLAG);
291 auto outputDevice = audioDeviceDescriptors[0];
292 outputDevice->deviceRole_ = DeviceRole::INPUT_DEVICE;
293 outputDevice->networkId_ = LOCAL_NETWORK_ID;
294 deviceDescriptorVector.push_back(outputDevice);
295 auto ret = AudioSystemManager::GetInstance()->SelectOutputDevice(audioRendererFilter, deviceDescriptorVector);
296 EXPECT_LT(ret, SUCCESS);
297 }
298
299 /**
300 * @tc.name : Test SelectOutputDevice API
301 * @tc.number: SelectOutputDevice_010
302 * @tc.desc : Test SelectOutputDevice interface, set networkId_ to "".
303 * @tc.require: issueI5NZAQ
304 */
305 HWTEST(AudioManagerUnitTest, SelectOutputDevice_010, TestSize.Level1)
306 {
307 sptr<AudioRendererFilter> audioRendererFilter = new(std::nothrow) AudioRendererFilter();
308 audioRendererFilter->uid = 20010041;
309 audioRendererFilter->rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
310 audioRendererFilter->rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
311 audioRendererFilter->rendererInfo.rendererFlags = 0;
312 audioRendererFilter->streamId = 0;
313
314 vector<sptr<AudioDeviceDescriptor>> deviceDescriptorVector;
315 auto audioDeviceDescriptors = AudioSystemManager::GetInstance()->GetDevices(DeviceFlag::OUTPUT_DEVICES_FLAG);
316 auto outputDevice = audioDeviceDescriptors[0];
317 outputDevice->deviceRole_ = DeviceRole::OUTPUT_DEVICE;
318 outputDevice->networkId_ = "";
319 deviceDescriptorVector.push_back(outputDevice);
320 auto ret = AudioSystemManager::GetInstance()->SelectOutputDevice(audioRendererFilter, deviceDescriptorVector);
321 EXPECT_LT(ret, SUCCESS);
322 }
323
324 /**
325 * @tc.name : Test SelectInputDevice API
326 * @tc.number: SelectInputDevice_001
327 * @tc.desc : Test SelectInputDevice interface. deviceRole_ set to INPUT_DEVICE
328 */
329 HWTEST(AudioManagerUnitTest, SelectInputDevice_001, TestSize.Level1)
330 {
331 vector<sptr<AudioDeviceDescriptor>> deviceDescriptorVector;
332
333 auto audioDeviceDescriptors = AudioSystemManager::GetInstance()->GetDevices(DeviceFlag::INPUT_DEVICES_FLAG);
334 auto inputDevice = audioDeviceDescriptors[0];
335 inputDevice->deviceRole_ = DeviceRole::INPUT_DEVICE;
336 inputDevice->networkId_ = LOCAL_NETWORK_ID;
337 deviceDescriptorVector.push_back(inputDevice);
338 auto ret = AudioSystemManager::GetInstance()->SelectInputDevice(deviceDescriptorVector);
339 EXPECT_EQ(SUCCESS, ret);
340 }
341
342 /**
343 * @tc.name : Test SelectInputDevice API
344 * @tc.number: SelectInputDevice_002
345 * @tc.desc : Test SelectInputDevice interface. deviceRole_ set to OUTPUT_DEVICE
346 */
347 HWTEST(AudioManagerUnitTest, SelectInputDevice_002, TestSize.Level1)
348 {
349 vector<sptr<AudioDeviceDescriptor>> deviceDescriptorVector;
350
351 auto audioDeviceDescriptors = AudioSystemManager::GetInstance()->GetDevices(DeviceFlag::INPUT_DEVICES_FLAG);
352 auto inputDevice = audioDeviceDescriptors[0];
353 inputDevice->deviceRole_ = DeviceRole::OUTPUT_DEVICE;
354 inputDevice->networkId_ = LOCAL_NETWORK_ID;
355 deviceDescriptorVector.push_back(inputDevice);
356 auto ret = AudioSystemManager::GetInstance()->SelectInputDevice(deviceDescriptorVector);
357 EXPECT_LT(ret, SUCCESS);
358 }
359
360 /**
361 * @tc.name : Test SelectInputDevice API
362 * @tc.number: SelectInputDevice_003
363 * @tc.desc : Test SelectInputDevice interface. deviceDescriptorVector[0] set to nullptr
364 */
365 HWTEST(AudioManagerUnitTest, SelectInputDevice_003, TestSize.Level1)
366 {
367 vector<sptr<AudioDeviceDescriptor>> deviceDescriptorVector;
368 auto ret = AudioSystemManager::GetInstance()->SelectInputDevice(deviceDescriptorVector);
369 EXPECT_LT(ret, SUCCESS);
370 }
371
372 /**
373 * @tc.name : Test SelectInputDevice API
374 * @tc.number: SelectInputDevice_004
375 * @tc.desc : Test SelectInputDevice interface. normal
376 */
377 HWTEST(AudioManagerUnitTest, SelectInputDevice_004, TestSize.Level1)
378 {
379 sptr<AudioCapturerFilter> audioCapturerFilter = new(std::nothrow) AudioCapturerFilter();
380 audioCapturerFilter->uid = 20010041;
381
382 vector<sptr<AudioDeviceDescriptor>> deviceDescriptorVector;
383 auto audioDeviceDescriptors = AudioSystemManager::GetInstance()->GetDevices(DeviceFlag::INPUT_DEVICES_FLAG);
384 auto inputDevice = audioDeviceDescriptors[0];
385 inputDevice->deviceRole_ = DeviceRole::INPUT_DEVICE;
386 inputDevice->networkId_ = LOCAL_NETWORK_ID;
387 deviceDescriptorVector.push_back(inputDevice);
388 auto ret = AudioSystemManager::GetInstance()->SelectInputDevice(audioCapturerFilter, deviceDescriptorVector);
389 EXPECT_EQ(SUCCESS, ret);
390 }
391
392 /**
393 * @tc.name : Test SelectInputDevice API
394 * @tc.number: SelectInputDevice_005
395 * @tc.desc : Test SelectInputDevice interface. audioCapturerFilter set to nullptr
396 */
397 HWTEST(AudioManagerUnitTest, SelectInputDevice_005, TestSize.Level1)
398 {
399 sptr<AudioCapturerFilter> audioCapturerFilter = nullptr;
400
401 vector<sptr<AudioDeviceDescriptor>> deviceDescriptorVector;
402 auto audioDeviceDescriptors = AudioSystemManager::GetInstance()->GetDevices(DeviceFlag::INPUT_DEVICES_FLAG);
403 auto inputDevice = audioDeviceDescriptors[0];
404 inputDevice->deviceRole_ = DeviceRole::INPUT_DEVICE;
405 inputDevice->networkId_ = LOCAL_NETWORK_ID;
406 deviceDescriptorVector.push_back(inputDevice);
407 auto ret = AudioSystemManager::GetInstance()->SelectInputDevice(audioCapturerFilter, deviceDescriptorVector);
408 EXPECT_LT(ret, SUCCESS);
409 }
410
411 /**
412 * @tc.name : Test SelectInputDevice API
413 * @tc.number: SelectInputDevice_006
414 * @tc.desc : Test SelectInputDevice interface. deviceDescriptorVector.size() set to 0
415 */
416 HWTEST(AudioManagerUnitTest, SelectInputDevice_006, TestSize.Level1)
417 {
418 sptr<AudioCapturerFilter> audioCapturerFilter = new(std::nothrow) AudioCapturerFilter();
419 audioCapturerFilter->uid = 20010041;
420
421 vector<sptr<AudioDeviceDescriptor>> deviceDescriptorVector;
422 auto ret = AudioSystemManager::GetInstance()->SelectInputDevice(audioCapturerFilter, deviceDescriptorVector);
423 EXPECT_LT(ret, SUCCESS);
424 }
425
426 /**
427 * @tc.name : Test SelectInputDevice API
428 * @tc.number: SelectInputDevice_007
429 * @tc.desc : Test SelectInputDevice interface. deviceDescriptorVector[0] set to nullptr
430 */
431 HWTEST(AudioManagerUnitTest, SelectInputDevice_007, TestSize.Level1)
432 {
433 sptr<AudioCapturerFilter> audioCapturerFilter = new(std::nothrow) AudioCapturerFilter();
434 audioCapturerFilter->uid = 20010041;
435
436 vector<sptr<AudioDeviceDescriptor>> deviceDescriptorVector;
437 deviceDescriptorVector.push_back(nullptr);
438 auto ret = AudioSystemManager::GetInstance()->SelectInputDevice(audioCapturerFilter, deviceDescriptorVector);
439 EXPECT_LT(ret, SUCCESS);
440 }
441
442 /**
443 * @tc.name : Test SelectInputDevice API
444 * @tc.number: SelectInputDevice_008
445 * @tc.desc : Test SelectInputDevice interface. deviceDescriptorVector[0] set to nullptr
446 */
447 HWTEST(AudioManagerUnitTest, SelectInputDevice_008, TestSize.Level1)
448 {
449 sptr<AudioCapturerFilter> audioCapturerFilter = new(std::nothrow) AudioCapturerFilter();
450 audioCapturerFilter->uid = 20010041;
451
452 vector<sptr<AudioDeviceDescriptor>> deviceDescriptorVector;
453 deviceDescriptorVector.push_back(nullptr);
454 auto ret = AudioSystemManager::GetInstance()->SelectInputDevice(audioCapturerFilter, deviceDescriptorVector);
455 EXPECT_LT(ret, SUCCESS);
456 }
457
458 /**
459 * @tc.name : Test SelectInputDevice API
460 * @tc.number: SelectInputDevice_009
461 * @tc.desc : Test SelectInputDevice interface. deviceRole_ set to DeviceRole::OUTPUT_DEVICE
462 */
463 HWTEST(AudioManagerUnitTest, SelectInputDevice_009, TestSize.Level1)
464 {
465 sptr<AudioCapturerFilter> audioCapturerFilter = new(std::nothrow) AudioCapturerFilter();
466 audioCapturerFilter->uid = 20010041;
467
468 vector<sptr<AudioDeviceDescriptor>> deviceDescriptorVector;
469 auto audioDeviceDescriptors = AudioSystemManager::GetInstance()->GetDevices(DeviceFlag::INPUT_DEVICES_FLAG);
470 auto inputDevice = audioDeviceDescriptors[0];
471 inputDevice->deviceRole_ = DeviceRole::OUTPUT_DEVICE;
472 inputDevice->networkId_ = LOCAL_NETWORK_ID;
473 deviceDescriptorVector.push_back(inputDevice);
474 auto ret = AudioSystemManager::GetInstance()->SelectInputDevice(audioCapturerFilter, deviceDescriptorVector);
475 EXPECT_LT(ret, SUCCESS);
476 }
477
478 /**
479 * @tc.name : Test SelectInputDevice API
480 * @tc.number: SelectInputDevice_010
481 * @tc.desc : Test SelectInputDevice interface. uid set to -1
482 */
483 HWTEST(AudioManagerUnitTest, SelectInputDevice_010, TestSize.Level1)
484 {
485 sptr<AudioCapturerFilter> audioCapturerFilter = new(std::nothrow) AudioCapturerFilter();
486 audioCapturerFilter->uid = -1;
487
488 vector<sptr<AudioDeviceDescriptor>> deviceDescriptorVector;
489 auto audioDeviceDescriptors = AudioSystemManager::GetInstance()->GetDevices(DeviceFlag::INPUT_DEVICES_FLAG);
490 auto inputDevice = audioDeviceDescriptors[0];
491 inputDevice->deviceRole_ = DeviceRole::INPUT_DEVICE;
492 inputDevice->networkId_ = LOCAL_NETWORK_ID;
493 deviceDescriptorVector.push_back(inputDevice);
494 auto ret = AudioSystemManager::GetInstance()->SelectInputDevice(audioCapturerFilter, deviceDescriptorVector);
495 EXPECT_LT(ret, SUCCESS);
496 }
497
498 /**
499 * @tc.name : Test GetActiveOutputDeviceDescriptors API
500 * @tc.number: GetActiveOutputDeviceDescriptors_001
501 * @tc.desc : Test GetActiveOutputDeviceDescriptors interface.
502 */
503 HWTEST(AudioManagerUnitTest, GetActiveOutputDeviceDescriptors_001, TestSize.Level1)
504 {
505 auto audioDeviceDescriptors = AudioSystemManager::GetInstance()->GetActiveOutputDeviceDescriptors();
506 auto ret = audioDeviceDescriptors.size();
507 EXPECT_GE(ret, MIN_DEVICE_NUM);
508 }
509
510 /**
511 * @tc.name : Test RegisterVolumeKeyEventCallback API
512 * @tc.number: RegisterVolumeKeyEventCallback_001
513 * @tc.desc : Test RegisterVolumeKeyEventCallback interface.
514 */
515 HWTEST(AudioManagerUnitTest, RegisterVolumeKeyEventCallback_001, TestSize.Level1)
516 {
517 int32_t clientPid = 1;
518 std::shared_ptr<VolumeKeyEventCallback> callback = nullptr;
519 auto ret = AudioSystemManager::GetInstance()->RegisterVolumeKeyEventCallback(clientPid, callback);
520 EXPECT_LT(ret, SUCCESS);
521 }
522
523 /**
524 * @tc.name : Test SetAudioManagerCallback API
525 * @tc.number: SetAudioManagerCallback_001
526 * @tc.desc : Test SetAudioManagerCallback interface.
527 */
528 HWTEST(AudioManagerUnitTest, SetAudioManagerCallback_001, TestSize.Level1)
529 {
530 AudioVolumeType streamType = AudioVolumeType::STREAM_VOICE_CALL;
531 std::shared_ptr<AudioManagerCallback> callback;
532 auto ret = AudioSystemManager::GetInstance()->SetAudioManagerCallback(streamType, callback);
533 EXPECT_EQ(ret, SUCCESS);
534 }
535
536 /**
537 * @tc.name : Test UnsetAudioManagerCallback API
538 * @tc.number: UnsetAudioManagerCallback_001
539 * @tc.desc : Test UnsetAudioManagerCallback interface.
540 */
541 HWTEST(AudioManagerUnitTest, UnsetAudioManagerCallback_001, TestSize.Level1)
542 {
543 AudioVolumeType streamType = AudioVolumeType::STREAM_VOICE_CALL;
544 auto ret = AudioSystemManager::GetInstance()->UnsetAudioManagerCallback(streamType);
545 EXPECT_EQ(ret, SUCCESS);
546 }
547
548 /**
549 * @tc.name : Test ActivateAudioInterrupt API
550 * @tc.number: ActivateAudioInterrupt_001
551 * @tc.desc : Test ActivateAudioInterrupt interface.
552 */
553 HWTEST(AudioManagerUnitTest, ActivateAudioInterrupt_001, TestSize.Level1)
554 {
555 AudioInterrupt audioInterrupt;
556 audioInterrupt.contentType = CONTENT_TYPE_RINGTONE;
557 audioInterrupt.streamUsage = STREAM_USAGE_NOTIFICATION_RINGTONE;
558 audioInterrupt.streamType = STREAM_ACCESSIBILITY;
559 auto ret = AudioSystemManager::GetInstance()->ActivateAudioInterrupt(audioInterrupt);
560 EXPECT_EQ(ret, SUCCESS);
561 }
562
563 /**
564 * @tc.name : Test DeactivateAudioInterrupt API
565 * @tc.number: DeactivateAudioInterrupt_001
566 * @tc.desc : Test DeactivateAudioInterrupt interface.
567 */
568 HWTEST(AudioManagerUnitTest, DeactivateAudioInterrupt_001, TestSize.Level1)
569 {
570 AudioInterrupt audioInterrupt;
571 audioInterrupt.contentType = CONTENT_TYPE_RINGTONE;
572 audioInterrupt.streamUsage = STREAM_USAGE_NOTIFICATION_RINGTONE;
573 audioInterrupt.streamType = STREAM_ACCESSIBILITY;
574 auto ret = AudioSystemManager::GetInstance()->DeactivateAudioInterrupt(audioInterrupt);
575 EXPECT_EQ(ret, SUCCESS);
576 }
577
578 /**
579 * @tc.name : Test RequestIndependentInterrupt API
580 * @tc.number: RequestIndependentInterrupt_001
581 * @tc.desc : Test RequestIndependentInterrupt interface.
582 */
583 HWTEST(AudioManagerUnitTest, RequestIndependentInterrupt_001, TestSize.Level1)
584 {
585 FocusType FocusType = FocusType::FOCUS_TYPE_RECORDING;
586 auto ret = AudioSystemManager::GetInstance()->RequestIndependentInterrupt(FocusType);
587 EXPECT_TRUE(ret);
588 }
589
590 /**
591 * @tc.name : Test AbandonIndependentInterrupt API
592 * @tc.number: AbandonIndependentInterrupt_001
593 * @tc.desc : Test AbandonIndependentInterrupt interface.
594 */
595 HWTEST(AudioManagerUnitTest, AbandonIndependentInterrupt_001, TestSize.Level1)
596 {
597 FocusType FocusType = FocusType::FOCUS_TYPE_RECORDING;
598 auto ret = AudioSystemManager::GetInstance()->AbandonIndependentInterrupt(FocusType);
599 EXPECT_TRUE(ret);
600 }
601
602 /**
603 * @tc.name : Test GetPinValueFromType API
604 * @tc.number: GetPinValueFromType_001
605 * @tc.desc : Test GetPinValueFromType interface. deviceType set to DEVICE_TYPE_NONE,
606 * deviceRole set to DEVICE_ROLE_NONE
607 */
608 HWTEST(AudioManagerUnitTest, GetPinValueFromType_001, TestSize.Level1)
609 {
610 DeviceType deviceType = DeviceType::DEVICE_TYPE_NONE;
611 DeviceRole deviceRole = DeviceRole::DEVICE_ROLE_NONE;
612 AudioPin ret = AudioSystemManager::GetInstance()->GetPinValueFromType(deviceType, deviceRole);
613 EXPECT_EQ(ret, AudioPin::AUDIO_PIN_NONE);
614 }
615
616 /**
617 * @tc.name : Test GetPinValueFromType API
618 * @tc.number: GetPinValueFromType_002
619 * @tc.desc : Test GetPinValueFromType interface. deviceType set to DEVICE_TYPE_INVALID,
620 * deviceRole set to DEVICE_ROLE_NONE
621 */
622 HWTEST(AudioManagerUnitTest, GetPinValueFromType_002, TestSize.Level1)
623 {
624 DeviceType deviceType = DeviceType::DEVICE_TYPE_INVALID;
625 DeviceRole deviceRole = DeviceRole::DEVICE_ROLE_NONE;
626 AudioPin ret = AudioSystemManager::GetInstance()->GetPinValueFromType(deviceType, deviceRole);
627 EXPECT_EQ(ret, AudioPin::AUDIO_PIN_NONE);
628 }
629
630 /**
631 * @tc.name : Test GetPinValueFromType API
632 * @tc.number: GetPinValueFromType_003
633 * @tc.desc : Test GetPinValueFromType interface. deviceType set to DEVICE_TYPE_DEFAULT,
634 * deviceRole set to INPUT_DEVICE
635 */
636 HWTEST(AudioManagerUnitTest, GetPinValueFromType_003, TestSize.Level1)
637 {
638 DeviceType deviceType = DeviceType::DEVICE_TYPE_DEFAULT;
639 DeviceRole deviceRole = DeviceRole::INPUT_DEVICE;
640 AudioPin ret = AudioSystemManager::GetInstance()->GetPinValueFromType(deviceType, deviceRole);
641 EXPECT_EQ(ret, AudioPin::AUDIO_PIN_IN_DAUDIO_DEFAULT);
642 }
643
644 /**
645 * @tc.name : Test GetPinValueFromType API
646 * @tc.number: GetPinValueFromType_004
647 * @tc.desc : Test GetPinValueFromType interface. deviceType set to DEVICE_TYPE_DEFAULT,
648 * deviceRole set to DEVICE_ROLE_NONE
649 */
650 HWTEST(AudioManagerUnitTest, GetPinValueFromType_004, TestSize.Level1)
651 {
652 DeviceType deviceType = DeviceType::DEVICE_TYPE_DEFAULT;
653 DeviceRole deviceRole = DeviceRole::DEVICE_ROLE_NONE;
654 AudioPin ret = AudioSystemManager::GetInstance()->GetPinValueFromType(deviceType, deviceRole);
655 EXPECT_EQ(ret, AudioPin::AUDIO_PIN_OUT_DAUDIO_DEFAULT);
656 }
657
658 /**
659 * @tc.name : Test GetPinValueFromType API
660 * @tc.number: GetPinValueFromType_005
661 * @tc.desc : Test GetPinValueFromType interface. deviceType set to DEVICE_TYPE_SPEAKER,
662 * deviceRole set to DEVICE_ROLE_NONE
663 */
664 HWTEST(AudioManagerUnitTest, GetPinValueFromType_005, TestSize.Level1)
665 {
666 DeviceType deviceType = DeviceType::DEVICE_TYPE_SPEAKER;
667 DeviceRole deviceRole = DeviceRole::DEVICE_ROLE_NONE;
668 AudioPin ret = AudioSystemManager::GetInstance()->GetPinValueFromType(deviceType, deviceRole);
669 EXPECT_EQ(ret, AudioPin::AUDIO_PIN_OUT_SPEAKER);
670 }
671
672 /**
673 * @tc.name : Test GetPinValueFromType API
674 * @tc.number: GetPinValueFromType_006
675 * @tc.desc : Test GetPinValueFromType interface. deviceType set to DEVICE_TYPE_MIC,
676 * deviceRole set to DEVICE_ROLE_NONE
677 */
678 HWTEST(AudioManagerUnitTest, GetPinValueFromType_006, TestSize.Level1)
679 {
680 DeviceType deviceType = DeviceType::DEVICE_TYPE_MIC;
681 DeviceRole deviceRole = DeviceRole::DEVICE_ROLE_NONE;
682 AudioPin ret = AudioSystemManager::GetInstance()->GetPinValueFromType(deviceType, deviceRole);
683 EXPECT_EQ(ret, AudioPin::AUDIO_PIN_IN_MIC);
684 }
685
686 /**
687 * @tc.name : Test GetPinValueFromType API
688 * @tc.number: GetPinValueFromType_007
689 * @tc.desc : Test GetPinValueFromType interface. deviceType set to DEVICE_TYPE_WIRED_HEADSET,
690 * deviceRole set to INPUT_DEVICE
691 */
692 HWTEST(AudioManagerUnitTest, GetPinValueFromType_007, TestSize.Level1)
693 {
694 DeviceType deviceType = DeviceType::DEVICE_TYPE_WIRED_HEADSET;
695 DeviceRole deviceRole = DeviceRole::INPUT_DEVICE;
696 AudioPin ret = AudioSystemManager::GetInstance()->GetPinValueFromType(deviceType, deviceRole);
697 EXPECT_EQ(ret, AudioPin::AUDIO_PIN_IN_HS_MIC);
698 }
699
700 /**
701 * @tc.name : Test GetPinValueFromType API
702 * @tc.number: GetPinValueFromType_008
703 * @tc.desc : Test GetPinValueFromType interface. deviceType set to DEVICE_TYPE_WIRED_HEADSET,
704 * deviceRole set to OUTPUT_DEVICE
705 */
706 HWTEST(AudioManagerUnitTest, GetPinValueFromType_008, TestSize.Level1)
707 {
708 DeviceType deviceType = DeviceType::DEVICE_TYPE_WIRED_HEADSET;
709 DeviceRole deviceRole = DeviceRole::OUTPUT_DEVICE;
710 AudioPin ret = AudioSystemManager::GetInstance()->GetPinValueFromType(deviceType, deviceRole);
711 EXPECT_EQ(ret, AudioPin::AUDIO_PIN_OUT_HEADSET);
712 }
713
714 /**
715 * @tc.name : Test GetPinValueFromType API
716 * @tc.number: GetPinValueFromType_009
717 * @tc.desc : Test GetPinValueFromType interface. deviceType set to DEVICE_TYPE_USB_HEADSET,
718 * deviceRole set to OUTPUT_DEVICE
719 */
720 HWTEST(AudioManagerUnitTest, GetPinValueFromType_009, TestSize.Level1)
721 {
722 DeviceType deviceType = DeviceType::DEVICE_TYPE_USB_HEADSET;
723 DeviceRole deviceRole = DeviceRole::OUTPUT_DEVICE;
724 AudioPin ret = AudioSystemManager::GetInstance()->GetPinValueFromType(deviceType, deviceRole);
725 EXPECT_EQ(ret, AudioPin::AUDIO_PIN_NONE);
726 }
727
728 /**
729 * @tc.name : Test GetPinValueFromType API
730 * @tc.number: GetPinValueFromType_010
731 * @tc.desc : Test GetPinValueFromType interface. deviceType set to DEVICE_TYPE_FILE_SINK,
732 * deviceRole set to OUTPUT_DEVICE
733 */
734 HWTEST(AudioManagerUnitTest, GetPinValueFromType_010, TestSize.Level1)
735 {
736 DeviceType deviceType = DeviceType::DEVICE_TYPE_FILE_SINK;
737 DeviceRole deviceRole = DeviceRole::OUTPUT_DEVICE;
738 AudioPin ret = AudioSystemManager::GetInstance()->GetPinValueFromType(deviceType, deviceRole);
739 EXPECT_EQ(ret, AudioPin::AUDIO_PIN_NONE);
740 }
741
742 /**
743 * @tc.name : Test GetPinValueFromType API
744 * @tc.number: GetPinValueFromType_011
745 * @tc.desc : Test GetPinValueFromType interface. deviceType set to DEVICE_TYPE_FILE_SOURCE,
746 * deviceRole set to OUTPUT_DEVICE
747 */
748 HWTEST(AudioManagerUnitTest, GetPinValueFromType_011, TestSize.Level1)
749 {
750 DeviceType deviceType = DeviceType::DEVICE_TYPE_FILE_SOURCE;
751 DeviceRole deviceRole = DeviceRole::OUTPUT_DEVICE;
752 AudioPin ret = AudioSystemManager::GetInstance()->GetPinValueFromType(deviceType, deviceRole);
753 EXPECT_EQ(ret, AudioPin::AUDIO_PIN_NONE);
754 }
755
756 /**
757 * @tc.name : Test GetPinValueFromType API
758 * @tc.number: GetPinValueFromType_012
759 * @tc.desc : Test GetPinValueFromType interface. deviceType set to DEVICE_TYPE_BLUETOOTH_SCO,
760 * deviceRole set to OUTPUT_DEVICE
761 */
762 HWTEST(AudioManagerUnitTest, GetPinValueFromType_012, TestSize.Level1)
763 {
764 DeviceType deviceType = DeviceType::DEVICE_TYPE_BLUETOOTH_SCO;
765 DeviceRole deviceRole = DeviceRole::OUTPUT_DEVICE;
766 AudioPin ret = AudioSystemManager::GetInstance()->GetPinValueFromType(deviceType, deviceRole);
767 EXPECT_EQ(ret, AudioPin::AUDIO_PIN_NONE);
768 }
769
770 /**
771 * @tc.name : Test GetPinValueFromType API
772 * @tc.number: GetPinValueFromType_013
773 * @tc.desc : Test GetPinValueFromType interface. deviceType set to DEVICE_TYPE_BLUETOOTH_A2DP,
774 * deviceRole set to OUTPUT_DEVICE
775 */
776 HWTEST(AudioManagerUnitTest, GetPinValueFromType_013, TestSize.Level1)
777 {
778 DeviceType deviceType = DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP;
779 DeviceRole deviceRole = DeviceRole::OUTPUT_DEVICE;
780 AudioPin ret = AudioSystemManager::GetInstance()->GetPinValueFromType(deviceType, deviceRole);
781 EXPECT_EQ(ret, AudioPin::AUDIO_PIN_NONE);
782 }
783
784 /**
785 * @tc.name : Test GetPinValueFromType API
786 * @tc.number: GetPinValueFromType_014
787 * @tc.desc : Test GetPinValueFromType interface. deviceType set to DEVICE_TYPE_MAX,
788 * deviceRole set to OUTPUT_DEVICE
789 */
790 HWTEST(AudioManagerUnitTest, GetPinValueFromType_014, TestSize.Level1)
791 {
792 DeviceType deviceType = DeviceType::DEVICE_TYPE_MAX;
793 DeviceRole deviceRole = DeviceRole::OUTPUT_DEVICE;
794 AudioPin ret = AudioSystemManager::GetInstance()->GetPinValueFromType(deviceType, deviceRole);
795 EXPECT_EQ(ret, AudioPin::AUDIO_PIN_NONE);
796 }
797
798 /**
799 * @tc.name : Test GetPinValueFromType API
800 * @tc.number: GetPinValueFromType_015
801 * @tc.desc : Test GetPinValueFromType interface. deviceType set to DEVICE_TYPE_DEFAULT,
802 * deviceRole set to OUTPUT_DEVICE
803 */
804 HWTEST(AudioManagerUnitTest, GetPinValueFromType_015, TestSize.Level1)
805 {
806 DeviceType deviceType = DeviceType::DEVICE_TYPE_DEFAULT;
807 DeviceRole deviceRole = DeviceRole::OUTPUT_DEVICE;
808 AudioPin ret = AudioSystemManager::GetInstance()->GetPinValueFromType(deviceType, deviceRole);
809 EXPECT_EQ(ret, AudioPin::AUDIO_PIN_OUT_DAUDIO_DEFAULT);
810 }
811
812 /**
813 * @tc.name : Test GetTypeValueFromPin API
814 * @tc.number: GetTypeValueFromPin_001
815 * @tc.desc : Test GetTypeValueFromPin interface. pin set to AUDIO_PIN_NONE
816 */
817 HWTEST(AudioManagerUnitTest, GetTypeValueFromPin_001, TestSize.Level1)
818 {
819 AudioPin pin = AudioPin::AUDIO_PIN_NONE;
820 DeviceType ret = AudioSystemManager::GetInstance()->GetTypeValueFromPin(pin);
821 EXPECT_EQ(ret, DeviceType::DEVICE_TYPE_NONE);
822 }
823
824 /**
825 * @tc.name : Test GetTypeValueFromPin API
826 * @tc.number: GetTypeValueFromPin_002
827 * @tc.desc : Test GetTypeValueFromPin interface. pin set to AUDIO_PIN_OUT_SPEAKER
828 */
829 HWTEST(AudioManagerUnitTest, GetTypeValueFromPin_002, TestSize.Level1)
830 {
831 AudioPin pin = AudioPin::AUDIO_PIN_OUT_SPEAKER;
832 DeviceType ret = AudioSystemManager::GetInstance()->GetTypeValueFromPin(pin);
833 EXPECT_EQ(ret, DeviceType::DEVICE_TYPE_SPEAKER);
834 }
835
836 /**
837 * @tc.name : Test GetTypeValueFromPin API
838 * @tc.number: GetTypeValueFromPin_003
839 * @tc.desc : Test GetTypeValueFromPin interface. pin set to AUDIO_PIN_OUT_HEADSET
840 */
841 HWTEST(AudioManagerUnitTest, GetTypeValueFromPin_003, TestSize.Level1)
842 {
843 AudioPin pin = AudioPin::AUDIO_PIN_OUT_HEADSET;
844 DeviceType ret = AudioSystemManager::GetInstance()->GetTypeValueFromPin(pin);
845 EXPECT_EQ(ret, DeviceType::DEVICE_TYPE_NONE);
846 }
847
848 /**
849 * @tc.name : Test GetTypeValueFromPin API
850 * @tc.number: GetTypeValueFromPin_004
851 * @tc.desc : Test GetTypeValueFromPin interface. pin set to AUDIO_PIN_OUT_LINEOUT
852 */
853 HWTEST(AudioManagerUnitTest, GetTypeValueFromPin_004, TestSize.Level1)
854 {
855 AudioPin pin = AudioPin::AUDIO_PIN_OUT_LINEOUT;
856 DeviceType ret = AudioSystemManager::GetInstance()->GetTypeValueFromPin(pin);
857 EXPECT_EQ(ret, DeviceType::DEVICE_TYPE_NONE);
858 }
859
860 /**
861 * @tc.name : Test GetTypeValueFromPin API
862 * @tc.number: GetTypeValueFromPin_005
863 * @tc.desc : Test GetTypeValueFromPin interface. pin set to AUDIO_PIN_OUT_HDMI
864 */
865 HWTEST(AudioManagerUnitTest, GetTypeValueFromPin_005, TestSize.Level1)
866 {
867 AudioPin pin = AudioPin::AUDIO_PIN_OUT_HDMI;
868 DeviceType ret = AudioSystemManager::GetInstance()->GetTypeValueFromPin(pin);
869 EXPECT_EQ(ret, DeviceType::DEVICE_TYPE_NONE);
870 }
871
872 /**
873 * @tc.name : Test GetTypeValueFromPin API
874 * @tc.number: GetTypeValueFromPin_006
875 * @tc.desc : Test GetTypeValueFromPin interface. pin set to AUDIO_PIN_OUT_USB
876 */
877 HWTEST(AudioManagerUnitTest, GetTypeValueFromPin_006, TestSize.Level1)
878 {
879 AudioPin pin = AudioPin::AUDIO_PIN_OUT_USB;
880 DeviceType ret = AudioSystemManager::GetInstance()->GetTypeValueFromPin(pin);
881 EXPECT_EQ(ret, DeviceType::DEVICE_TYPE_NONE);
882 }
883
884 /**
885 * @tc.name : Test GetTypeValueFromPin API
886 * @tc.number: GetTypeValueFromPin_007
887 * @tc.desc : Test GetTypeValueFromPin interface. pin set to AUDIO_PIN_OUT_USB_EXT
888 */
889 HWTEST(AudioManagerUnitTest, GetTypeValueFromPin_007, TestSize.Level1)
890 {
891 AudioPin pin = AudioPin::AUDIO_PIN_OUT_USB_EXT;
892 DeviceType ret = AudioSystemManager::GetInstance()->GetTypeValueFromPin(pin);
893 EXPECT_EQ(ret, DeviceType::DEVICE_TYPE_NONE);
894 }
895
896 /**
897 * @tc.name : Test GetTypeValueFromPin API
898 * @tc.number: GetTypeValueFromPin_008
899 * @tc.desc : Test GetTypeValueFromPin interface. pin set to AUDIO_PIN_OUT_DAUDIO_DEFAULT
900 */
901 HWTEST(AudioManagerUnitTest, GetTypeValueFromPin_008, TestSize.Level1)
902 {
903 AudioPin pin = AudioPin::AUDIO_PIN_OUT_DAUDIO_DEFAULT;
904 DeviceType ret = AudioSystemManager::GetInstance()->GetTypeValueFromPin(pin);
905 EXPECT_EQ(ret, DeviceType::DEVICE_TYPE_DEFAULT);
906 }
907
908 /**
909 * @tc.name : Test GetTypeValueFromPin API
910 * @tc.number: GetTypeValueFromPin_009
911 * @tc.desc : Test GetTypeValueFromPin interface. pin set to AUDIO_PIN_IN_MIC
912 */
913 HWTEST(AudioManagerUnitTest, GetTypeValueFromPin_009, TestSize.Level1)
914 {
915 AudioPin pin = AudioPin::AUDIO_PIN_IN_MIC;
916 DeviceType ret = AudioSystemManager::GetInstance()->GetTypeValueFromPin(pin);
917 EXPECT_EQ(ret, DeviceType::DEVICE_TYPE_MIC);
918 }
919
920 /**
921 * @tc.name : Test GetTypeValueFromPin API
922 * @tc.number: GetTypeValueFromPin_010
923 * @tc.desc : Test GetTypeValueFromPin interface. pin set to AUDIO_PIN_IN_HS_MIC
924 */
925 HWTEST(AudioManagerUnitTest, GetTypeValueFromPin_010, TestSize.Level1)
926 {
927 AudioPin pin = AudioPin::AUDIO_PIN_IN_HS_MIC;
928 DeviceType ret = AudioSystemManager::GetInstance()->GetTypeValueFromPin(pin);
929 EXPECT_EQ(ret, DeviceType::DEVICE_TYPE_WIRED_HEADSET);
930 }
931
932 /**
933 * @tc.name : Test GetTypeValueFromPin API
934 * @tc.number: GetTypeValueFromPin_011
935 * @tc.desc : Test GetTypeValueFromPin interface. pin set to AUDIO_PIN_IN_LINEIN
936 */
937 HWTEST(AudioManagerUnitTest, GetTypeValueFromPin_011, TestSize.Level1)
938 {
939 AudioPin pin = AudioPin::AUDIO_PIN_IN_LINEIN;
940 DeviceType ret = AudioSystemManager::GetInstance()->GetTypeValueFromPin(pin);
941 EXPECT_EQ(ret, DeviceType::DEVICE_TYPE_NONE);
942 }
943
944 /**
945 * @tc.name : Test GetTypeValueFromPin API
946 * @tc.number: GetTypeValueFromPin_012
947 * @tc.desc : Test GetTypeValueFromPin interface. pin set to AUDIO_PIN_IN_USB_EXT
948 */
949 HWTEST(AudioManagerUnitTest, GetTypeValueFromPin_012, TestSize.Level1)
950 {
951 AudioPin pin = AudioPin::AUDIO_PIN_IN_USB_EXT;
952 DeviceType ret = AudioSystemManager::GetInstance()->GetTypeValueFromPin(pin);
953 EXPECT_EQ(ret, DeviceType::DEVICE_TYPE_NONE);
954 }
955
956 /**
957 * @tc.name : Test GetTypeValueFromPin API
958 * @tc.number: GetTypeValueFromPin_013
959 * @tc.desc : Test GetTypeValueFromPin interface. pin set to AUDIO_PIN_IN_DAUDIO_DEFAULT
960 */
961 HWTEST(AudioManagerUnitTest, GetTypeValueFromPin_013, TestSize.Level1)
962 {
963 AudioPin pin = AudioPin::AUDIO_PIN_IN_DAUDIO_DEFAULT;
964 DeviceType ret = AudioSystemManager::GetInstance()->GetTypeValueFromPin(pin);
965 EXPECT_EQ(ret, DeviceType::DEVICE_TYPE_DEFAULT);
966 }
967
968 /**
969 * @tc.name : Test GetTypeValueFromPin API
970 * @tc.number: GetTypeValueFromPin_014
971 * @tc.desc : Test GetTypeValueFromPin interface. pin set to INVALID data
972 */
973 HWTEST(AudioManagerUnitTest, GetTypeValueFromPin_014, TestSize.Level1)
974 {
975 int32_t invalid_value = 128;
976 AudioPin pin = AudioPin(invalid_value);
977 DeviceType ret = AudioSystemManager::GetInstance()->GetTypeValueFromPin(pin);
978 EXPECT_EQ(ret, DeviceType::DEVICE_TYPE_NONE);
979 }
980
981 /**
982 * @tc.name : Test SetDeviceActive API
983 * @tc.number: SetDeviceActive_001
984 * @tc.desc : Test SetDeviceActive interface. Activate bluetooth sco device by deactivating speaker
985 */
986 HWTEST(AudioManagerUnitTest, SetDeviceActive_001, TestSize.Level1)
987 {
988 auto isActive = AudioSystemManager::GetInstance()->IsDeviceActive(ActiveDeviceType::SPEAKER);
989 EXPECT_TRUE(isActive);
990 }
991
992 /**
993 * @tc.name : Test SetDeviceActive API
994 * @tc.number: SetDeviceActive_002
995 * @tc.desc : Test SetDeviceActive interface. Speaker should not be disable since its the only active device
996 */
997 HWTEST(AudioManagerUnitTest, SetDeviceActive_002, TestSize.Level1)
998 {
999 auto ret = AudioSystemManager::GetInstance()->SetDeviceActive(ActiveDeviceType::SPEAKER, false);
1000 EXPECT_EQ(SUCCESS, ret);
1001
1002 auto isActive = AudioSystemManager::GetInstance()->IsDeviceActive(ActiveDeviceType::SPEAKER);
1003 EXPECT_TRUE(isActive);
1004 }
1005
1006 /**
1007 * @tc.name : Test SetDeviceActive API
1008 * @tc.number: SetDeviceActive_003
1009 * @tc.desc : Test SetDeviceActive interface. Actiavting invalid device should fail
1010 */
1011 HWTEST(AudioManagerUnitTest, SetDeviceActive_003, TestSize.Level1)
1012 {
1013 auto ret = AudioSystemManager::GetInstance()->SetDeviceActive(ActiveDeviceType::ACTIVE_DEVICE_TYPE_NONE, true);
1014 EXPECT_NE(SUCCESS, ret);
1015
1016 // On bootup sco won't be connected. Hence activation should fail
1017 ret = AudioSystemManager::GetInstance()->SetDeviceActive(ActiveDeviceType::BLUETOOTH_SCO, true);
1018 EXPECT_NE(SUCCESS, ret);
1019
1020 auto isActive = AudioSystemManager::GetInstance()->IsDeviceActive(ActiveDeviceType::SPEAKER);
1021 EXPECT_TRUE(isActive);
1022 }
1023
1024 /**
1025 * @tc.name : Test IsDeviceActive API
1026 * @tc.number: IsDeviceActive_001
1027 * @tc.desc : Test IsDeviceActive interface. Activate device by ACTIVE_DEVICE_TYPE_NONE
1028 */
1029 HWTEST(AudioManagerUnitTest, IsDeviceActive_001, TestSize.Level1)
1030 {
1031 auto isActive = AudioSystemManager::GetInstance()->IsDeviceActive(ActiveDeviceType::ACTIVE_DEVICE_TYPE_NONE);
1032 EXPECT_FALSE(isActive);
1033 }
1034
1035 /**
1036 * @tc.name : Test IsStreamActive API
1037 * @tc.number: IsStreamActive_001
1038 * @tc.desc : Test IsStreamActive interface. set AudioVolumeType return true
1039 */
1040 HWTEST(AudioManagerUnitTest, IsStreamActive_001, TestSize.Level1)
1041 {
1042 auto isActive = AudioSystemManager::GetInstance()->IsStreamActive(AudioVolumeType::STREAM_MUSIC);
1043 EXPECT_FALSE(isActive);
1044 isActive = AudioSystemManager::GetInstance()->IsStreamActive(AudioVolumeType::STREAM_RING);
1045 EXPECT_FALSE(isActive);
1046 isActive = AudioSystemManager::GetInstance()->IsStreamActive(AudioVolumeType::STREAM_VOICE_CALL);
1047 EXPECT_FALSE(isActive);
1048 isActive = AudioSystemManager::GetInstance()->IsStreamActive(AudioVolumeType::STREAM_VOICE_ASSISTANT);
1049 EXPECT_FALSE(isActive);
1050 }
1051
1052 /**
1053 * @tc.name : Test IsStreamActive API
1054 * @tc.number: IsStreamActive_002
1055 * @tc.desc : Test IsStreamActive interface. set AudioVolumeType return false
1056 */
1057 HWTEST(AudioManagerUnitTest, IsStreamActive_002, TestSize.Level1)
1058 {
1059 auto isActive = AudioSystemManager::GetInstance()->IsStreamActive(AudioVolumeType::STREAM_DEFAULT);
1060 EXPECT_FALSE(isActive);
1061 }
1062
1063 /**
1064 * @tc.name : Test IsStreamMute API
1065 * @tc.number: IsStreamMute_001
1066 * @tc.desc : Test IsStreamMute interface. set AudioVolumeType return false
1067 */
1068 HWTEST(AudioManagerUnitTest, IsStreamMute_001, TestSize.Level1)
1069 {
1070 auto isActive = AudioSystemManager::GetInstance()->IsStreamMute(AudioVolumeType::STREAM_DEFAULT);
1071 EXPECT_FALSE(isActive);
1072 }
1073
1074 /**
1075 * @tc.name : Test ReconfigureChannel API
1076 * @tc.number: ReconfigureChannel_001
1077 * @tc.desc : Test ReconfigureAudioChannel interface. Change sink and source channel count on runtime
1078 */
1079 HWTEST(AudioManagerUnitTest, ReconfigureChannel_001, TestSize.Level1)
1080 {
1081 auto ret = AudioSystemManager::GetInstance()->SetDeviceActive(ActiveDeviceType::FILE_SINK_DEVICE, true);
1082 EXPECT_EQ(SUCCESS, ret);
1083
1084 auto isActive = AudioSystemManager::GetInstance()->IsDeviceActive(ActiveDeviceType::FILE_SINK_DEVICE);
1085 EXPECT_TRUE(isActive);
1086
1087 ret = AudioSystemManager::GetInstance()->ReconfigureAudioChannel(CHANNEL_4, DeviceType::DEVICE_TYPE_FILE_SINK);
1088 EXPECT_EQ(SUCCESS, ret);
1089
1090 ret = AudioSystemManager::GetInstance()->SetDeviceActive(ActiveDeviceType::FILE_SINK_DEVICE, false);
1091 EXPECT_EQ(SUCCESS, ret);
1092
1093 isActive = AudioSystemManager::GetInstance()->IsDeviceActive(ActiveDeviceType::SPEAKER);
1094 EXPECT_TRUE(isActive);
1095 }
1096
1097 /**
1098 * @tc.name : Test ReconfigureChannel API
1099 * @tc.number: ReconfigureChannel_002
1100 * @tc.desc : Test ReconfigureAudioChannel interface. Change sink and source channel count on runtime
1101 */
1102 HWTEST(AudioManagerUnitTest, ReconfigureChannel_002, TestSize.Level1)
1103 {
1104 int32_t ret = SUCCESS;
1105
1106 auto isActive = AudioSystemManager::GetInstance()->IsDeviceActive(ActiveDeviceType::FILE_SINK_DEVICE);
1107 if (isActive) {
1108 ret = AudioSystemManager::GetInstance()->SetDeviceActive(ActiveDeviceType::FILE_SINK_DEVICE, false);
1109 EXPECT_EQ(SUCCESS, ret);
1110 }
1111
1112 ret = AudioSystemManager::GetInstance()->ReconfigureAudioChannel(CHANNEL_4, DeviceType::DEVICE_TYPE_FILE_SINK);
1113 EXPECT_NE(SUCCESS, ret);
1114
1115 ret = AudioSystemManager::GetInstance()->ReconfigureAudioChannel(CHANNEL_4, DeviceType::DEVICE_TYPE_FILE_SOURCE);
1116 EXPECT_NE(SUCCESS, ret);
1117 }
1118
1119 /**
1120 * @tc.name : Test ReconfigureChannel API
1121 * @tc.number: ReconfigureChannel_003
1122 * @tc.desc : Test ReconfigureAudioChannel interface. Check for wrong channel count
1123 */
1124 HWTEST(AudioManagerUnitTest, ReconfigureChannel_003, TestSize.Level1)
1125 {
1126 auto ret = AudioSystemManager::GetInstance()->SetDeviceActive(ActiveDeviceType::FILE_SINK_DEVICE, true);
1127 EXPECT_EQ(SUCCESS, ret);
1128
1129 auto isActive = AudioSystemManager::GetInstance()->IsDeviceActive(ActiveDeviceType::FILE_SINK_DEVICE);
1130 EXPECT_TRUE(isActive);
1131
1132 ret = AudioSystemManager::GetInstance()->ReconfigureAudioChannel(INV_CHANNEL, DeviceType::DEVICE_TYPE_FILE_SINK);
1133 EXPECT_NE(SUCCESS, ret);
1134
1135 ret = AudioSystemManager::GetInstance()->ReconfigureAudioChannel(INV_CHANNEL, DeviceType::DEVICE_TYPE_FILE_SOURCE);
1136 EXPECT_NE(SUCCESS, ret);
1137
1138 ret = AudioSystemManager::GetInstance()->ReconfigureAudioChannel(CHANNEL_8, DeviceType::DEVICE_TYPE_FILE_SOURCE);
1139 EXPECT_NE(SUCCESS, ret);
1140
1141 ret = AudioSystemManager::GetInstance()->ReconfigureAudioChannel(CHANNEL_10, DeviceType::DEVICE_TYPE_FILE_SINK);
1142 EXPECT_NE(SUCCESS, ret);
1143
1144 ret = AudioSystemManager::GetInstance()->SetDeviceActive(ActiveDeviceType::SPEAKER, true);
1145 EXPECT_EQ(SUCCESS, ret);
1146
1147 isActive = AudioSystemManager::GetInstance()->IsDeviceActive(ActiveDeviceType::SPEAKER);
1148 EXPECT_TRUE(isActive);
1149 }
1150
1151 /**
1152 * @tc.name : Test SetAudioManagerInterruptCallback API
1153 * @tc.number: SetAudioManagerInterruptCallback_001
1154 * @tc.desc : Test SetAudioManagerInterruptCallback interface with valid parameters
1155 */
1156 HWTEST(AudioManagerUnitTest, SetAudioManagerInterruptCallback_001, TestSize.Level1)
1157 {
1158 shared_ptr<AudioManagerCallback> interruptCallback = make_shared<AudioManagerCallbackImpl>();
1159 auto ret = AudioSystemManager::GetInstance()->SetAudioManagerInterruptCallback(interruptCallback);
1160 EXPECT_EQ(SUCCESS, ret);
1161 }
1162
1163 /**
1164 * @tc.name : Test SetAudioManagerInterruptCallback API
1165 * @tc.number: SetAudioManagerInterruptCallback_002
1166 * @tc.desc : Test SetAudioManagerInterruptCallback interface with null callback pointer as parameter
1167 */
1168 HWTEST(AudioManagerUnitTest, SetAudioManagerInterruptCallback_002, TestSize.Level1)
1169 {
1170 auto ret = AudioSystemManager::GetInstance()->SetAudioManagerInterruptCallback(nullptr);
1171 EXPECT_NE(SUCCESS, ret);
1172 }
1173
1174 /**
1175 * @tc.name : Test SetAudioManagerInterruptCallback API
1176 * @tc.number: SetAudioManagerInterruptCallback_003
1177 * @tc.desc : Test SetAudioManagerInterruptCallback interface with Multiple Set
1178 */
1179 HWTEST(AudioManagerUnitTest, SetAudioManagerInterruptCallback_003, TestSize.Level1)
1180 {
1181 shared_ptr<AudioManagerCallback> interruptCallback = make_shared<AudioManagerCallbackImpl>();
1182 auto ret = AudioSystemManager::GetInstance()->SetAudioManagerInterruptCallback(interruptCallback);
1183 EXPECT_EQ(SUCCESS, ret);
1184 ret = AudioSystemManager::GetInstance()->SetAudioManagerInterruptCallback(interruptCallback);
1185 EXPECT_EQ(SUCCESS, ret);
1186 shared_ptr<AudioManagerCallback> interruptCallbackNew = make_shared<AudioManagerCallbackImpl>();
1187 ret = AudioSystemManager::GetInstance()->SetAudioManagerInterruptCallback(interruptCallbackNew);
1188 EXPECT_EQ(SUCCESS, ret);
1189 }
1190
1191 /**
1192 * @tc.name : Test UnsetAudioManagerInterruptCallback API
1193 * @tc.number: UnsetAudioManagerInterruptCallback_001
1194 * @tc.desc : Test UnsetAudioManagerInterruptCallback interface with Set and Unset callback
1195 */
1196 HWTEST(AudioManagerUnitTest, UnsetAudioManagerInterruptCallback_001, TestSize.Level1)
1197 {
1198 shared_ptr<AudioManagerCallback> interruptCallback = make_shared<AudioManagerCallbackImpl>();
1199 auto ret = AudioSystemManager::GetInstance()->SetAudioManagerInterruptCallback(interruptCallback);
1200 EXPECT_EQ(SUCCESS, ret);
1201 ret = AudioSystemManager::GetInstance()->UnsetAudioManagerInterruptCallback();
1202 EXPECT_EQ(SUCCESS, ret);
1203 }
1204
1205 /**
1206 * @tc.name : Test UnsetAudioManagerInterruptCallback API
1207 * @tc.number: UnsetAudioManagerInterruptCallback_002
1208 * @tc.desc : Test UnsetAudioManagerInterruptCallback interface with Multiple Unset
1209 */
1210 HWTEST(AudioManagerUnitTest, UnsetAudioManagerInterruptCallback_002, TestSize.Level1)
1211 {
1212 shared_ptr<AudioManagerCallback> interruptCallback = make_shared<AudioManagerCallbackImpl>();
1213 auto ret = AudioSystemManager::GetInstance()->SetAudioManagerInterruptCallback(interruptCallback);
1214 EXPECT_EQ(SUCCESS, ret);
1215 ret = AudioSystemManager::GetInstance()->UnsetAudioManagerInterruptCallback();
1216 EXPECT_EQ(SUCCESS, ret);
1217 ret = AudioSystemManager::GetInstance()->UnsetAudioManagerInterruptCallback();
1218 EXPECT_EQ(SUCCESS, ret);
1219 }
1220
1221 /**
1222 * @tc.name : Test UnsetAudioManagerInterruptCallback API
1223 * @tc.number: UnsetAudioManagerInterruptCallback_003
1224 * @tc.desc : Test UnsetAudioManagerInterruptCallback interface without set interrupt call
1225 */
1226 HWTEST(AudioManagerUnitTest, UnsetAudioManagerInterruptCallback_003, TestSize.Level1)
1227 {
1228 auto ret = AudioSystemManager::GetInstance()->UnsetAudioManagerInterruptCallback();
1229 EXPECT_EQ(SUCCESS, ret);
1230 }
1231
1232 /**
1233 * @tc.name : Test RequestAudioFocus API
1234 * @tc.number: RequestAudioFocus_001
1235 * @tc.desc : Test RequestAudioFocus interface with valid parameters
1236 */
1237 HWTEST(AudioManagerUnitTest, RequestAudioFocus_001, TestSize.Level1)
1238 {
1239 AudioInterrupt audioInterrupt;
1240 audioInterrupt.contentType = CONTENT_TYPE_RINGTONE;
1241 audioInterrupt.streamUsage = STREAM_USAGE_NOTIFICATION_RINGTONE;
1242 audioInterrupt.streamType = STREAM_ACCESSIBILITY;
1243 shared_ptr<AudioManagerCallback> interruptCallback = make_shared<AudioManagerCallbackImpl>();
1244 auto ret = AudioSystemManager::GetInstance()->SetAudioManagerInterruptCallback(interruptCallback);
1245 EXPECT_EQ(SUCCESS, ret);
1246 ret = AudioSystemManager::GetInstance()->RequestAudioFocus(audioInterrupt);
1247 EXPECT_EQ(SUCCESS, ret);
1248 }
1249
1250 /**
1251 * @tc.name : Test RequestAudioFocus API
1252 * @tc.number: RequestAudioFocus_002
1253 * @tc.desc : Test RequestAudioFocus interface with invalid parameters
1254 */
1255 HWTEST(AudioManagerUnitTest, RequestAudioFocus_002, TestSize.Level1)
1256 {
1257 AudioInterrupt audioInterrupt;
1258 constexpr int32_t INVALID_CONTENT_TYPE = 10;
1259 audioInterrupt.contentType = static_cast<ContentType>(INVALID_CONTENT_TYPE);
1260 audioInterrupt.streamUsage = STREAM_USAGE_NOTIFICATION_RINGTONE;
1261 audioInterrupt.streamType = STREAM_ACCESSIBILITY;
1262 shared_ptr<AudioManagerCallback> interruptCallback = make_shared<AudioManagerCallbackImpl>();
1263 auto ret = AudioSystemManager::GetInstance()->SetAudioManagerInterruptCallback(interruptCallback);
1264 EXPECT_EQ(SUCCESS, ret);
1265 ret = AudioSystemManager::GetInstance()->RequestAudioFocus(audioInterrupt);
1266 EXPECT_NE(SUCCESS, ret);
1267 }
1268
1269 /**
1270 * @tc.name : Test RequestAudioFocus API
1271 * @tc.number: RequestAudioFocus_003
1272 * @tc.desc : Test RequestAudioFocus interface with boundary values for content type, stream usage
1273 * and stream type
1274 */
1275 HWTEST(AudioManagerUnitTest, RequestAudioFocus_003, TestSize.Level1)
1276 {
1277 AudioInterrupt audioInterrupt;
1278 audioInterrupt.contentType = static_cast<ContentType>(CONTENT_TYPE_UPPER_INVALID);
1279 audioInterrupt.streamUsage = STREAM_USAGE_UNKNOWN;
1280 audioInterrupt.streamType = STREAM_VOICE_CALL;
1281
1282 shared_ptr<AudioManagerCallback> interruptCallback = make_shared<AudioManagerCallbackImpl>();
1283 auto ret = AudioSystemManager::GetInstance()->SetAudioManagerInterruptCallback(interruptCallback);
1284 EXPECT_EQ(SUCCESS, ret);
1285 ret = AudioSystemManager::GetInstance()->RequestAudioFocus(audioInterrupt);
1286 EXPECT_NE(SUCCESS, ret);
1287 audioInterrupt.contentType = static_cast<ContentType>(CONTENT_TYPE_LOWER_INVALID);
1288 ret = AudioSystemManager::GetInstance()->RequestAudioFocus(audioInterrupt);
1289 EXPECT_NE(SUCCESS, ret);
1290
1291 audioInterrupt.contentType = CONTENT_TYPE_RINGTONE;
1292 audioInterrupt.streamUsage = static_cast<StreamUsage>(STREAM_USAGE_UPPER_INVALID);
1293 ret = AudioSystemManager::GetInstance()->RequestAudioFocus(audioInterrupt);
1294 EXPECT_NE(SUCCESS, ret);
1295 audioInterrupt.streamUsage = static_cast<StreamUsage>(STREAM_USAGE_LOWER_INVALID);
1296 ret = AudioSystemManager::GetInstance()->RequestAudioFocus(audioInterrupt);
1297 EXPECT_NE(SUCCESS, ret);
1298
1299 audioInterrupt.streamUsage = STREAM_USAGE_NOTIFICATION_RINGTONE;
1300 audioInterrupt.streamType = static_cast<AudioStreamType>(STREAM_TYPE_UPPER_INVALID);
1301 ret = AudioSystemManager::GetInstance()->RequestAudioFocus(audioInterrupt);
1302 EXPECT_NE(SUCCESS, ret);
1303 audioInterrupt.streamType = static_cast<AudioStreamType>(STREAM_TYPE_LOWER_INVALID);
1304 ret = AudioSystemManager::GetInstance()->RequestAudioFocus(audioInterrupt);
1305 EXPECT_NE(SUCCESS, ret);
1306
1307 audioInterrupt.contentType = CONTENT_TYPE_UNKNOWN;
1308 audioInterrupt.streamUsage = STREAM_USAGE_UNKNOWN;
1309 audioInterrupt.streamType = STREAM_VOICE_CALL;
1310 ret = AudioSystemManager::GetInstance()->RequestAudioFocus(audioInterrupt);
1311 EXPECT_EQ(SUCCESS, ret);
1312
1313 audioInterrupt.contentType = CONTENT_TYPE_RINGTONE;
1314 audioInterrupt.streamUsage = STREAM_USAGE_NOTIFICATION_RINGTONE;
1315 audioInterrupt.streamType = STREAM_ACCESSIBILITY;
1316 ret = AudioSystemManager::GetInstance()->RequestAudioFocus(audioInterrupt);
1317 EXPECT_EQ(SUCCESS, ret);
1318 }
1319
1320 /**
1321 * @tc.name : Test RequestAudioFocus API
1322 * @tc.number: RequestAudioFocus_004
1323 * @tc.desc : Test RequestAudioFocus interface with back to back requests
1324 */
1325 HWTEST(AudioManagerUnitTest, RequestAudioFocus_004, TestSize.Level1)
1326 {
1327 AudioInterrupt audioInterrupt;
1328 audioInterrupt.contentType = CONTENT_TYPE_RINGTONE;
1329 audioInterrupt.streamUsage = STREAM_USAGE_NOTIFICATION_RINGTONE;
1330 audioInterrupt.streamType = STREAM_ACCESSIBILITY;
1331 shared_ptr<AudioManagerCallback> interruptCallback = make_shared<AudioManagerCallbackImpl>();
1332 auto ret = AudioSystemManager::GetInstance()->SetAudioManagerInterruptCallback(interruptCallback);
1333 EXPECT_EQ(SUCCESS, ret);
1334 ret = AudioSystemManager::GetInstance()->RequestAudioFocus(audioInterrupt);
1335 EXPECT_EQ(SUCCESS, ret);
1336 ret = AudioSystemManager::GetInstance()->RequestAudioFocus(audioInterrupt);
1337 EXPECT_EQ(SUCCESS, ret);
1338 shared_ptr<AudioManagerCallback> interruptCallbackNew = make_shared<AudioManagerCallbackImpl>();
1339 ret = AudioSystemManager::GetInstance()->SetAudioManagerInterruptCallback(interruptCallbackNew);
1340 EXPECT_EQ(SUCCESS, ret);
1341 ret = AudioSystemManager::GetInstance()->RequestAudioFocus(audioInterrupt);
1342 EXPECT_EQ(SUCCESS, ret);
1343 }
1344
1345 /**
1346 * @tc.name : Test AbandonAudioFocus API
1347 * @tc.number: AbandonAudioFocus_001
1348 * @tc.desc : Test AbandonAudioFocus interface with valid parameters
1349 */
1350 HWTEST(AudioManagerUnitTest, AbandonAudioFocus_001, TestSize.Level1)
1351 {
1352 AudioInterrupt audioInterrupt;
1353 audioInterrupt.contentType = CONTENT_TYPE_RINGTONE;
1354 audioInterrupt.streamUsage = STREAM_USAGE_NOTIFICATION_RINGTONE;
1355 audioInterrupt.streamType = STREAM_ACCESSIBILITY;
1356 shared_ptr<AudioManagerCallback> interruptCallback = make_shared<AudioManagerCallbackImpl>();
1357 auto ret = AudioSystemManager::GetInstance()->SetAudioManagerInterruptCallback(interruptCallback);
1358 EXPECT_EQ(SUCCESS, ret);
1359 ret = AudioSystemManager::GetInstance()->RequestAudioFocus(audioInterrupt);
1360 EXPECT_EQ(SUCCESS, ret);
1361 ret = AudioSystemManager::GetInstance()->AbandonAudioFocus(audioInterrupt);
1362 EXPECT_EQ(SUCCESS, ret);
1363 }
1364
1365 /**
1366 * @tc.name : Test AbandonAudioFocus API
1367 * @tc.number: AbandonAudioFocus_002
1368 * @tc.desc : Test AbandonAudioFocus interface with invalid parameters
1369 */
1370 HWTEST(AudioManagerUnitTest, AbandonAudioFocus_002, TestSize.Level1)
1371 {
1372 AudioInterrupt audioInterrupt;
1373 audioInterrupt.contentType = CONTENT_TYPE_RINGTONE;
1374 audioInterrupt.streamUsage = STREAM_USAGE_NOTIFICATION_RINGTONE;
1375 audioInterrupt.streamType = STREAM_ACCESSIBILITY;
1376 shared_ptr<AudioManagerCallback> interruptCallback = make_shared<AudioManagerCallbackImpl>();
1377 auto ret = AudioSystemManager::GetInstance()->SetAudioManagerInterruptCallback(interruptCallback);
1378 EXPECT_EQ(SUCCESS, ret);
1379 ret = AudioSystemManager::GetInstance()->RequestAudioFocus(audioInterrupt);
1380 EXPECT_EQ(SUCCESS, ret);
1381 constexpr int32_t INVALID_CONTENT_TYPE = 10;
1382 audioInterrupt.contentType = static_cast<ContentType>(INVALID_CONTENT_TYPE);
1383 ret = AudioSystemManager::GetInstance()->AbandonAudioFocus(audioInterrupt);
1384 EXPECT_NE(SUCCESS, ret);
1385 }
1386
1387 /**
1388 * @tc.name : Test AbandonAudioFocus API
1389 * @tc.number: AbandonAudioFocus_003
1390 * @tc.desc : Test AbandonAudioFocus interface with invalid parameters
1391 */
1392 HWTEST(AudioManagerUnitTest, AbandonAudioFocus_003, TestSize.Level1)
1393 {
1394 AudioInterrupt audioInterrupt;
1395 audioInterrupt.contentType = CONTENT_TYPE_RINGTONE;
1396 audioInterrupt.streamUsage = STREAM_USAGE_NOTIFICATION_RINGTONE;
1397 audioInterrupt.streamType = STREAM_ACCESSIBILITY;
1398
1399 shared_ptr<AudioManagerCallback> interruptCallback = make_shared<AudioManagerCallbackImpl>();
1400 auto ret = AudioSystemManager::GetInstance()->SetAudioManagerInterruptCallback(interruptCallback);
1401 EXPECT_EQ(SUCCESS, ret);
1402 ret = AudioSystemManager::GetInstance()->RequestAudioFocus(audioInterrupt);
1403 EXPECT_EQ(SUCCESS, ret);
1404
1405 audioInterrupt.contentType = static_cast<ContentType>(CONTENT_TYPE_UPPER_INVALID);
1406 ret = AudioSystemManager::GetInstance()->AbandonAudioFocus(audioInterrupt);
1407 EXPECT_NE(SUCCESS, ret);
1408 audioInterrupt.contentType = static_cast<ContentType>(CONTENT_TYPE_LOWER_INVALID);
1409 ret = AudioSystemManager::GetInstance()->AbandonAudioFocus(audioInterrupt);
1410 EXPECT_NE(SUCCESS, ret);
1411
1412 audioInterrupt.contentType = CONTENT_TYPE_RINGTONE;
1413 audioInterrupt.streamUsage = static_cast<StreamUsage>(STREAM_USAGE_UPPER_INVALID);
1414 ret = AudioSystemManager::GetInstance()->AbandonAudioFocus(audioInterrupt);
1415 EXPECT_NE(SUCCESS, ret);
1416 audioInterrupt.streamUsage = static_cast<StreamUsage>(STREAM_USAGE_LOWER_INVALID);
1417 ret = AudioSystemManager::GetInstance()->AbandonAudioFocus(audioInterrupt);
1418 EXPECT_NE(SUCCESS, ret);
1419
1420 audioInterrupt.streamUsage = STREAM_USAGE_NOTIFICATION_RINGTONE;
1421 audioInterrupt.streamType = static_cast<AudioStreamType>(STREAM_TYPE_UPPER_INVALID);
1422 ret = AudioSystemManager::GetInstance()->RequestAudioFocus(audioInterrupt);
1423 EXPECT_NE(SUCCESS, ret);
1424 audioInterrupt.streamType = static_cast<AudioStreamType>(STREAM_TYPE_LOWER_INVALID);
1425 ret = AudioSystemManager::GetInstance()->RequestAudioFocus(audioInterrupt);
1426 EXPECT_NE(SUCCESS, ret);
1427
1428
1429 audioInterrupt.contentType = CONTENT_TYPE_UNKNOWN;
1430 audioInterrupt.streamUsage = STREAM_USAGE_UNKNOWN;
1431 audioInterrupt.streamType = STREAM_VOICE_CALL;
1432 ret = AudioSystemManager::GetInstance()->RequestAudioFocus(audioInterrupt);
1433 EXPECT_EQ(SUCCESS, ret);
1434 ret = AudioSystemManager::GetInstance()->AbandonAudioFocus(audioInterrupt);
1435 EXPECT_EQ(SUCCESS, ret);
1436
1437 audioInterrupt.contentType = CONTENT_TYPE_RINGTONE;
1438 audioInterrupt.streamUsage = STREAM_USAGE_NOTIFICATION_RINGTONE;
1439 audioInterrupt.streamType = STREAM_VOICE_CALL;
1440 ret = AudioSystemManager::GetInstance()->RequestAudioFocus(audioInterrupt);
1441 EXPECT_EQ(SUCCESS, ret);
1442 ret = AudioSystemManager::GetInstance()->AbandonAudioFocus(audioInterrupt);
1443 EXPECT_EQ(SUCCESS, ret);
1444 }
1445
1446 /**
1447 * @tc.name : Test AbandonAudioFocus API
1448 * @tc.number: AbandonAudioFocus_004
1449 * @tc.desc : Test AbandonAudioFocus interface multiple requests
1450 */
1451 HWTEST(AudioManagerUnitTest, AbandonAudioFocus_004, TestSize.Level1)
1452 {
1453 AudioInterrupt audioInterrupt;
1454 audioInterrupt.contentType = CONTENT_TYPE_RINGTONE;
1455 audioInterrupt.streamUsage = STREAM_USAGE_NOTIFICATION_RINGTONE;
1456 audioInterrupt.streamType = STREAM_ACCESSIBILITY;
1457 shared_ptr<AudioManagerCallback> interruptCallback = make_shared<AudioManagerCallbackImpl>();
1458 auto ret = AudioSystemManager::GetInstance()->SetAudioManagerInterruptCallback(interruptCallback);
1459 EXPECT_EQ(SUCCESS, ret);
1460 ret = AudioSystemManager::GetInstance()->RequestAudioFocus(audioInterrupt);
1461 EXPECT_EQ(SUCCESS, ret);
1462 ret = AudioSystemManager::GetInstance()->AbandonAudioFocus(audioInterrupt);
1463 EXPECT_EQ(SUCCESS, ret);
1464 ret = AudioSystemManager::GetInstance()->AbandonAudioFocus(audioInterrupt);
1465 EXPECT_EQ(SUCCESS, ret);
1466 shared_ptr<AudioManagerCallback> interruptCallbackNew = make_shared<AudioManagerCallbackImpl>();
1467 ret = AudioSystemManager::GetInstance()->SetAudioManagerInterruptCallback(interruptCallbackNew);
1468 EXPECT_EQ(SUCCESS, ret);
1469 ret = AudioSystemManager::GetInstance()->RequestAudioFocus(audioInterrupt);
1470 EXPECT_EQ(SUCCESS, ret);
1471 ret = AudioSystemManager::GetInstance()->AbandonAudioFocus(audioInterrupt);
1472 EXPECT_EQ(SUCCESS, ret);
1473 }
1474
1475 /**
1476 * @tc.name : Test AudioVolume API
1477 * @tc.number: AudioVolume_001
1478 * @tc.desc : Test AudioVolume manager interface multiple requests
1479 */
1480 HWTEST(AudioManagerUnitTest, AudioVolume_001, TestSize.Level1)
1481 {
1482 int32_t volume = 10;
1483 bool mute = true;
1484
1485 AudioRendererOptions rendererOptions;
1486 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_48000;
1487 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
1488 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
1489 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
1490 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
1491 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
1492 rendererOptions.rendererInfo.rendererFlags = 0;
1493
1494 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1495 ASSERT_NE(nullptr, audioRenderer);
1496
1497 auto ret = AudioSystemManager::GetInstance()->SetVolume(AudioVolumeType::STREAM_ALL, volume);
1498 EXPECT_EQ(SUCCESS, ret);
1499 ret = AudioSystemManager::GetInstance()->GetVolume(AudioVolumeType::STREAM_ALL);
1500 EXPECT_EQ(volume, ret);
1501 ret = AudioSystemManager::GetInstance()->SetMute(AudioVolumeType::STREAM_ALL, mute);
1502 EXPECT_EQ(SUCCESS, ret);
1503 ret = AudioSystemManager::GetInstance()->IsStreamMute(AudioVolumeType::STREAM_ALL);
1504 EXPECT_EQ(true, ret);
1505
1506 audioRenderer->Release();
1507 }
1508
1509 /**
1510 * @tc.name : Test SetVolume API
1511 * @tc.number: SetVolumeTest_001
1512 * @tc.desc : Test setting volume of ringtone stream with max volume
1513 */
1514 HWTEST(AudioManagerUnitTest, SetVolumeTest_001, TestSize.Level1)
1515 {
1516 auto ret = AudioSystemManager::GetInstance()->SetVolume(AudioVolumeType::STREAM_RING, MAX_VOL);
1517 EXPECT_EQ(SUCCESS, ret);
1518
1519 int32_t volume = AudioSystemManager::GetInstance()->GetVolume(AudioVolumeType::STREAM_RING);
1520 EXPECT_EQ(MAX_VOL, volume);
1521 }
1522
1523 /**
1524 * @tc.name : Test SetVolume API
1525 * @tc.number: SetVolumeTest_002
1526 * @tc.desc : Test setting volume of ringtone stream with min volume
1527 */
1528 HWTEST(AudioManagerUnitTest, SetVolumeTest_002, TestSize.Level1)
1529 {
1530 auto ret = AudioSystemManager::GetInstance()->SetVolume(AudioVolumeType::STREAM_RING, MIN_VOL);
1531 EXPECT_EQ(SUCCESS, ret);
1532
1533 int32_t volume = AudioSystemManager::GetInstance()->GetVolume(AudioVolumeType::STREAM_RING);
1534 EXPECT_EQ(MIN_VOL, volume);
1535 }
1536
1537 /**
1538 * @tc.name : Test SetVolume API
1539 * @tc.number: SetVolumeTest_003
1540 * @tc.desc : Test setting volume of media stream with max volume
1541 */
1542 HWTEST(AudioManagerUnitTest, SetVolumeTest_003, TestSize.Level1)
1543 {
1544 auto ret = AudioSystemManager::GetInstance()->SetVolume(AudioVolumeType::STREAM_MUSIC, MAX_VOL);
1545 EXPECT_EQ(SUCCESS, ret);
1546
1547 int32_t mediaVol = AudioSystemManager::GetInstance()->GetVolume(AudioVolumeType::STREAM_MUSIC);
1548 EXPECT_EQ(MAX_VOL, mediaVol);
1549
1550 int32_t ringVolume = AudioSystemManager::GetInstance()->GetVolume(AudioVolumeType::STREAM_RING);
1551 EXPECT_EQ(MIN_VOL, ringVolume);
1552 }
1553
1554 /**
1555 * @tc.name : Test SetVolume API
1556 * @tc.number: SetVolumeTest_004
1557 * @tc.desc : Test setting volume of default stream with max volume
1558 */
1559 HWTEST(AudioManagerUnitTest, SetVolumeTest_004, TestSize.Level1)
1560 {
1561 auto ret = AudioSystemManager::GetInstance()->SetVolume(AudioVolumeType::STREAM_DEFAULT, MAX_VOL);
1562 EXPECT_LT(ret, SUCCESS);
1563 int32_t mediaVol = AudioSystemManager::GetInstance()->GetVolume(AudioVolumeType::STREAM_DEFAULT);
1564 EXPECT_LT(mediaVol, SUCCESS);
1565 }
1566
1567 /**
1568 * @tc.name : Test SetRingerModeCallbak API
1569 * @tc.number: SetRingerModeCallbak_001
1570 * @tc.desc : Test setting of callback to nullptr
1571 */
1572 HWTEST(AudioManagerUnitTest, SetRingerModeCallbak_001, TestSize.Level1)
1573 {
1574 int32_t clientId = 1;
1575 std::shared_ptr<AudioRingerModeCallback> callback = nullptr;
1576 auto ret = AudioSystemManager::GetInstance()->SetRingerModeCallback(clientId, callback);
1577 EXPECT_LT(ret, SUCCESS);
1578 }
1579
1580 /**
1581 * @tc.name : Test SetRingerMode API
1582 * @tc.number: SetRingerModeTest_001
1583 * @tc.desc : Test setting of ringer mode to SILENT
1584 */
1585 HWTEST(AudioManagerUnitTest, SetRingerModeTest_001, TestSize.Level1)
1586 {
1587 auto ret = AudioSystemManager::GetInstance()->SetRingerMode(AudioRingerMode::RINGER_MODE_SILENT);
1588 EXPECT_EQ(SUCCESS, ret);
1589
1590 AudioRingerMode ringerMode = AudioSystemManager::GetInstance()->GetRingerMode();
1591 EXPECT_EQ(ringerMode, AudioRingerMode::RINGER_MODE_SILENT);
1592 }
1593
1594 /**
1595 * @tc.name : Test SetRingerMode API
1596 * @tc.number: SetRingerModeTest_002
1597 * @tc.desc : Test setting of ringer mode to NORMAL
1598 */
1599 HWTEST(AudioManagerUnitTest, SetRingerModeTest_002, TestSize.Level1)
1600 {
1601 auto ret = AudioSystemManager::GetInstance()->SetRingerMode(AudioRingerMode::RINGER_MODE_NORMAL);
1602 EXPECT_EQ(SUCCESS, ret);
1603
1604 AudioRingerMode ringerMode = AudioSystemManager::GetInstance()->GetRingerMode();
1605 EXPECT_EQ(ringerMode, AudioRingerMode::RINGER_MODE_NORMAL);
1606 }
1607
1608 /**
1609 * @tc.name : Test SetRingerMode API
1610 * @tc.number: SetRingerModeTest_003
1611 * @tc.desc : Test setting of ringer mode to VIBRATE
1612 */
1613 HWTEST(AudioManagerUnitTest, SetRingerModeTest_003, TestSize.Level1)
1614 {
1615 auto ret = AudioSystemManager::GetInstance()->SetRingerMode(AudioRingerMode::RINGER_MODE_VIBRATE);
1616 EXPECT_EQ(SUCCESS, ret);
1617
1618 AudioRingerMode ringerMode = AudioSystemManager::GetInstance()->GetRingerMode();
1619 EXPECT_EQ(ringerMode, AudioRingerMode::RINGER_MODE_VIBRATE);
1620 }
1621
1622 /**
1623 * @tc.name : Test SetMicrophoneMute API
1624 * @tc.number: SetMicrophoneMute_001
1625 * @tc.desc : Test muting of microphone to true
1626 */
1627 HWTEST(AudioManagerUnitTest, SetMicrophoneMute_001, TestSize.Level1)
1628 {
1629 int32_t ret = AudioSystemManager::GetInstance()->SetMicrophoneMute(true);
1630 EXPECT_EQ(SUCCESS, ret);
1631
1632 bool isMicrophoneMuted = AudioSystemManager::GetInstance()->IsMicrophoneMute();
1633 EXPECT_EQ(isMicrophoneMuted, true);
1634 }
1635
1636 /**
1637 * @tc.name : Test SetMicrophoneMute API
1638 * @tc.number: SetMicrophoneMute_002
1639 * @tc.desc : Test muting of microphone to false
1640 */
1641 HWTEST(AudioManagerUnitTest, SetMicrophoneMute_002, TestSize.Level1)
1642 {
1643 int32_t ret = AudioSystemManager::GetInstance()->SetMicrophoneMute(false);
1644 EXPECT_EQ(SUCCESS, ret);
1645
1646 bool isMicrophoneMuted = AudioSystemManager::GetInstance()->IsMicrophoneMute();
1647 EXPECT_EQ(isMicrophoneMuted, false);
1648 }
1649
1650 /**
1651 * @tc.name : Test SetMute API
1652 * @tc.number: SetMute_001
1653 * @tc.desc : Test mute functionality of ring stream
1654 */
1655 HWTEST(AudioManagerUnitTest, SetMute_001, TestSize.Level1)
1656 {
1657 int32_t ret = AudioSystemManager::GetInstance()->SetMute(AudioVolumeType::STREAM_RING, true);
1658 EXPECT_EQ(SUCCESS, ret);
1659 }
1660
1661 /**
1662 * @tc.name : Test SetMute API
1663 * @tc.number: SetMute_002
1664 * @tc.desc : Test unmute functionality of ring stream
1665 */
1666 HWTEST(AudioManagerUnitTest, SetMute_002, TestSize.Level1)
1667 {
1668 int32_t ret = AudioSystemManager::GetInstance()->SetMute(AudioVolumeType::STREAM_RING, false);
1669 EXPECT_EQ(SUCCESS, ret);
1670 }
1671
1672 /**
1673 * @tc.name : Test SetMute API
1674 * @tc.number: SetMute_003
1675 * @tc.desc : Test mute functionality of music stream
1676 */
1677 HWTEST(AudioManagerUnitTest, SetMute_003, TestSize.Level1)
1678 {
1679 int32_t ret = AudioSystemManager::GetInstance()->SetMute(AudioVolumeType::STREAM_MUSIC, true);
1680 EXPECT_EQ(SUCCESS, ret);
1681 }
1682
1683 /**
1684 * @tc.name : Test SetMute API
1685 * @tc.number: SetMute_004
1686 * @tc.desc : Test unmute functionality of music stream
1687 */
1688 HWTEST(AudioManagerUnitTest, SetMute_004, TestSize.Level1)
1689 {
1690 int32_t ret = AudioSystemManager::GetInstance()->SetMute(AudioVolumeType::STREAM_MUSIC, false);
1691 EXPECT_EQ(SUCCESS, ret);
1692 }
1693
1694 /**
1695 * @tc.name : Test SetMute API
1696 * @tc.number: SetMute_005
1697 * @tc.desc : Test mute functionality of default stream
1698 */
1699 HWTEST(AudioManagerUnitTest, SetMute_005, TestSize.Level1)
1700 {
1701 int32_t ret = AudioSystemManager::GetInstance()->SetMute(AudioVolumeType::STREAM_DEFAULT, true);
1702 EXPECT_LT(ret, SUCCESS);
1703 }
1704
1705 /**
1706 * @tc.name : Test SetMute API
1707 * @tc.number: SetMute_006
1708 * @tc.desc : Test unmute functionality of default stream
1709 */
1710 HWTEST(AudioManagerUnitTest, SetMute_006, TestSize.Level1)
1711 {
1712 int32_t ret = AudioSystemManager::GetInstance()->SetMute(AudioVolumeType::STREAM_DEFAULT, false);
1713 EXPECT_LT(ret, SUCCESS);
1714 }
1715
1716 /**
1717 * @tc.name : SetLowPowerVolume_001
1718 * @tc.desc : Test set the volume discount coefficient of a single stream
1719 * @tc.type : FUNC
1720 * @tc.require : issueI5NXAE
1721 */
1722 HWTEST(AudioManagerUnitTest, SetLowPowerVolume_001, TestSize.Level1)
1723 {
1724 int32_t streamId = 0;
1725 vector<unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
1726 AudioRendererOptions rendererOptions = {};
1727 AppInfo appInfo = {};
1728 appInfo.appUid = static_cast<int32_t>(getuid());
1729 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
1730 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
1731 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
1732 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
1733 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
1734 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
1735 rendererOptions.rendererInfo.rendererFlags = 0;
1736
1737 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions, appInfo);
1738 ASSERT_NE(nullptr, audioRenderer);
1739 int32_t ret = AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
1740 EXPECT_EQ(SUCCESS, ret);
1741
1742 for (auto it = audioRendererChangeInfos.begin(); it != audioRendererChangeInfos.end(); it++) {
1743 AudioRendererChangeInfo audioRendererChangeInfos_ = **it;
1744 if (audioRendererChangeInfos_.clientUID == appInfo.appUid) {
1745 streamId = audioRendererChangeInfos_.sessionId;
1746 }
1747 }
1748 ASSERT_NE(0, streamId);
1749
1750 ret = AudioSystemManager::GetInstance()->SetLowPowerVolume(streamId, DISCOUNT_VOLUME);
1751 EXPECT_EQ(SUCCESS, ret);
1752
1753 audioRenderer->Release();
1754 }
1755
1756 /**
1757 * @tc.name : SetLowPowerVolume_002
1758 * @tc.desc : Test set the volume invalid value
1759 * @tc.type : FUNC
1760 * @tc.require : issueI5NXAE
1761 */
1762 HWTEST(AudioManagerUnitTest, SetLowPowerVolume_002, TestSize.Level1)
1763 {
1764 int32_t streamId = 0;
1765 vector<unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
1766 AudioRendererOptions rendererOptions = {};
1767 AppInfo appInfo = {};
1768 appInfo.appUid = static_cast<int32_t>(getuid());
1769 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
1770 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
1771 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
1772 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
1773 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
1774 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
1775 rendererOptions.rendererInfo.rendererFlags = 0;
1776
1777 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions, appInfo);
1778 ASSERT_NE(nullptr, audioRenderer);
1779 int32_t ret = AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
1780 EXPECT_EQ(SUCCESS, ret);
1781
1782 for (auto it = audioRendererChangeInfos.begin(); it != audioRendererChangeInfos.end(); it++) {
1783 AudioRendererChangeInfo audioRendererChangeInfos_ = **it;
1784 if (audioRendererChangeInfos_.clientUID == appInfo.appUid) {
1785 streamId = audioRendererChangeInfos_.sessionId;
1786 }
1787 }
1788 ASSERT_NE(0, streamId);
1789
1790 ret = AudioSystemManager::GetInstance()->SetLowPowerVolume(streamId, INVALID_VOLUME);
1791 EXPECT_LT(ret, SUCCESS);
1792
1793 audioRenderer->Release();
1794 }
1795
1796 /**
1797 * @tc.name : Test SetLowPowerVolume API
1798 * @tc.number: SetLowPowerVolume_003
1799 * @tc.desc : Test function SetLowPowerVolume in the recording scene
1800 */
1801 HWTEST(AudioManagerUnitTest, SetLowPowerVolume_003, TestSize.Level1)
1802 {
1803 int32_t streamId = 0;
1804 vector<unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
1805 AudioCapturerOptions capturerOptions = {};
1806 AppInfo appInfo = {};
1807 appInfo.appUid = static_cast<int32_t>(getuid());
1808 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_8000;
1809 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
1810 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
1811 capturerOptions.streamInfo.channels = AudioChannel::MONO;
1812 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
1813 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
1814
1815 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions, appInfo);
1816 ASSERT_NE(nullptr, audioCapturer);
1817 int32_t ret = AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
1818 EXPECT_EQ(SUCCESS, ret);
1819
1820 for (auto it = audioCapturerChangeInfos.begin(); it != audioCapturerChangeInfos.end(); it++) {
1821 AudioCapturerChangeInfo audioCapturerChangeInfos_ = **it;
1822 if (audioCapturerChangeInfos_.clientUID == appInfo.appUid) {
1823 streamId = audioCapturerChangeInfos_.sessionId;
1824 }
1825 }
1826 ASSERT_NE(0, streamId);
1827
1828 ret = AudioSystemManager::GetInstance()->SetLowPowerVolume(streamId, DISCOUNT_VOLUME);
1829 EXPECT_EQ(SUCCESS, ret);
1830
1831 audioCapturer->Release();
1832 }
1833
1834 /**
1835 * @tc.name : GetLowPowerVolume_001
1836 * @tc.desc : Test get the volume discount coefficient of a single stream
1837 * @tc.type : FUNC
1838 * @tc.require : issueI5NXAE
1839 */
1840 HWTEST(AudioManagerUnitTest, GetLowPowerVolume_001, TestSize.Level1)
1841 {
1842 int32_t streamId = 0;
1843 vector<unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
1844 AudioRendererOptions rendererOptions = {};
1845 AppInfo appInfo = {};
1846 appInfo.appUid = static_cast<int32_t>(getuid());
1847 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
1848 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
1849 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
1850 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
1851 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
1852 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
1853 rendererOptions.rendererInfo.rendererFlags = 0;
1854
1855 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions, appInfo);
1856 ASSERT_NE(nullptr, audioRenderer);
1857 int32_t ret = AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
1858 EXPECT_EQ(SUCCESS, ret);
1859
1860 for (auto it = audioRendererChangeInfos.begin(); it != audioRendererChangeInfos.end(); it++) {
1861 AudioRendererChangeInfo audioRendererChangeInfos_ = **it;
1862 if (audioRendererChangeInfos_.clientUID == appInfo.appUid) {
1863 streamId = audioRendererChangeInfos_.sessionId;
1864 }
1865 }
1866 ASSERT_NE(0, streamId);
1867
1868 float vol = AudioSystemManager::GetInstance()->GetLowPowerVolume(streamId);
1869 if (vol < VOLUME_MIN || vol > VOLUME_MAX) {
1870 ret = ERROR;
1871 } else {
1872 ret = SUCCESS;
1873 }
1874 EXPECT_EQ(SUCCESS, ret);
1875 audioRenderer->Release();
1876 }
1877
1878 /**
1879 * @tc.name : Test GetLowPowerVolume API
1880 * @tc.number: GetLowPowerVolume_002
1881 * @tc.desc : Test function GetLowPowerVolume in the recording scene
1882 */
1883 HWTEST(AudioManagerUnitTest, GetLowPowerVolume_002, TestSize.Level1)
1884 {
1885 int32_t streamId = 0;
1886 vector<unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
1887 AudioCapturerOptions capturerOptions = {};
1888 AppInfo appInfo = {};
1889 appInfo.appUid = static_cast<int32_t>(getuid());
1890 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_8000;
1891 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
1892 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
1893 capturerOptions.streamInfo.channels = AudioChannel::MONO;
1894 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
1895 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
1896
1897 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions, appInfo);
1898 ASSERT_NE(nullptr, audioCapturer);
1899 int32_t ret = AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
1900 EXPECT_EQ(SUCCESS, ret);
1901
1902 for (auto it = audioCapturerChangeInfos.begin(); it != audioCapturerChangeInfos.end(); it++) {
1903 AudioCapturerChangeInfo audioCapturerChangeInfos_ = **it;
1904 if (audioCapturerChangeInfos_.clientUID == appInfo.appUid) {
1905 streamId = audioCapturerChangeInfos_.sessionId;
1906 }
1907 }
1908 ASSERT_NE(0, streamId);
1909
1910 float vol = AudioSystemManager::GetInstance()->GetLowPowerVolume(streamId);
1911 if (vol < VOLUME_MIN || vol > VOLUME_MAX) {
1912 ret = ERROR;
1913 } else {
1914 ret = SUCCESS;
1915 }
1916 EXPECT_EQ(SUCCESS, ret);
1917 audioCapturer->Release();
1918 }
1919
1920 /**
1921 * @tc.name : GetSingleStreamVolume_001
1922 * @tc.desc : Test get single stream volume.
1923 * @tc.type : FUNC
1924 * @tc.require : issueI5NXAE
1925 */
1926 HWTEST(AudioManagerUnitTest, GetSingleStreamVolume_001, TestSize.Level1)
1927 {
1928 int32_t streamId = 0;
1929 vector<unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
1930 AudioRendererOptions rendererOptions = {};
1931 AppInfo appInfo = {};
1932 appInfo.appUid = static_cast<int32_t>(getuid());
1933 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
1934 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
1935 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
1936 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
1937 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
1938 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
1939 rendererOptions.rendererInfo.rendererFlags = 0;
1940
1941 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions, appInfo);
1942 ASSERT_NE(nullptr, audioRenderer);
1943 int32_t ret = AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
1944 EXPECT_EQ(SUCCESS, ret);
1945
1946 for (auto it = audioRendererChangeInfos.begin(); it != audioRendererChangeInfos.end(); it++) {
1947 AudioRendererChangeInfo audioRendererChangeInfos_ = **it;
1948 if (audioRendererChangeInfos_.clientUID == appInfo.appUid) {
1949 streamId = audioRendererChangeInfos_.sessionId;
1950 }
1951 }
1952 ASSERT_NE(0, streamId);
1953
1954 float vol = AudioSystemManager::GetInstance()->GetSingleStreamVolume(streamId);
1955 if (vol < VOLUME_MIN || vol > VOLUME_MAX) {
1956 ret = ERROR;
1957 } else {
1958 ret = SUCCESS;
1959 }
1960 EXPECT_EQ(SUCCESS, ret);
1961 audioRenderer->Release();
1962 }
1963
1964 /**
1965 * @tc.name : Test GetSingleStreamVolume API
1966 * @tc.number: GetSingleStreamVolume_002
1967 * @tc.desc : Test function GetSingleStreamVolume in the recording scene
1968 */
1969 HWTEST(AudioManagerUnitTest, GetSingleStreamVolume_002, TestSize.Level1)
1970 {
1971 int32_t streamId = 0;
1972 vector<unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfo;
1973 AudioCapturerOptions capturerOptions = {};
1974 AppInfo appInfo = {};
1975 appInfo.appUid = static_cast<int32_t>(getuid());
1976 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_8000;
1977 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
1978 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
1979 capturerOptions.streamInfo.channels = AudioChannel::MONO;
1980 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
1981 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
1982
1983 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions, appInfo);
1984 ASSERT_NE(nullptr, audioCapturer);
1985 int32_t ret = AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfo);
1986 EXPECT_EQ(SUCCESS, ret);
1987
1988 for (auto it = audioCapturerChangeInfo.begin(); it != audioCapturerChangeInfo.end(); it++) {
1989 AudioCapturerChangeInfo audioCapturerChangeInfo_ = **it;
1990 if (audioCapturerChangeInfo_.clientUID == appInfo.appUid) {
1991 streamId = audioCapturerChangeInfo_.sessionId;
1992 }
1993 }
1994 ASSERT_NE(0, streamId);
1995
1996 float vol = AudioSystemManager::GetInstance()->GetSingleStreamVolume(streamId);
1997 if (vol < VOLUME_MIN || vol > VOLUME_MAX) {
1998 ret = ERROR;
1999 } else {
2000 ret = SUCCESS;
2001 }
2002 EXPECT_EQ(SUCCESS, ret);
2003 audioCapturer->Release();
2004 }
2005
2006 /**
2007 * @tc.name : Test SetPauseOrResumeStream API
2008 * @tc.number: SetPauseOrResumeStream_001
2009 * @tc.desc : Test Puase functionality of media stream
2010 */
2011 HWTEST(AudioManagerUnitTest, SetPauseOrResumeStream_001, TestSize.Level1)
2012 {
2013 int32_t ret = AudioSystemManager::GetInstance()->UpdateStreamState(0,
2014 StreamSetState::STREAM_PAUSE, AudioStreamType::STREAM_MEDIA);
2015 EXPECT_EQ(SUCCESS, ret);
2016 }
2017
2018 /**
2019 * @tc.name : Test SetPauseOrResumeStream API
2020 * @tc.number: SetPauseOrResumeStream_002
2021 * @tc.desc : Test Resume functionality of media stream
2022 */
2023 HWTEST(AudioManagerUnitTest, SetPauseOrResumeStream_002, TestSize.Level1)
2024 {
2025 int32_t ret = AudioSystemManager::GetInstance()->UpdateStreamState(0,
2026 StreamSetState::STREAM_RESUME, AudioStreamType::STREAM_MEDIA);
2027 EXPECT_EQ(SUCCESS, ret);
2028 }
2029 } // namespace AudioStandard
2030 } // namespace OHOS
2031