1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "audio_policy_utils.h"
16 #include "audio_adapter_manager_unit_test.h"
17 #include "audio_stream_descriptor.h"
18 #include "audio_interrupt_service.h"
19 #include "audio_adapter_manager_handler.h"
20
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace AudioStandard {
25
26 static AudioAdapterManager *audioAdapterManager_;
27
SetUpTestCase(void)28 void AudioAdapterManagerUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)29 void AudioAdapterManagerUnitTest::TearDownTestCase(void) {}
30
GetTnterruptServiceTest()31 std::shared_ptr<AudioInterruptService> GetTnterruptServiceTest()
32 {
33 return std::make_shared<AudioInterruptService>();
34 }
35 /**
36 * @tc.name: IsAppVolumeMute_001
37 * @tc.desc: Test IsAppVolumeMute when owned is true.
38 * @tc.type: FUNC
39 * @tc.require: #I5Y4MZ
40 */
41 HWTEST_F(AudioAdapterManagerUnitTest, IsAppVolumeMute_001, TestSize.Level1)
42 {
43 int32_t appUid = 12345;
44 bool owned = true;
45 bool isMute = true;
46 bool result = AudioAdapterManager::GetInstance().IsAppVolumeMute(appUid, owned, isMute);
47 EXPECT_EQ(result, SUCCESS);
48 }
49
50 /**
51 * @tc.name: IsAppVolumeMute_002
52 * @tc.desc: Test IsAppVolumeMute when owned is false.
53 * @tc.type: FUNC
54 * @tc.require: #I5Y4MZ
55 */
56 HWTEST_F(AudioAdapterManagerUnitTest, IsAppVolumeMute_002, TestSize.Level1)
57 {
58 int32_t appUid = 12345;
59 bool owned = false;
60 bool isMute = true;
61 bool result = AudioAdapterManager::GetInstance().IsAppVolumeMute(appUid, owned, isMute);
62 EXPECT_EQ(result, SUCCESS);
63 }
64
65 /**
66 * @tc.name: SaveSpecifiedDeviceVolume_001
67 * @tc.desc: Test SaveSpecifiedDeviceVolume when deviceType is different from currentActiveDevice.
68 * @tc.type: FUNC
69 * @tc.require: #I5Y4MZ
70 */
71 HWTEST_F(AudioAdapterManagerUnitTest, SaveSpecifiedDeviceVolume_001, TestSize.Level1)
72 {
73 audioAdapterManager_->Init();
74 audioAdapterManager_->currentActiveDevice_.deviceType_ = DEVICE_TYPE_SPEAKER;
75 AudioStreamType streamType = STREAM_MUSIC;
76 int32_t volumeLevel = 5;
77 DeviceType deviceType = DEVICE_TYPE_WIRED_HEADSET;
78 int32_t minVolume = audioAdapterManager_->GetMinVolumeLevel(streamType);
79 int32_t maxVolume = audioAdapterManager_->GetMaxVolumeLevel(streamType);
80 ASSERT_TRUE(volumeLevel >= minVolume && volumeLevel <= maxVolume);
81 int32_t result = audioAdapterManager_->SaveSpecifiedDeviceVolume(streamType, volumeLevel, deviceType);
82 ASSERT_EQ(result, 0);
83 }
84
85 /**
86 * @tc.name: SaveSpecifiedDeviceVolume_002
87 * @tc.desc: Test SaveSpecifiedDeviceVolume when deviceType is same as currentActiveDevice.
88 * @tc.type: FUNC
89 * @tc.require: #I5Y4MZ
90 */
91 HWTEST_F(AudioAdapterManagerUnitTest, SaveSpecifiedDeviceVolume_002, TestSize.Level1)
92 {
93 audioAdapterManager_->currentActiveDevice_.deviceType_ = DEVICE_TYPE_WIRED_HEADSET;
94 AudioStreamType streamType = STREAM_MUSIC;
95 int32_t volumeLevel = 5;
96 DeviceType deviceType = DEVICE_TYPE_WIRED_HEADSET;
97 int32_t minVolume = audioAdapterManager_->GetMinVolumeLevel(streamType);
98 int32_t maxVolume = audioAdapterManager_->GetMaxVolumeLevel(streamType);
99 ASSERT_TRUE(volumeLevel >= minVolume && volumeLevel <= maxVolume);
100 int32_t result = audioAdapterManager_->SaveSpecifiedDeviceVolume(streamType, volumeLevel, deviceType);
101 ASSERT_EQ(result, 0);
102 }
103
104 /**
105 * @tc.name: HandleStreamMuteStatus_001
106 * @tc.desc: Test HandleStreamMuteStatus when deviceType is not DEVICE_TYPE_NONE.
107 * @tc.type: FUNC
108 * @tc.require: #I5Y4MZ
109 */
110 HWTEST_F(AudioAdapterManagerUnitTest, HandleStreamMuteStatus_001, TestSize.Level1)
111 {
112 AudioStreamType streamType = STREAM_MUSIC;
113 bool mute = true;
114 StreamUsage streamUsage = STREAM_USAGE_UNKNOWN;
115 DeviceType deviceType = DEVICE_TYPE_BLUETOOTH_A2DP;
116 AudioAdapterManager::GetInstance().HandleStreamMuteStatus(streamType, mute, streamUsage, deviceType);
117 EXPECT_TRUE(mute);
118 }
119
120 /**
121 * @tc.name: HandleStreamMuteStatus_002
122 * @tc.desc: Test HandleStreamMuteStatus when deviceType is DEVICE_TYPE_NONE.
123 * @tc.type: FUNC
124 * @tc.require: #I5Y4MZ
125 */
126 HWTEST_F(AudioAdapterManagerUnitTest, HandleStreamMuteStatus_002, TestSize.Level1)
127 {
128 AudioStreamType streamType = STREAM_MUSIC;
129 bool mute = true;
130 StreamUsage streamUsage = STREAM_USAGE_UNKNOWN;
131 DeviceType deviceType = DEVICE_TYPE_NONE;
132 AudioAdapterManager::GetInstance().HandleStreamMuteStatus(streamType, mute, streamUsage, deviceType);
133 EXPECT_TRUE(mute);
134 }
135
136 /**
137 * @tc.name: IsHandleStreamMute_001
138 * @tc.desc: Test IsHandleStreamMute when streamType is STREAM_VOICE_CALL.
139 * @tc.type: FUNC
140 * @tc.require: #I5Y4MZ
141 */
142 HWTEST_F(AudioAdapterManagerUnitTest, IsHandleStreamMute_001, TestSize.Level1)
143 {
144 AudioStreamType streamType = STREAM_VOICE_CALL;
145 bool mute = true;
146 StreamUsage streamUsage = STREAM_USAGE_UNKNOWN;
147 int32_t SUCCESS = 0;
148 int32_t result = audioAdapterManager_->IsHandleStreamMute(streamType, mute, streamUsage);
149 EXPECT_EQ(result, SUCCESS);
150 }
151
152 /**
153 * @tc.name: IsHandleStreamMute_002
154 * @tc.desc: Test IsHandleStreamMute when streamType is STREAM_VOICE_CALL.
155 * @tc.type: FUNC
156 * @tc.require: #I5Y4MZ
157 */
158 HWTEST_F(AudioAdapterManagerUnitTest, IsHandleStreamMute_002, TestSize.Level1)
159 {
160 AudioStreamType streamType = STREAM_VOICE_CALL;
161 bool mute = false;
162 StreamUsage streamUsage = STREAM_USAGE_UNKNOWN;
163 int32_t result = audioAdapterManager_->IsHandleStreamMute(streamType, mute, streamUsage);
164 EXPECT_EQ(result, ERROR);
165 }
166
167 /**
168 * @tc.name: SetOffloadVolume_001
169 * @tc.desc: Test SetOffloadVolume.
170 * @tc.type: FUNC
171 * @tc.require: #I5Y4MZ
172 */
173 HWTEST_F(AudioAdapterManagerUnitTest, SetOffloadVolume_001, TestSize.Level1)
174 {
175 audioAdapterManager_->Init();
176 AudioStreamType streamType = STREAM_MUSIC;
177 float volumeDb = 1;
178 audioAdapterManager_->SetOffloadVolume(streamType, volumeDb, "offload");
179
180 streamType = STREAM_SPEECH;
181 audioAdapterManager_->SetOffloadVolume(streamType, volumeDb, "offload");
182
183 streamType = STREAM_SYSTEM;
184 audioAdapterManager_->currentActiveDevice_.deviceType_ = DEVICE_TYPE_DP;
185 audioAdapterManager_->SetOffloadVolume(streamType, volumeDb, "offload");
186
187 streamType = STREAM_SYSTEM;
188 audioAdapterManager_->currentActiveDevice_.deviceType_ = DEVICE_TYPE_SPEAKER;
189 auto interruptServiceTest = GetTnterruptServiceTest();
190 audioAdapterManager_->audioServerProxy_ = interruptServiceTest->GetAudioServerProxy();
191 ASSERT_NE(audioAdapterManager_->audioServerProxy_, nullptr);
192 audioAdapterManager_->SetOffloadVolume(streamType, volumeDb, "offload");
193 }
194
195 /**
196 * @tc.name: SetOffloadSessionId_001
197 * @tc.desc: Test SetOffloadSessionId.
198 * @tc.type: FUNC
199 * @tc.require: #I5Y4MZ
200 */
201 HWTEST_F(AudioAdapterManagerUnitTest, SetOffloadSessionId_001, TestSize.Level1)
202 {
203 uint32_t sessionId = MIN_STREAMID - 1;
204 AudioAdapterManager::GetInstance().SetOffloadSessionId(sessionId);
205
206 sessionId = MAX_STREAMID + 1;
207 AudioAdapterManager::GetInstance().SetOffloadSessionId(sessionId);
208
209 sessionId = MIN_STREAMID + 1;
210 AudioAdapterManager::GetInstance().SetOffloadSessionId(sessionId);
211 }
212
213 /**
214 * @tc.name: SetVolumeForSwitchDevice_001
215 * @tc.desc: Test SetVolumeForSwitchDevice
216 * @tc.type: FUNC
217 * @tc.require: #I5Y4MZ
218 */
219 HWTEST_F(AudioAdapterManagerUnitTest, SetVolumeForSwitchDevice_001, TestSize.Level1)
220 {
221 AudioDeviceDescriptor deviceDescriptor;
222 deviceDescriptor.deviceType_ = DEVICE_TYPE_SPEAKER;
223 deviceDescriptor.networkId_ = "LocalDevice";
224
225 auto audioAdapterManager = std::make_shared<AudioAdapterManager>();
226 audioAdapterManager->SetVolumeForSwitchDevice(deviceDescriptor);
227 EXPECT_EQ(audioAdapterManager->currentActiveDevice_.deviceType_, DEVICE_TYPE_SPEAKER);
228
229 deviceDescriptor.networkId_ = "RemoteDevice";
230 audioAdapterManager->SetVolumeForSwitchDevice(deviceDescriptor);
231 EXPECT_EQ(audioAdapterManager->currentActiveDevice_.deviceType_, DEVICE_TYPE_SPEAKER);
232
233 deviceDescriptor.networkId_ = "LocalDevice";
234 audioAdapterManager->SetVolumeForSwitchDevice(deviceDescriptor);
235 EXPECT_EQ(audioAdapterManager->currentActiveDevice_.deviceType_, DEVICE_TYPE_SPEAKER);
236
237 deviceDescriptor.deviceType_ = DEVICE_TYPE_DP;
238 audioAdapterManager->SetVolumeForSwitchDevice(deviceDescriptor);
239 EXPECT_EQ(audioAdapterManager->currentActiveDevice_.deviceType_, DEVICE_TYPE_DP);
240
241 deviceDescriptor.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP;
242 audioAdapterManager->SetVolumeForSwitchDevice(deviceDescriptor);
243 EXPECT_EQ(audioAdapterManager->currentActiveDevice_.deviceType_, DEVICE_TYPE_BLUETOOTH_A2DP);
244
245 deviceDescriptor.deviceType_ = DEVICE_TYPE_BLUETOOTH_SCO;
246 audioAdapterManager->SetVolumeForSwitchDevice(deviceDescriptor);
247 EXPECT_EQ(audioAdapterManager->currentActiveDevice_.deviceType_, DEVICE_TYPE_BLUETOOTH_SCO);
248 }
249
250 /**
251 * @tc.name: SetAdjustVolumeForZone_001
252 * @tc.desc: Test SetAdjustVolumeForZone
253 * @tc.type: FUNC
254 * @tc.require: #I5Y4MZ
255 */
256 HWTEST_F(AudioAdapterManagerUnitTest, SetAdjustVolumeForZone_001, TestSize.Level1)
257 {
258 auto audioAdapterManager = std::make_shared<AudioAdapterManager>();
259 auto ret = audioAdapterManager->SetAdjustVolumeForZone(0);
260 EXPECT_EQ(ret, SUCCESS);
261
262 std::vector<std::shared_ptr<AudioDeviceDescriptor>> devices;
263 std::shared_ptr<AudioDeviceDescriptor> desc =
264 std::make_shared<AudioDeviceDescriptor>(DEVICE_TYPE_REMOTE_CAST, OUTPUT_DEVICE);
265 desc->networkId_ = "LocalDevice";
266 devices.push_back(desc);
267 AudioZoneService::GetInstance().BindDeviceToAudioZone(zoneId1_, devices);
268 AudioConnectedDevice::GetInstance().AddConnectedDevice(desc);
269 AudioZoneService::GetInstance().UpdateDeviceFromGlobalForAllZone(desc);
270
271 ret = audioAdapterManager->SetAdjustVolumeForZone(zoneId2_);
272 EXPECT_NE(ret, SUCCESS);
273
274 audioAdapterManager->volumeDataExtMaintainer_[desc->GetKey()] = std::make_shared<VolumeDataMaintainer>();
275 ret = audioAdapterManager->SetAdjustVolumeForZone(zoneId2_);
276 EXPECT_NE(ret, SUCCESS);
277
278 audioAdapterManager->volumeDataExtMaintainer_.clear();
279 desc->networkId_ = "RemoteDevice";
280 desc->deviceType_ = DEVICE_TYPE_SPEAKER;
281
282 audioAdapterManager->volumeDataExtMaintainer_[desc->GetKey()] = std::make_shared<VolumeDataMaintainer>();
283 ret = audioAdapterManager->SetAdjustVolumeForZone(zoneId2_);
284 EXPECT_NE(ret, SUCCESS);
285 }
286
287 /**
288 * @tc.name: SetSystemVolumeLevel_001
289 * @tc.desc: Test CheckAndUpdateRemoteDeviceVolume
290 * @tc.type: FUNC
291 * @tc.require: #I5Y4MZ
292 */
293 HWTEST_F(AudioAdapterManagerUnitTest, SetSystemVolumeLevel_001, TestSize.Level1)
294 {
295 AudioDeviceDescriptor deviceDescriptor;
296 deviceDescriptor.deviceType_ = DEVICE_TYPE_SPEAKER;
297 deviceDescriptor.networkId_ = "LocalDevice";
298 int32_t testVolumeLevel = 10;
299 auto audioAdapterManager = std::make_shared<AudioAdapterManager>();
300 audioAdapterManager->SetActiveDeviceDescriptor(deviceDescriptor);
301 audioAdapterManager->SetSystemVolumeLevel(STREAM_MUSIC, testVolumeLevel);
302 EXPECT_EQ(audioAdapterManager->volumeDataMaintainer_.GetStreamVolume(STREAM_MUSIC), testVolumeLevel);
303
304 deviceDescriptor.networkId_ = "RemoteDevice";
305 testVolumeLevel = 5;
306 audioAdapterManager->SetActiveDeviceDescriptor(deviceDescriptor);
307 audioAdapterManager->SetSystemVolumeLevel(STREAM_MUSIC, testVolumeLevel);
308 EXPECT_EQ(audioAdapterManager->volumeDataMaintainer_.GetStreamVolume(STREAM_MUSIC), testVolumeLevel);
309 }
310
311 /**
312 * @tc.name: SetAbsVolumeMute_001
313 * @tc.desc: Test SetAbsVolumeMute
314 * @tc.type: FUNC
315 * @tc.require: #ICDC94
316 */
317 HWTEST_F(AudioAdapterManagerUnitTest, SetAbsVolumeMute_001, TestSize.Level1)
318 {
319 audioAdapterManager_->currentActiveDevice_.deviceType_ = DEVICE_TYPE_NEARLINK;
320 bool mute = true;
321
322 audioAdapterManager_->SetAbsVolumeMute(mute);
323 int32_t ret = audioAdapterManager_->SetVolumeDb(STREAM_MUSIC);
324
325 EXPECT_EQ(ret, SUCCESS);
326 }
327
328 /**
329 * @tc.name: UpdateSinkArgs_001
330 * @tc.desc: Test UpdateSinkArgs all args have value
331 * @tc.type: FUNC
332 * @tc.require: #ICDC94
333 */
334 HWTEST_F(AudioAdapterManagerUnitTest, UpdateSinkArgs_001, TestSize.Level1)
335 {
336 AudioModuleInfo info;
337 info.name = "hello";
338 info.adapterName = "world";
339 info.className = "CALSS";
340 info.fileName = "sink.so";
341 info.sinkLatency = "300ms";
342 info.networkId = "ASD**G124";
343 info.deviceType = "AE00";
344 info.extra = "1:13:2";
345 info.needEmptyChunk = true;
346 std::string ret {};
347 AudioAdapterManager::UpdateSinkArgs(info, ret);
348 EXPECT_EQ(ret,
349 " sink_name=hello"
350 " adapter_name=world"
351 " device_class=CALSS"
352 " file_path=sink.so"
353 " sink_latency=300ms"
354 " network_id=ASD**G124"
355 " device_type=AE00"
356 " split_mode=1:13:2"
357 " need_empty_chunk=1");
358 }
359
360 /**
361 * @tc.name: UpdateSinkArgs_002
362 * @tc.desc: Test UpdateSinkArgs no value: network_id
363 * @tc.type: FUNC
364 * @tc.require: #ICDC94
365 */
366 HWTEST_F(AudioAdapterManagerUnitTest, UpdateSinkArgs_002, TestSize.Level1)
367 {
368 AudioModuleInfo info;
369 std::string ret {};
370 AudioAdapterManager::UpdateSinkArgs(info, ret);
371 EXPECT_EQ(ret, " network_id=LocalDevice");
372 }
373
374 /**
375 * @tc.name: Test AudioAdapterManager
376 * @tc.desc: HandleHearingAidVolume_001
377 * @tc.type: FUNC
378 * @tc.require: #ICDC94
379 */
380 HWTEST_F(AudioAdapterManagerUnitTest, HandleHearingAidVolume_001, TestSize.Level1)
381 {
382 audioAdapterManager_->currentActiveDevice_.deviceType_ = DEVICE_TYPE_HEARING_AID;
383 AudioStreamType streamType = STREAM_MUSIC;
384 int defaultVolume =
385 static_cast<int>(std::ceil(audioAdapterManager_->GetMaxVolumeLevel(STREAM_MUSIC) * 0.8));
386 audioAdapterManager_->HandleHearingAidVolume(streamType);
387 EXPECT_EQ(audioAdapterManager_->volumeDataMaintainer_.GetStreamVolume(STREAM_MUSIC), defaultVolume);
388 }
389
390 /**
391 * @tc.name: Test SetInnerStreamMute
392 * @tc.desc: SetInnerStreamMute_001
393 * @tc.type: FUNC
394 * @tc.require: #ICDC94
395 */
396 HWTEST_F(AudioAdapterManagerUnitTest, SetInnerStreamMute_001, TestSize.Level1)
397 {
398 auto audioAdapterManager = std::make_shared<AudioAdapterManager>();
399 audioAdapterManager->audioPolicyServerHandler_ = std::make_shared<AudioPolicyServerHandler>();
400 AudioStreamType streamType = STREAM_MUSIC;
401 bool mute = true;
402 StreamUsage streamUsage = STREAM_USAGE_MUSIC;
403 audioAdapterManager->SetInnerStreamMute(streamType, mute, streamUsage);
404 EXPECT_EQ(audioAdapterManager->GetStreamMute(streamType), mute);
405 }
406
407 /**
408 * @tc.name: Test SetInnerStreamMute
409 * @tc.desc: SetInnerStreamMute_002
410 * @tc.type: FUNC
411 * @tc.require: #ICDC94
412 */
413 HWTEST_F(AudioAdapterManagerUnitTest, SetInnerStreamMute_002, TestSize.Level4)
414 {
415 auto audioAdapterManager = std::make_shared<AudioAdapterManager>();
416 audioAdapterManager->currentActiveDevice_.deviceType_ = DEVICE_TYPE_NEARLINK;
417 AudioStreamType streamType = STREAM_MUSIC;
418 bool mute = true;
419 StreamUsage streamUsage = STREAM_USAGE_MUSIC;
420 audioAdapterManager->SetInnerStreamMute(streamType, mute, streamUsage);
421 EXPECT_EQ(audioAdapterManager->GetStreamMute(streamType), mute);
422 }
423
424 /**
425 * @tc.name: Test SetSystemVolumeDegree
426 * @tc.desc: SetSystemVolumeDegree_001
427 * @tc.type: FUNC
428 * @tc.require:
429 */
430 HWTEST_F(AudioAdapterManagerUnitTest, SetSystemVolumeDegree_001, TestSize.Level4)
431 {
432 auto audioAdapterManager = std::make_shared<AudioAdapterManager>();
433 ASSERT_NE(audioAdapterManager, nullptr);
434 AudioStreamType streamType = STREAM_MUSIC;
435 int32_t volumeDegree = 44;
436 auto ret = audioAdapterManager->SetSystemVolumeDegree(streamType, volumeDegree);
437 EXPECT_EQ(ret, SUCCESS);
438
439 ret = audioAdapterManager->SetSystemVolumeDegree(streamType, volumeDegree);
440 EXPECT_EQ(ret, SUCCESS);
441
442 ret = audioAdapterManager->GetSystemVolumeDegree(streamType);
443 EXPECT_EQ(ret, volumeDegree);
444
445 ret = audioAdapterManager->GetMinVolumeDegree(streamType);
446 EXPECT_EQ(ret, 0);
447 }
448
449 /**
450 * @tc.name: Test SetSleVoliceStatusFlag
451 * @tc.desc: SetSleVoliceStatusFlag_001
452 * @tc.type: FUNC
453 * @tc.require: #ICDC94
454 */
455 HWTEST_F(AudioAdapterManagerUnitTest, SetSleVoliceStatusFlag_001, TestSize.Level4)
456 {
457 auto audioAdapterManager = std::make_shared<AudioAdapterManager>();
458 audioAdapterManager->currentActiveDevice_.deviceType_ = DEVICE_TYPE_NEARLINK;
459 AudioStreamType streamType = STREAM_MUSIC;
460 audioAdapterManager->SetSleVoiceStatusFlag(false);
461 int32_t ret = audioAdapterManager->SetVolumeDb(streamType);
462 EXPECT_NE(ret, SUCCESS);
463 }
464
465 /**
466 * @tc.name: Test SetSleVoliceStatusFlag
467 * @tc.desc: SetSleVoliceStatusFlag_002
468 * @tc.type: FUNC
469 * @tc.require: #ICDC94
470 */
471 HWTEST_F(AudioAdapterManagerUnitTest, SetSleVoliceStatusFlag_002, TestSize.Level4)
472 {
473 auto audioAdapterManager = std::make_shared<AudioAdapterManager>();
474 audioAdapterManager->currentActiveDevice_.deviceType_ = DEVICE_TYPE_NEARLINK;
475 AudioStreamType streamType = STREAM_VOICE_CALL;
476 audioAdapterManager->SetSleVoiceStatusFlag(false);
477 int32_t ret = audioAdapterManager->SetVolumeDb(streamType);
478 EXPECT_NE(ret, SUCCESS);
479 }
480
481 /**
482 * @tc.name: Test SetSleVoliceStatusFlag
483 * @tc.desc: SetSleVoliceStatusFlag_003
484 * @tc.type: FUNC
485 * @tc.require: #ICDC94
486 */
487 HWTEST_F(AudioAdapterManagerUnitTest, SetSleVoliceStatusFlag_003, TestSize.Level4)
488 {
489 auto audioAdapterManager = std::make_shared<AudioAdapterManager>();
490 audioAdapterManager->currentActiveDevice_.deviceType_ = DEVICE_TYPE_NEARLINK;
491 AudioStreamType streamType = STREAM_MUSIC;
492 audioAdapterManager->SetSleVoiceStatusFlag(true);
493 int32_t ret = audioAdapterManager->SetVolumeDb(streamType);
494 EXPECT_NE(ret, SUCCESS);
495 }
496
497 /**
498 * @tc.name: Test SetSleVoliceStatusFlag
499 * @tc.desc: SetSleVoliceStatusFlag_004
500 * @tc.type: FUNC
501 * @tc.require: #ICDC94
502 */
503 HWTEST_F(AudioAdapterManagerUnitTest, SetSleVoliceStatusFlag_004, TestSize.Level4)
504 {
505 auto audioAdapterManager = std::make_shared<AudioAdapterManager>();
506 audioAdapterManager->currentActiveDevice_.deviceType_ = DEVICE_TYPE_NEARLINK;
507 AudioStreamType streamType = STREAM_VOICE_CALL;
508 audioAdapterManager->SetSleVoiceStatusFlag(true);
509 int32_t ret = audioAdapterManager->SetVolumeDb(streamType);
510 EXPECT_NE(ret, SUCCESS);
511 }
512
513 /**
514 * @tc.name: Test GetMaxVolumeLevel
515 * @tc.number: GetMaxVolumeLevel_001
516 * @tc.type: FUNC
517 * @tc.desc: the volumeType is STREAM_APP, return appConfigVolume_.maxVolume.
518 */
519 HWTEST_F(AudioAdapterManagerUnitTest, GetMaxVolumeLevel_001, TestSize.Level1)
520 {
521 auto audioAdapterManager = std::make_shared<AudioAdapterManager>();
522 int32_t ret = audioAdapterManager->GetMaxVolumeLevel(STREAM_APP, DEVICE_TYPE_NONE);
523 EXPECT_EQ(ret, audioAdapterManager->appConfigVolume_.maxVolume);
524 }
525
526 /**
527 * @tc.name: Test GetMaxVolumeLevel
528 * @tc.number: GetMaxVolumeLevel_002
529 * @tc.type: FUNC
530 * @tc.desc: the device maxLevel is valid, return the device maxLevel.
531 */
532 HWTEST_F(AudioAdapterManagerUnitTest, GetMaxVolumeLevel_002, TestSize.Level1)
533 {
534 auto audioAdapterManager = std::make_shared<AudioAdapterManager>();
535 AudioVolumeType volumeType = STREAM_VOICE_CALL;
536 DeviceVolumeType deviceType = SPEAKER_VOLUME_TYPE;
537 if (audioAdapterManager->streamVolumeInfos_.end() != audioAdapterManager->streamVolumeInfos_.find(volumeType)) {
538 if ((audioAdapterManager->streamVolumeInfos_[volumeType] != nullptr) &&
539 (audioAdapterManager->streamVolumeInfos_[volumeType]->deviceVolumeInfos.end() !=
540 audioAdapterManager->streamVolumeInfos_[volumeType]->deviceVolumeInfos.find(deviceType)) &&
541 (audioAdapterManager->streamVolumeInfos_[volumeType]->deviceVolumeInfos[deviceType] != nullptr)) {
542 audioAdapterManager->streamVolumeInfos_[volumeType]->deviceVolumeInfos[deviceType]->maxLevel = 10;
543 }
544 }
545
546 int32_t ret = audioAdapterManager->GetMaxVolumeLevel(volumeType, DEVICE_TYPE_SPEAKER);
547 EXPECT_NE(ret, 10);
548 }
549
550 /**
551 * @tc.name: Test GetMaxVolumeLevel
552 * @tc.number: GetMaxVolumeLevel_003
553 * @tc.type: FUNC
554 * @tc.desc: the device maxLevel is not valid, return maxVolumeIndexMap_[volumeType].
555 */
556 HWTEST_F(AudioAdapterManagerUnitTest, GetMaxVolumeLevel_003, TestSize.Level1)
557 {
558 auto audioAdapterManager = std::make_shared<AudioAdapterManager>();
559 int32_t ret = audioAdapterManager->GetMaxVolumeLevel(STREAM_ALARM, DEVICE_TYPE_NONE);
560 EXPECT_NE(ret, audioAdapterManager->maxVolumeIndexMap_[STREAM_ALARM]);
561 }
562
563 /**
564 * @tc.name: Test GetMaxVolumeLevel
565 * @tc.number: GetMaxVolumeLevel_004
566 * @tc.type: FUNC
567 * @tc.desc: the volume Type is not valid, return maxVolumeIndexMap_[STREAM_MUSIC].
568 */
569 HWTEST_F(AudioAdapterManagerUnitTest, GetMaxVolumeLevel_004, TestSize.Level1)
570 {
571 auto audioAdapterManager = std::make_shared<AudioAdapterManager>();
572 int32_t ret = audioAdapterManager->GetMaxVolumeLevel(STREAM_DEFAULT, DEVICE_TYPE_NONE);
573 EXPECT_NE(ret, audioAdapterManager->maxVolumeIndexMap_[STREAM_MUSIC]);
574 }
575
576 /**
577 * @tc.name: Test GetMinVolumeLevel
578 * @tc.number: GetMinVolumeLevel_001
579 * @tc.type: FUNC
580 * @tc.desc: the volumeType is STREAM_APP, return appConfigVolume_.minVolume.
581 */
582 HWTEST_F(AudioAdapterManagerUnitTest, GetMinVolumeLevel_001, TestSize.Level1)
583 {
584 auto audioAdapterManager = std::make_shared<AudioAdapterManager>();
585 int32_t ret = audioAdapterManager->GetMinVolumeLevel(STREAM_APP, DEVICE_TYPE_NONE);
586 EXPECT_EQ(ret, audioAdapterManager->appConfigVolume_.minVolume);
587 }
588
589 /**
590 * @tc.name: Test GetMinVolumeLevel
591 * @tc.number: GetMinVolumeLevel_002
592 * @tc.type: FUNC
593 * @tc.desc: the device maxLevel is valid, return the device maxLevel.
594 */
595 HWTEST_F(AudioAdapterManagerUnitTest, GetMinVolumeLevel_002, TestSize.Level1)
596 {
597 auto audioAdapterManager = std::make_shared<AudioAdapterManager>();
598 AudioVolumeType volumeType = STREAM_VOICE_CALL;
599 DeviceVolumeType deviceType = SPEAKER_VOLUME_TYPE;
600 if (audioAdapterManager->streamVolumeInfos_.end() != audioAdapterManager->streamVolumeInfos_.find(volumeType)) {
601 if ((audioAdapterManager->streamVolumeInfos_[volumeType] != nullptr) &&
602 (audioAdapterManager->streamVolumeInfos_[volumeType]->deviceVolumeInfos.end() !=
603 audioAdapterManager->streamVolumeInfos_[volumeType]->deviceVolumeInfos.find(deviceType)) &&
604 (audioAdapterManager->streamVolumeInfos_[volumeType]->deviceVolumeInfos[deviceType] != nullptr)) {
605 audioAdapterManager->streamVolumeInfos_[volumeType]->deviceVolumeInfos[deviceType]->minLevel = 2;
606 }
607 }
608
609 int32_t ret = audioAdapterManager->GetMinVolumeLevel(volumeType, DEVICE_TYPE_SPEAKER);
610 EXPECT_NE(ret, 2);
611 }
612
613 /**
614 * @tc.name: Test GetMinVolumeLevel
615 * @tc.number: GetMinVolumeLevel_003
616 * @tc.type: FUNC
617 * @tc.desc: the device maxLevel is not valid, return minVolumeIndexMap_[volumeType].
618 */
619 HWTEST_F(AudioAdapterManagerUnitTest, GetMinVolumeLevel_003, TestSize.Level1)
620 {
621 auto audioAdapterManager = std::make_shared<AudioAdapterManager>();
622 int32_t ret = audioAdapterManager->GetMinVolumeLevel(STREAM_ALARM, DEVICE_TYPE_NONE);
623 EXPECT_EQ(ret, audioAdapterManager->minVolumeIndexMap_[STREAM_ALARM]);
624 }
625
626 /**
627 * @tc.name: Test GetMinVolumeLevel
628 * @tc.number: GetMinVolumeLevel_004
629 * @tc.type: FUNC
630 * @tc.desc: the volume Type is not valid, return minVolumeIndexMap_[STREAM_MUSIC].
631 */
632 HWTEST_F(AudioAdapterManagerUnitTest, GetMinVolumeLevel_004, TestSize.Level1)
633 {
634 auto audioAdapterManager = std::make_shared<AudioAdapterManager>();
635 int32_t ret = audioAdapterManager->GetMinVolumeLevel(STREAM_DEFAULT, DEVICE_TYPE_NONE);
636 EXPECT_NE(ret, audioAdapterManager->minVolumeIndexMap_[STREAM_MUSIC]);
637 }
638
639 } // namespace AudioStandard
640 } // namespace OHOS
641