1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "volume_data_maintainer_unit_test.h"
17
18 #include "system_ability_definition.h"
19 #include "audio_errors.h"
20 #include "audio_utils.h"
21
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace AudioStandard {
26
SetUpTestCase(void)27 void VolumeDataMaintainerUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)28 void VolumeDataMaintainerUnitTest::TearDownTestCase(void) {}
SetUp(void)29 void VolumeDataMaintainerUnitTest::SetUp(void) {}
TearDown(void)30 void VolumeDataMaintainerUnitTest::TearDown(void) {}
31
32 /**
33 * @tc.name : Test VolumeDataMaintainer.
34 * @tc.number: VolumeDataMaintainerUnitTest_001.
35 * @tc.desc : Test VolumeDataMaintainer API.
36 */
37 HWTEST(VolumeDataMaintainerUnitTest, VolumeDataMaintainerUnitTest_001, TestSize.Level1)
38 {
39 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
40 DeviceType typeRet = DEVICE_TYPE_NONE;
41 AudioStreamType streamTypeRet = STREAM_DEFAULT;
42 int32_t volumeLevelRet = 0;
43 auto ret = volumeDataMaintainerRet->SaveVolume(typeRet, streamTypeRet, volumeLevelRet);
44 EXPECT_EQ(ret, false);
45 }
46
47 /**
48 * @tc.name : Test VolumeDataMaintainer.
49 * @tc.number: VolumeDataMaintainerUnitTest_002.
50 * @tc.desc : Test VolumeDataMaintainer API.
51 */
52 HWTEST(VolumeDataMaintainerUnitTest, VolumeDataMaintainerUnitTest_002, TestSize.Level1)
53 {
54 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
55 DeviceType typeRet = DEVICE_TYPE_DP;
56 AudioStreamType streamTypeRet = STREAM_MUSIC;
57 int32_t volumeLevelRet = 0;
58 auto ret = volumeDataMaintainerRet->SaveVolume(typeRet, streamTypeRet, volumeLevelRet);
59 EXPECT_EQ(ret, false);
60 }
61
62 /**
63 * @tc.name : Test VolumeDataMaintainer.
64 * @tc.number: VolumeDataMaintainerUnitTest_003.
65 * @tc.desc : Test VolumeDataMaintainer API.
66 */
67 HWTEST(VolumeDataMaintainerUnitTest, VolumeDataMaintainerUnitTest_003, TestSize.Level1)
68 {
69 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
70 DeviceType deviceTypeRet = DEVICE_TYPE_NONE;
71 AudioStreamType streamTypeRet = STREAM_DEFAULT;
72 auto ret = volumeDataMaintainerRet->GetVolume(deviceTypeRet, streamTypeRet);
73 EXPECT_EQ(ret, false);
74 }
75
76 /**
77 * @tc.name : Test VolumeDataMaintainer.
78 * @tc.number: VolumeDataMaintainerUnitTest_004.
79 * @tc.desc : Test VolumeDataMaintainer API.
80 */
81 HWTEST(VolumeDataMaintainerUnitTest, VolumeDataMaintainerUnitTest_004, TestSize.Level1)
82 {
83 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
84 DeviceType deviceTypeRet = DEVICE_TYPE_NONE;
85 AudioStreamType streamTypeRet = STREAM_RING;
86 bool muteStatusRet = false;
87 auto ret = volumeDataMaintainerRet->SaveMuteStatus(deviceTypeRet, streamTypeRet, muteStatusRet);
88 EXPECT_EQ(ret, true);
89 }
90
91 /**
92 * @tc.name : Test VolumeDataMaintainer.
93 * @tc.number: VolumeDataMaintainerUnitTest_005.
94 * @tc.desc : Test VolumeDataMaintainer API.
95 */
96 HWTEST(VolumeDataMaintainerUnitTest, VolumeDataMaintainerUnitTest_005, TestSize.Level1)
97 {
98 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
99 DeviceType deviceTypeRet = DEVICE_TYPE_DP;
100 AudioStreamType streamTypeRet = STREAM_MUSIC;
101 bool muteStatusRet = false;
102 auto ret = volumeDataMaintainerRet->SaveMuteStatus(deviceTypeRet, streamTypeRet, muteStatusRet);
103 EXPECT_EQ(ret, true);
104 }
105
106 /**
107 * @tc.name : Test VolumeDataMaintainer.
108 * @tc.number: VolumeDataMaintainerUnitTest_006.
109 * @tc.desc : Test VolumeDataMaintainer API.
110 */
111 HWTEST(VolumeDataMaintainerUnitTest, VolumeDataMaintainerUnitTest_006, TestSize.Level1)
112 {
113 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
114 DeviceType deviceTypeRet = DEVICE_TYPE_DP;
115 AudioStreamType streamTypeRet = STREAM_DEFAULT;
116 auto ret = volumeDataMaintainerRet->GetMuteStatusInternal(deviceTypeRet, streamTypeRet);
117 EXPECT_EQ(ret, false);
118 }
119
120 /**
121 * @tc.name : Test VolumeDataMaintainer.
122 * @tc.number: VolumeDataMaintainerUnitTest_007.
123 * @tc.desc : Test VolumeDataMaintainer API.
124 */
125 HWTEST(VolumeDataMaintainerUnitTest, VolumeDataMaintainerUnitTest_007, TestSize.Level1)
126 {
127 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
128 DeviceType deviceTypeRet = DEVICE_TYPE_DP;
129 AudioStreamType streamTypeRet = STREAM_MUSIC;
130 auto ret = volumeDataMaintainerRet->GetMuteStatusInternal(deviceTypeRet, streamTypeRet);
131 EXPECT_EQ(ret, false);
132 }
133
134 /**
135 * @tc.name : Test VolumeDataMaintainer.
136 * @tc.number: VolumeDataMaintainerUnitTest_008.
137 * @tc.desc : Test VolumeDataMaintainer API.
138 */
139 HWTEST(VolumeDataMaintainerUnitTest, VolumeDataMaintainerUnitTest_008, TestSize.Level1)
140 {
141 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
142 int32_t affectedRet;
143 bool statusRet;
144 auto ret = volumeDataMaintainerRet->GetMuteAffected(affectedRet);
145 EXPECT_EQ(ret, false);
146
147 ret = volumeDataMaintainerRet->GetMuteTransferStatus(statusRet);
148 EXPECT_EQ(ret, false);
149 }
150
151 /**
152 * @tc.name : Test VolumeDataMaintainer.
153 * @tc.number: VolumeDataMaintainerUnitTest_009.
154 * @tc.desc : Test VolumeDataMaintainer API.
155 */
156 HWTEST(VolumeDataMaintainerUnitTest, VolumeDataMaintainerUnitTest_009, TestSize.Level1)
157 {
158 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
159 int32_t affectedRet = 0;
160 bool statusRet = false;
161 AudioRingerMode ringerModeRet = RINGER_MODE_SILENT;
162 auto ret = volumeDataMaintainerRet->SetMuteAffectedToMuteStatusDataBase(affectedRet);
163 EXPECT_EQ(ret, true);
164
165 ret = volumeDataMaintainerRet->SaveMuteTransferStatus(statusRet);
166 EXPECT_EQ(ret, false);
167
168 ret = volumeDataMaintainerRet->SaveRingerMode(ringerModeRet);
169 EXPECT_EQ(ret, false);
170
171 ret = volumeDataMaintainerRet->GetRingerMode(ringerModeRet);
172 EXPECT_EQ(ret, false);
173 }
174
175 /**
176 * @tc.name : Test VolumeDataMaintainer.
177 * @tc.number: VolumeDataMaintainerUnitTest_010.
178 * @tc.desc : Test VolumeDataMaintainer API.
179 */
180 HWTEST(VolumeDataMaintainerUnitTest, VolumeDataMaintainerUnitTest_010, TestSize.Level1)
181 {
182 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
183 DeviceType deviceTypeRet = DEVICE_TYPE_BLUETOOTH_SCO;
184 SafeStatus safeStatusRet = SAFE_UNKNOWN;
185 auto ret = volumeDataMaintainerRet->SaveSafeStatus(deviceTypeRet, safeStatusRet);
186 EXPECT_EQ(ret, false);
187
188 deviceTypeRet = DEVICE_TYPE_USB_ARM_HEADSET;
189 ret = volumeDataMaintainerRet->SaveSafeStatus(deviceTypeRet, safeStatusRet);
190 EXPECT_EQ(ret, false);
191
192 deviceTypeRet = DEVICE_TYPE_NONE;
193 ret = volumeDataMaintainerRet->SaveSafeStatus(deviceTypeRet, safeStatusRet);
194 EXPECT_EQ(ret, false);
195
196 deviceTypeRet = DEVICE_TYPE_BLUETOOTH_A2DP;
197 ret = volumeDataMaintainerRet->SaveSafeStatus(deviceTypeRet, safeStatusRet);
198 EXPECT_EQ(ret, false);
199 }
200
201 /**
202 * @tc.name : Test VolumeDataMaintainer.
203 * @tc.number: VolumeDataMaintainerUnitTest_011.
204 * @tc.desc : Test VolumeDataMaintainer API.
205 */
206 HWTEST(VolumeDataMaintainerUnitTest, VolumeDataMaintainerUnitTest_011, TestSize.Level1)
207 {
208 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
209 DeviceType deviceTypeRet = DEVICE_TYPE_NONE;
210 SafeStatus safeStatusRet = SAFE_UNKNOWN;
211 auto ret = volumeDataMaintainerRet->GetSafeStatus(deviceTypeRet, safeStatusRet);
212 EXPECT_EQ(ret, false);
213
214 deviceTypeRet = DEVICE_TYPE_USB_ARM_HEADSET;
215 ret = volumeDataMaintainerRet->GetSafeStatus(deviceTypeRet, safeStatusRet);
216 EXPECT_EQ(ret, false);
217
218 deviceTypeRet = DEVICE_TYPE_BLUETOOTH_A2DP;
219 ret = volumeDataMaintainerRet->GetSafeStatus(deviceTypeRet, safeStatusRet);
220 EXPECT_EQ(ret, false);
221 }
222
223 /**
224 * @tc.name : Test VolumeDataMaintainer.
225 * @tc.number: VolumeDataMaintainerUnitTest_012.
226 * @tc.desc : Test VolumeDataMaintainer API.
227 */
228 HWTEST(VolumeDataMaintainerUnitTest, VolumeDataMaintainerUnitTest_012, TestSize.Level1)
229 {
230 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
231 DeviceType deviceTypeRet = DEVICE_TYPE_BLUETOOTH_SCO;
232 int64_t timeRet = 0;
233 auto ret = volumeDataMaintainerRet->SaveSafeVolumeTime(deviceTypeRet, timeRet);
234 EXPECT_EQ(ret, false);
235
236 deviceTypeRet = DEVICE_TYPE_USB_ARM_HEADSET;
237 ret = volumeDataMaintainerRet->SaveSafeVolumeTime(deviceTypeRet, timeRet);
238 EXPECT_EQ(ret, false);
239
240 deviceTypeRet = DEVICE_TYPE_NONE;
241 ret = volumeDataMaintainerRet->SaveSafeVolumeTime(deviceTypeRet, timeRet);
242 EXPECT_EQ(ret, false);
243
244 deviceTypeRet = DEVICE_TYPE_BLUETOOTH_A2DP;
245 ret = volumeDataMaintainerRet->SaveSafeVolumeTime(deviceTypeRet, timeRet);
246 EXPECT_EQ(ret, false);
247 }
248
249 /**
250 * @tc.name : Test VolumeDataMaintainer.
251 * @tc.number: VolumeDataMaintainerUnitTest_013.
252 * @tc.desc : Test VolumeDataMaintainer API.
253 */
254 HWTEST(VolumeDataMaintainerUnitTest, VolumeDataMaintainerUnitTest_013, TestSize.Level1)
255 {
256 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
257 DeviceType deviceTypeRet = DEVICE_TYPE_NONE;
258 int64_t timeRet = 0;
259 auto ret = volumeDataMaintainerRet->GetSafeVolumeTime(deviceTypeRet, timeRet);
260 EXPECT_EQ(ret, false);
261
262 deviceTypeRet = DEVICE_TYPE_BLUETOOTH_SCO;
263 ret = volumeDataMaintainerRet->GetSafeVolumeTime(deviceTypeRet, timeRet);
264 EXPECT_EQ(ret, false);
265
266 deviceTypeRet = DEVICE_TYPE_USB_HEADSET;
267 ret = volumeDataMaintainerRet->GetSafeVolumeTime(deviceTypeRet, timeRet);
268 EXPECT_EQ(ret, false);
269 }
270
271 /**
272 * @tc.name : Test VolumeDataMaintainer.
273 * @tc.number: VolumeDataMaintainerUnitTest_014.
274 * @tc.desc : Test VolumeDataMaintainer API.
275 */
276 HWTEST(VolumeDataMaintainerUnitTest, VolumeDataMaintainerUnitTest_014, TestSize.Level1)
277 {
278 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
279 std::string keyRet1;
280 std::string valueRet1;
281 auto ret = volumeDataMaintainerRet->SaveSystemSoundUrl(keyRet1, valueRet1);
282 EXPECT_EQ(ret, false);
283
284 std::string keyRet2;
285 std::string valueRet2;
286 ret = volumeDataMaintainerRet->GetSystemSoundUrl(keyRet2, valueRet2);
287 EXPECT_EQ(ret, false);
288 volumeDataMaintainerRet->RegisterCloned();
289 }
290
291 /**
292 * @tc.name : Test VolumeDataMaintainer.
293 * @tc.number: VolumeDataMaintainerUnitTest_015.
294 * @tc.desc : Test VolumeDataMaintainer API.
295 */
296 HWTEST(VolumeDataMaintainerUnitTest, VolumeDataMaintainerUnitTest_015, TestSize.Level1)
297 {
298 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
299 bool isMuteRet1 = false;
300 auto ret = volumeDataMaintainerRet->SaveMicMuteState(isMuteRet1);
301 EXPECT_EQ(ret, false);
302
303 bool isMuteRet2;
304 ret = volumeDataMaintainerRet->GetMicMuteState(isMuteRet2);
305 EXPECT_EQ(ret, false);
306 }
307
308 /**
309 * @tc.name : Test VolumeDataMaintainer.
310 * @tc.number: VolumeDataMaintainerUnitTest_016.
311 * @tc.desc : Test VolumeDataMaintainer API.
312 */
313 HWTEST(VolumeDataMaintainerUnitTest, VolumeDataMaintainerUnitTest_016, TestSize.Level1)
314 {
315 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
316 DeviceType deviceTypeRet = DEVICE_TYPE_BLUETOOTH_SCO;
317
318 auto ret = volumeDataMaintainerRet->GetDeviceTypeName(deviceTypeRet);
319 std::string typeRet = "_wireless";
320 EXPECT_EQ(ret, typeRet);
321
322 deviceTypeRet = DEVICE_TYPE_USB_ARM_HEADSET;
323 ret = volumeDataMaintainerRet->GetDeviceTypeName(deviceTypeRet);
324 typeRet = "_wired";
325 EXPECT_EQ(ret, typeRet);
326
327 deviceTypeRet = DEVICE_TYPE_REMOTE_CAST;
328 ret = volumeDataMaintainerRet->GetDeviceTypeName(deviceTypeRet);
329 typeRet = "_remote_cast";
330 EXPECT_EQ(ret, typeRet);
331
332 deviceTypeRet = DEVICE_TYPE_NEARLINK;
333 ret = volumeDataMaintainerRet->GetDeviceTypeName(deviceTypeRet);
334 typeRet = "_wireless";
335 EXPECT_EQ(ret, typeRet);
336
337 deviceTypeRet = DEVICE_TYPE_NONE;
338 ret = volumeDataMaintainerRet->GetDeviceTypeName(deviceTypeRet);
339 typeRet = "";
340 EXPECT_EQ(ret, typeRet);
341
342 deviceTypeRet = DEVICE_TYPE_HEARING_AID;
343 ret = volumeDataMaintainerRet->GetDeviceTypeName(deviceTypeRet);
344 typeRet = "_hearing_aid";
345 EXPECT_EQ(ret, typeRet);
346 }
347
348 /**
349 * @tc.name : Test VolumeDataMaintainer.
350 * @tc.number: VolumeDataMaintainerUnitTest_017.
351 * @tc.desc : Test VolumeDataMaintainer API.
352 */
353 HWTEST(VolumeDataMaintainerUnitTest, VolumeDataMaintainerUnitTest_017, TestSize.Level1)
354 {
355 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
356 DeviceType deviceTypeRet = DEVICE_TYPE_BLUETOOTH_SCO;
357 AudioStreamType streamTypeRet = STREAM_DEFAULT;
358
359 auto ret = volumeDataMaintainerRet->GetVolumeKeyForDataShare(deviceTypeRet, streamTypeRet);
360 std::string typeRet = "";
361 EXPECT_EQ(ret, typeRet);
362
363 streamTypeRet = STREAM_VOICE_ASSISTANT;
364 ret = volumeDataMaintainerRet->GetVolumeKeyForDataShare(deviceTypeRet, streamTypeRet);
365 typeRet = "voice_assistant_volume_wireless_sco";
366 EXPECT_EQ(ret, typeRet);
367 }
368
369 /**
370 * @tc.name : Test VolumeDataMaintainer.
371 * @tc.number: VolumeDataMaintainerUnitTest_018.
372 * @tc.desc : Test VolumeDataMaintainer API.
373 */
374 HWTEST(VolumeDataMaintainerUnitTest, VolumeDataMaintainerUnitTest_018, TestSize.Level3)
375 {
376 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
377 bool isMuteRet1 = true;
378 auto ret = volumeDataMaintainerRet->SaveMicMuteState(isMuteRet1);
379 EXPECT_EQ(ret, false);
380
381 bool isMuteRet2 = true;
382 ret = volumeDataMaintainerRet->GetMicMuteState(isMuteRet2);
383 EXPECT_EQ(ret, false);
384 }
385
386 /**
387 * @tc.name : Test VolumeDataMaintainer SaveMuteStatusInternal when muteKey is empty.
388 * @tc.number: VolumeDataMaintainer_SaveMuteStatusInternal_001.
389 * @tc.desc : Test VolumeDataMaintainer API when GetMuteKeyForDataShare returns empty string.
390 */
391 HWTEST(VolumeDataMaintainerUnitTest, VolumeDataMaintainer_SaveMuteStatusInternal_001, TestSize.Level1)
392 {
393 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
394 DeviceType deviceType = DEVICE_TYPE_NONE;
395 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
396 bool muteStatus = true;
397 bool result = volumeDataMaintainer->SaveMuteStatusInternal(deviceType, streamType, muteStatus);
398 EXPECT_FALSE(result);
399 }
400
401 /**
402 * @tc.name : Test VolumeDataMaintainer SaveMuteStatusInternal when muteKey is valid.
403 * @tc.number: VolumeDataMaintainer_SaveMuteStatusInternal_002.
404 * @tc.desc : Test VolumeDataMaintainer API when GetMuteKeyForDataShare returns valid string and save succeeds.
405 */
406 HWTEST(VolumeDataMaintainerUnitTest, VolumeDataMaintainer_SaveMuteStatusInternal_002, TestSize.Level1)
407 {
408 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
409 DeviceType deviceType = DEVICE_TYPE_BLUETOOTH_SCO;
410 AudioStreamType streamType = AudioStreamType::STREAM_MUSIC;
411 bool muteStatus = true;
412 bool result = volumeDataMaintainer->SaveMuteStatusInternal(deviceType, streamType, muteStatus);
413 EXPECT_TRUE(result);
414 }
415
416 /**
417 * @tc.name : Test VolumeDataMaintainer SaveMuteStatusInternal when muteKey is valid.
418 * @tc.number: VolumeDataMaintainer_SaveMuteStatusInternal_003.
419 * @tc.desc : Test VolumeDataMaintainer API when GetMuteKeyForDataShare returns valid string and save succeeds.
420 */
421 HWTEST(VolumeDataMaintainerUnitTest, VolumeDataMaintainer_SaveMuteStatusInternal_003, TestSize.Level3)
422 {
423 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
424 DeviceType deviceType = DEVICE_TYPE_BLUETOOTH_SCO;
425 AudioStreamType streamType = AudioStreamType::STREAM_MUSIC;
426 bool muteStatus = true;
427 VolumeUtils::SetPCVolumeEnable(true);
428 bool result = volumeDataMaintainer->SaveMuteStatusInternal(deviceType, streamType, muteStatus);
429 EXPECT_TRUE(result);
430 }
431
432 /**
433 * @tc.name : Test VolumeDataMaintainer SaveMuteStatusInternal when muteKey is valid.
434 * @tc.number: VolumeDataMaintainer_SaveMuteStatusInternal_004.
435 * @tc.desc : Test VolumeDataMaintainer API when GetMuteKeyForDataShare returns valid string and save succeeds.
436 */
437 HWTEST(VolumeDataMaintainerUnitTest, VolumeDataMaintainer_SaveMuteStatusInternal_004, TestSize.Level3)
438 {
439 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
440 DeviceType deviceType = DEVICE_TYPE_BLUETOOTH_SCO;
441 AudioStreamType streamType = AudioStreamType::STREAM_VOICE_ASSISTANT;
442 bool muteStatus = true;
443 VolumeUtils::SetPCVolumeEnable(true);
444 bool result = volumeDataMaintainer->SaveMuteStatusInternal(deviceType, streamType, muteStatus);
445 EXPECT_TRUE(result);
446 }
447
448
449 /**
450 * @tc.name : Test VolumeDataMaintainer SaveMuteStatusInternal when muteKey is valid.
451 * @tc.number: VolumeDataMaintainer_SaveMuteStatusInternal_005.
452 * @tc.desc : Test VolumeDataMaintainer API when GetMuteKeyForDataShare returns valid string and save succeeds.
453 */
454 HWTEST(VolumeDataMaintainerUnitTest, VolumeDataMaintainer_SaveMuteStatusInternal_005, TestSize.Level3)
455 {
456 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
457 DeviceType deviceType = DEVICE_TYPE_SPEAKER;
458 AudioStreamType streamType = AudioStreamType::STREAM_VOICE_ASSISTANT;
459 bool muteStatus = true;
460 VolumeUtils::SetPCVolumeEnable(true);
461 bool result = volumeDataMaintainer->SaveMuteStatusInternal(deviceType, streamType, muteStatus);
462 EXPECT_TRUE(result);
463 }
464
465 /**
466 * @tc.name : Test VolumeDataMaintainer GetAppMute when appUid not found.
467 * @tc.number: GetAppMute_001
468 * @tc.desc : Test VolumeDataMaintainer API when appUid is not present in appMuteStatusMap.
469 */
470 HWTEST(VolumeDataMaintainerUnitTest, GetAppMute_001, TestSize.Level1)
471 {
472 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
473 int32_t appUid = 12345;
474 bool isMute = false;
475 volumeDataMaintainer->appMuteStatusMap_.erase(appUid);
476
477 volumeDataMaintainer->GetAppMute(appUid, isMute);
478 EXPECT_FALSE(isMute);
479 }
480
481 /**
482 * @tc.name : Test VolumeDataMaintainer GetAppMute when subIter.second is true.
483 * @tc.number: GetAppMute_002
484 * @tc.desc : Test VolumeDataMaintainer API when subIter.second is true in the loop.
485 */
486 HWTEST(VolumeDataMaintainerUnitTest, GetAppMute_002, TestSize.Level1)
487 {
488 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
489 int32_t appUid = 12345;
490 bool isMute = false;
491 volumeDataMaintainer->appMuteStatusMap_[appUid][STREAM_MUSIC] = true;
492
493 volumeDataMaintainer->GetAppMute(appUid, isMute);
494 EXPECT_TRUE(isMute);
495 }
496
497 /**
498 * @tc.name : Test VolumeDataMaintainer GetAppMute when subIter.second is false.
499 * @tc.number: GetAppMute_003
500 * @tc.desc : Test VolumeDataMaintainer API when subIter.second is false in the loop.
501 */
502 HWTEST(VolumeDataMaintainerUnitTest, GetAppMute_003, TestSize.Level1)
503 {
504 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
505 int32_t appUid = 12345;
506 bool isMute = false;
507 volumeDataMaintainer->appMuteStatusMap_[appUid][STREAM_MUSIC] = false;
508 volumeDataMaintainer->appMuteStatusMap_[appUid][STREAM_RING] = false;
509
510 volumeDataMaintainer->GetAppMute(appUid, isMute);
511 EXPECT_FALSE(isMute);
512 }
513
514 /**
515 * @tc.name : Test VolumeDataMaintainer GetAppMuteOwned when appUid not found.
516 * @tc.number: GetAppMuteOwned_001
517 * @tc.desc : Test VolumeDataMaintainer API when appUid is not present in appMuteStatusMap.
518 */
519 HWTEST(VolumeDataMaintainerUnitTest, GetAppMuteOwned_001, TestSize.Level1)
520 {
521 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
522 int32_t appUid = 12345;
523 bool isMute = false;
524 volumeDataMaintainer->appMuteStatusMap_.erase(appUid);
525
526 volumeDataMaintainer->GetAppMuteOwned(appUid, isMute);
527 EXPECT_FALSE(isMute);
528 }
529
530 /**
531 * @tc.name : Test VolumeDataMaintainer GetAppMuteOwned when appUid is found.
532 * @tc.number: GetAppMuteOwned_002
533 * @tc.desc : Test VolumeDataMaintainer API when appUid is present in appMuteStatusMap.
534 */
535 HWTEST(VolumeDataMaintainerUnitTest, GetAppMuteOwned_002, TestSize.Level1)
536 {
537 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
538 int32_t appUid = 12345;
539 bool isMute = false;
540 int32_t callingUid = IPCSkeleton::GetCallingUid();
541 volumeDataMaintainer->appMuteStatusMap_[appUid][callingUid] = true;
542
543 volumeDataMaintainer->GetAppMuteOwned(appUid, isMute);
544 EXPECT_TRUE(isMute);
545 }
546
547 /**
548 * @tc.name : Test VolumeDataMaintainer GetDeviceVolumeInternal when volumeKey is empty.
549 * @tc.number: GetDeviceVolumeInternal_001
550 * @tc.desc : Test VolumeDataMaintainer API when GetVolumeKeyForDataShare returns empty string.
551 */
552 HWTEST(VolumeDataMaintainerUnitTest, GetDeviceVolumeInternal_001, TestSize.Level1)
553 {
554 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
555 DeviceType deviceType = DEVICE_TYPE_INVALID;
556 AudioStreamType streamType = STREAM_MUSIC;
557 int32_t volumeValue = volumeDataMaintainer->GetDeviceVolumeInternal(deviceType, streamType);
558 EXPECT_EQ(volumeValue, 0);
559 }
560
561 /**
562 * @tc.name : Test VolumeDataMaintainer GetDeviceVolumeInternal when GetIntValue fails.
563 * @tc.number: GetDeviceVolumeInternal_002
564 * @tc.desc : Test VolumeDataMaintainer API when GetIntValue returns failure.
565 */
566 HWTEST(VolumeDataMaintainerUnitTest, GetDeviceVolumeInternal_002, TestSize.Level1)
567 {
568 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
569 DeviceType deviceType = DEVICE_TYPE_WIRED_HEADSET;
570 AudioStreamType streamType = STREAM_MUSIC;
571 int32_t volumeValue = volumeDataMaintainer->GetDeviceVolumeInternal(deviceType, streamType);
572 EXPECT_EQ(volumeValue, 0);
573 }
574
575 /**
576 * @tc.name : Test VolumeDataMaintainer GetDeviceVolumeInternal when GetIntValue fails.
577 * @tc.number: GetDeviceVolumeInternal_003
578 * @tc.desc : Test VolumeDataMaintainer API when GetIntValue returns failure.
579 */
580 HWTEST(VolumeDataMaintainerUnitTest, GetDeviceVolumeInternal_003, TestSize.Level3)
581 {
582 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
583 DeviceType deviceType = DEVICE_TYPE_BLUETOOTH_SCO;
584 AudioStreamType streamType = STREAM_MUSIC;
585 VolumeUtils::SetPCVolumeEnable(true);
586 int32_t volumeValue = volumeDataMaintainer->GetDeviceVolumeInternal(deviceType, streamType);
587 EXPECT_EQ(volumeValue, 0);
588 }
589
590 /**
591 * @tc.name : Test VolumeDataMaintainer GetDeviceVolumeInternal when GetIntValue fails.
592 * @tc.number: GetDeviceVolumeInternal_004
593 * @tc.desc : Test VolumeDataMaintainer API when GetIntValue returns failure.
594 */
595 HWTEST(VolumeDataMaintainerUnitTest, GetDeviceVolumeInternal_004, TestSize.Level3)
596 {
597 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
598 DeviceType deviceType = DEVICE_TYPE_BLUETOOTH_SCO;
599 AudioStreamType streamType = STREAM_VOICE_ASSISTANT;
600 VolumeUtils::SetPCVolumeEnable(true);
601 int32_t volumeValue = volumeDataMaintainer->GetDeviceVolumeInternal(deviceType, streamType);
602 EXPECT_EQ(volumeValue, 0);
603 }
604
605 /**
606 * @tc.name : Test VolumeDataMaintainer GetDeviceVolumeInternal when GetIntValue fails.
607 * @tc.number: GetDeviceVolumeInternal_005
608 * @tc.desc : Test VolumeDataMaintainer API when GetIntValue returns failure.
609 */
610 HWTEST(VolumeDataMaintainerUnitTest, GetDeviceVolumeInternal_005, TestSize.Level3)
611 {
612 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
613 DeviceType deviceType = DEVICE_TYPE_SPEAKER;
614 AudioStreamType streamType = STREAM_VOICE_ASSISTANT;
615 VolumeUtils::SetPCVolumeEnable(true);
616 int32_t volumeValue = volumeDataMaintainer->GetDeviceVolumeInternal(deviceType, streamType);
617 EXPECT_EQ(volumeValue, 0);
618 }
619
620 /**
621 * @tc.name : Test VolumeDataMaintainer SaveMuteStatusInternal when muteKey is empty.
622 * @tc.number: SaveMuteStatusInternal_001
623 * @tc.desc : Test VolumeDataMaintainer API when GetMuteKeyForDataShare returns empty string.
624 */
625 HWTEST(VolumeDataMaintainerUnitTest, SaveMuteStatusInternal_001, TestSize.Level1)
626 {
627 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
628 std::lock_guard<ffrt::mutex> lock(volumeDataMaintainer->volumeMutex_);
629 volumeDataMaintainer->volumeLevelMap_.clear();
630 volumeDataMaintainer->appVolumeLevelMap_.clear();
631 volumeDataMaintainer->appMuteStatusMap_.clear();
632
633 DeviceType deviceType = DEVICE_TYPE_INVALID;
634 AudioStreamType streamType = STREAM_MUSIC;
635 bool muteStatus = true;
636 bool result = volumeDataMaintainer->SaveMuteStatusInternal(deviceType, streamType, muteStatus);
637 EXPECT_FALSE(result);
638 }
639
640 /**
641 * @tc.name : Test VolumeDataMaintainer SetMuteAffectedToMuteStatusDataBase when entering the if branch.
642 * @tc.number: SetMuteAffectedToMuteStatusDataBase_001
643 * @tc.desc : Test VolumeDataMaintainer API when entering the if branch in the loop.
644 */
645 HWTEST(VolumeDataMaintainerUnitTest, SetMuteAffectedToMuteStatusDataBase_001, TestSize.Level1)
646 {
647 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
648 std::lock_guard<ffrt::mutex> lock(volumeDataMaintainer->volumeMutex_);
649 volumeDataMaintainer->volumeLevelMap_.clear();
650 volumeDataMaintainer->appVolumeLevelMap_.clear();
651 volumeDataMaintainer->appMuteStatusMap_.clear();
652
653 int32_t affected = 1 << VolumeDataMaintainer::VT_STREAM_ALARM;
654 bool result = volumeDataMaintainer->SetMuteAffectedToMuteStatusDataBase(affected);
655 EXPECT_TRUE(result);
656 }
657
658 /**
659 * @tc.name : Test VolumeDataMaintainer SetRestoreVolumeLevel when deviceType is USB_HEADSET and ret is not SUCCESS.
660 * @tc.number: SetRestoreVolumeLevel_002
661 * @tc.desc : Test VolumeDataMaintainer API when deviceType is USB_HEADSET and PutIntValue fails.
662 */
663 HWTEST(VolumeDataMaintainerUnitTest, SetRestoreVolumeLevel_002, TestSize.Level1)
664 {
665 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
666 std::lock_guard<ffrt::mutex> lock(volumeDataMaintainer->volumeMutex_);
667 volumeDataMaintainer->volumeLevelMap_.clear();
668 volumeDataMaintainer->appVolumeLevelMap_.clear();
669 volumeDataMaintainer->appMuteStatusMap_.clear();
670
671 DeviceType deviceType = DEVICE_TYPE_USB_HEADSET;
672 int32_t volume = 5;
673 bool result = volumeDataMaintainer->SetRestoreVolumeLevel(deviceType, volume);
674 EXPECT_FALSE(result);
675 }
676
677 /**
678 * @tc.name : Test VolumeDataMaintainer SetRestoreVolumeLevel when deviceType is
679 USB_ARM_HEADSET and ret is not SUCCESS.
680 * @tc.number: SetRestoreVolumeLevel_003
681 * @tc.desc : Test VolumeDataMaintainer API when deviceType is USB_ARM_HEADSET and PutIntValue fails.
682 */
683 HWTEST(VolumeDataMaintainerUnitTest, SetRestoreVolumeLevel_003, TestSize.Level1)
684 {
685 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
686 std::lock_guard<ffrt::mutex> lock(volumeDataMaintainer->volumeMutex_);
687 volumeDataMaintainer->volumeLevelMap_.clear();
688 volumeDataMaintainer->appVolumeLevelMap_.clear();
689 volumeDataMaintainer->appMuteStatusMap_.clear();
690
691 DeviceType deviceType = DEVICE_TYPE_USB_ARM_HEADSET;
692 int32_t volume = 5;
693 bool result = volumeDataMaintainer->SetRestoreVolumeLevel(deviceType, volume);
694 EXPECT_FALSE(result);
695 }
696
697 /**
698 * @tc.name : Test VolumeDataMaintainer SetRestoreVolumeLevel when deviceType is not supported.
699 * @tc.number: SetRestoreVolumeLevel_004
700 * @tc.desc : Test VolumeDataMaintainer API when deviceType is not supported.
701 */
702 HWTEST(VolumeDataMaintainerUnitTest, SetRestoreVolumeLevel_004, TestSize.Level1)
703 {
704 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
705 std::lock_guard<ffrt::mutex> lock(volumeDataMaintainer->volumeMutex_);
706 volumeDataMaintainer->volumeLevelMap_.clear();
707 volumeDataMaintainer->appVolumeLevelMap_.clear();
708 volumeDataMaintainer->appMuteStatusMap_.clear();
709
710 DeviceType deviceType = DEVICE_TYPE_INVALID;
711 int32_t volume = 5;
712 bool result = volumeDataMaintainer->SetRestoreVolumeLevel(deviceType, volume);
713 EXPECT_FALSE(result);
714 }
715
716 /**
717 * @tc.name : Test VolumeDataMaintainer GetRestoreVolumeLevel when deviceType is not supported.
718 * @tc.number: GetRestoreVolumeLevel_001
719 * @tc.desc : Test VolumeDataMaintainer API when deviceType is not supported.
720 */
721 HWTEST(VolumeDataMaintainerUnitTest, GetRestoreVolumeLevel_001, TestSize.Level1)
722 {
723 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
724 std::lock_guard<ffrt::mutex> lock(volumeDataMaintainer->volumeMutex_);
725 volumeDataMaintainer->volumeLevelMap_.clear();
726 volumeDataMaintainer->appVolumeLevelMap_.clear();
727 volumeDataMaintainer->appMuteStatusMap_.clear();
728
729 DeviceType deviceType = DEVICE_TYPE_INVALID;
730 int32_t volume = 0;
731 bool result = volumeDataMaintainer->GetRestoreVolumeLevel(deviceType, volume);
732 EXPECT_FALSE(result);
733 }
734
735 /**
736 * @tc.name : Test VolumeDataMaintainer GetRestoreVolumeLevel when deviceType is not supported.
737 * @tc.number: GetRestoreVolumeLevel_002
738 * @tc.desc : Test VolumeDataMaintainer API when deviceType is not supported.
739 */
740 HWTEST(VolumeDataMaintainerUnitTest, GetRestoreVolumeLevel_002, TestSize.Level1)
741 {
742 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
743 std::lock_guard<ffrt::mutex> lock(volumeDataMaintainer->volumeMutex_);
744 volumeDataMaintainer->volumeLevelMap_.clear();
745 volumeDataMaintainer->appVolumeLevelMap_.clear();
746 volumeDataMaintainer->appMuteStatusMap_.clear();
747
748 DeviceType deviceType = DEVICE_TYPE_INVALID;
749 int32_t volume = 0;
750 bool result = volumeDataMaintainer->GetRestoreVolumeLevel(deviceType, volume);
751 EXPECT_FALSE(result);
752 }
753
754 /**
755 * @tc.name : Test VolumeDataMaintainer.
756 * @tc.number: SaveMicMuteStateTest_002.
757 * @tc.desc : Test SaveMicMuteState API.
758 */
759 HWTEST(VolumeDataMaintainerUnitTest, SaveMicMuteStateTest_002, TestSize.Level1)
760 {
761 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
762 bool isMuteRet1 = true;
763 auto ret = volumeDataMaintainerRet->SaveMicMuteState(isMuteRet1);
764 EXPECT_EQ(ret, false);
765
766 const int32_t invalidUserId = -1;
767 const int32_t invalidUserIdMinUser = 99;
768 const int32_t validUser = 1000;
769 AudioSettingProvider& settingProvider = AudioSettingProvider::GetInstance(AUDIO_POLICY_SERVICE_ID);
770 int32_t userId = settingProvider.GetCurrentUserId(invalidUserId);
771 EXPECT_NE(userId, invalidUserId);
772 userId = settingProvider.GetCurrentUserId(AudioSettingProvider::MAIN_USER_ID);
773 EXPECT_EQ(userId, AudioSettingProvider::MAIN_USER_ID);
774 userId = settingProvider.GetCurrentUserId(invalidUserIdMinUser);
775 EXPECT_NE(userId, invalidUserIdMinUser);
776 userId = settingProvider.GetCurrentUserId(validUser);
777 EXPECT_EQ(userId, validUser);
778 }
779
780 /**
781 * @tc.name : Test VolumeDataMaintainer.
782 * @tc.number: SaveMuteStatusWithDatabaseVolumeName_001.
783 * @tc.desc : Test SaveMuteStatusWithDatabaseVolumeName API.
784 */
785 HWTEST(VolumeDataMaintainerUnitTest, SaveMuteStatusWithDatabaseVolumeName_001, TestSize.Level1)
786 {
787 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
788 std::string databaseVolumeName = "TestName";
789 AudioStreamType streamType = STREAM_MUSIC;
790 bool mute = true;
791 auto ret = volumeDataMaintainerRet->SaveMuteStatusWithDatabaseVolumeName(databaseVolumeName, streamType, mute);
792 EXPECT_EQ(ret, false);
793
794 mute = false;
795 ret = volumeDataMaintainerRet->SaveMuteStatusWithDatabaseVolumeName(databaseVolumeName, streamType, mute);
796 EXPECT_EQ(ret, false);
797 }
798
799 /**
800 * @tc.name : Test VolumeDataMaintainer.
801 * @tc.number: SaveMuteStatusWithDatabaseVolumeName_002.
802 * @tc.desc : Test SaveMuteStatusWithDatabaseVolumeName API.
803 */
804 HWTEST(VolumeDataMaintainerUnitTest, SaveMuteStatusWithDatabaseVolumeName_002, TestSize.Level1)
805 {
806 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
807 std::string databaseVolumeName = "TestName";
808 AudioStreamType streamType = STREAM_RING;
809 bool mute = true;
810 auto ret = volumeDataMaintainerRet->SaveMuteStatusWithDatabaseVolumeName(databaseVolumeName, streamType, mute);
811 EXPECT_EQ(ret, false);
812
813 mute = false;
814 ret = volumeDataMaintainerRet->SaveMuteStatusWithDatabaseVolumeName(databaseVolumeName, streamType, mute);
815 EXPECT_EQ(ret, false);
816 }
817
818 /**
819 * @tc.name : Test VolumeDataMaintainer.
820 * @tc.number: SaveMuteStatusWithDatabaseVolumeName_003.
821 * @tc.desc : Test SaveMuteStatusWithDatabaseVolumeName API.
822 */
823 HWTEST(VolumeDataMaintainerUnitTest, SaveMuteStatusWithDatabaseVolumeName_003, TestSize.Level1)
824 {
825 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
826 std::string databaseVolumeName = "TestName";
827 AudioStreamType streamType = STREAM_VOICE_CALL;
828 bool mute = true;
829 auto ret = volumeDataMaintainerRet->SaveMuteStatusWithDatabaseVolumeName(databaseVolumeName, streamType, mute);
830 EXPECT_EQ(ret, false);
831
832 mute = false;
833 ret = volumeDataMaintainerRet->SaveMuteStatusWithDatabaseVolumeName(databaseVolumeName, streamType, mute);
834 EXPECT_EQ(ret, false);
835 }
836
837 /**
838 * @tc.name : Test VolumeDataMaintainer.
839 * @tc.number: SaveMuteStatusWithDatabaseVolumeName_004.
840 * @tc.desc : Test SaveMuteStatusWithDatabaseVolumeName API.
841 */
842 HWTEST(VolumeDataMaintainerUnitTest, SaveMuteStatusWithDatabaseVolumeName_004, TestSize.Level4)
843 {
844 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
845 std::string databaseVolumeName = "TestName";
846 AudioStreamType streamType = STREAM_DEFAULT;
847 bool mute = true;
848 VolumeUtils::SetPCVolumeEnable(false);
849 auto ret = volumeDataMaintainerRet->SaveMuteStatusWithDatabaseVolumeName(databaseVolumeName, streamType, mute);
850 EXPECT_EQ(ret, false);
851 }
852
853 /**
854 * @tc.name : Test VolumeDataMaintainer.
855 * @tc.number: GetMuteStatusWithDatabaseVolumeName_001.
856 * @tc.desc : Test GetMuteStatusWithDatabaseVolumeName API.
857 */
858 HWTEST(VolumeDataMaintainerUnitTest, GetMuteStatusWithDatabaseVolumeName_001, TestSize.Level1)
859 {
860 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
861 std::string databaseVolumeName = "TestName";
862 AudioStreamType streamType = STREAM_VOICE_ASSISTANT;
863 bool mute = true;
864 auto ret = volumeDataMaintainerRet->SaveMuteStatusWithDatabaseVolumeName(databaseVolumeName, streamType, mute);
865 EXPECT_EQ(ret, false);
866
867 ret = volumeDataMaintainerRet->GetMuteStatusWithDatabaseVolumeName(databaseVolumeName, streamType);
868 EXPECT_EQ(ret, false);
869
870 mute = false;
871 ret = volumeDataMaintainerRet->SaveMuteStatusWithDatabaseVolumeName(databaseVolumeName, streamType, mute);
872 EXPECT_EQ(ret, false);
873
874 ret = volumeDataMaintainerRet->GetMuteStatusWithDatabaseVolumeName(databaseVolumeName, streamType);
875 EXPECT_EQ(ret, false);
876 }
877
878 /**
879 * @tc.name : Test VolumeDataMaintainer.
880 * @tc.number: SaveVolumeWithDatabaseVolumeName_001.
881 * @tc.desc : Test SaveVolumeWithDatabaseVolumeName API.
882 */
883 HWTEST(VolumeDataMaintainerUnitTest, SaveVolumeWithDatabaseVolumeName_001, TestSize.Level1)
884 {
885 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
886 std::string databaseVolumeName = "TestName";
887 AudioStreamType streamType = STREAM_MUSIC;
888 int32_t volume = 1;
889 auto ret = volumeDataMaintainerRet->SaveVolumeWithDatabaseVolumeName(databaseVolumeName, streamType, volume);
890 EXPECT_EQ(ret, false);
891
892 volume = 10;
893 ret = volumeDataMaintainerRet->SaveVolumeWithDatabaseVolumeName(databaseVolumeName, streamType, volume);
894 EXPECT_EQ(ret, false);
895 }
896
897 /**
898 * @tc.name : Test VolumeDataMaintainer.
899 * @tc.number: SaveVolumeWithDatabaseVolumeName_002.
900 * @tc.desc : Test SaveVolumeWithDatabaseVolumeName API.
901 */
902 HWTEST(VolumeDataMaintainerUnitTest, SaveVolumeWithDatabaseVolumeName_002, TestSize.Level1)
903 {
904 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
905 std::string databaseVolumeName = "TestName";
906 AudioStreamType streamType = STREAM_RING;
907 int32_t volume = 0;
908 auto ret = volumeDataMaintainerRet->SaveVolumeWithDatabaseVolumeName(databaseVolumeName, streamType, volume);
909 EXPECT_EQ(ret, false);
910
911 volume = 15;
912 ret = volumeDataMaintainerRet->SaveVolumeWithDatabaseVolumeName(databaseVolumeName, streamType, volume);
913 EXPECT_EQ(ret, false);
914 }
915
916 /**
917 * @tc.name : Test VolumeDataMaintainer.
918 * @tc.number: SaveVolumeWithDatabaseVolumeName_003.
919 * @tc.desc : Test SaveVolumeWithDatabaseVolumeName API.
920 */
921 HWTEST(VolumeDataMaintainerUnitTest, SaveVolumeWithDatabaseVolumeName_003, TestSize.Level1)
922 {
923 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
924 std::string databaseVolumeName = "TestName";
925 AudioStreamType streamType = STREAM_VOICE_CALL;
926 int32_t volume = 0;
927 auto ret = volumeDataMaintainerRet->SaveVolumeWithDatabaseVolumeName(databaseVolumeName, streamType, volume);
928 EXPECT_EQ(ret, false);
929
930 volume = 15;
931 ret = volumeDataMaintainerRet->SaveVolumeWithDatabaseVolumeName(databaseVolumeName, streamType, volume);
932 EXPECT_EQ(ret, false);
933 }
934
935 /**
936 * @tc.name : Test VolumeDataMaintainer.
937 * @tc.number: GetVolumeWithDatabaseVolumeName_001.
938 * @tc.desc : Test GetVolumeWithDatabaseVolumeName API.
939 */
940 HWTEST(VolumeDataMaintainerUnitTest, GetVolumeWithDatabaseVolumeName_001, TestSize.Level1)
941 {
942 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
943 std::string databaseVolumeName = "TestName";
944 AudioStreamType streamType = STREAM_VOICE_ASSISTANT;
945 int32_t volume = 5;
946 auto ret = volumeDataMaintainerRet->SaveVolumeWithDatabaseVolumeName(databaseVolumeName, streamType, volume);
947 EXPECT_EQ(ret, false);
948
949 ret = volumeDataMaintainerRet->GetVolumeWithDatabaseVolumeName(databaseVolumeName, streamType);
950 EXPECT_EQ(ret, false);
951
952 volume = 10;
953 ret = volumeDataMaintainerRet->SaveVolumeWithDatabaseVolumeName(databaseVolumeName, streamType, volume);
954 EXPECT_EQ(ret, false);
955
956 ret = volumeDataMaintainerRet->GetVolumeWithDatabaseVolumeName(databaseVolumeName, streamType);
957 EXPECT_EQ(ret, false);
958 }
959
960 /**
961 * @tc.name : Test VolumeDataMaintainer.
962 * @tc.number: SetAppStreamMuted_001.
963 * @tc.desc : Test SetAppStreamMuted and IsAppStreamMuted.
964 */
965 HWTEST(VolumeDataMaintainerUnitTest, SetAppStreamMuted_001, TestSize.Level1)
966 {
967 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
968 ASSERT_NE(nullptr, volumeDataMaintainer);
969 const int32_t appUid = 123;
970 const AudioStreamType streamType = AudioStreamType::STREAM_RING;
971
972 // Test setting mute
973 volumeDataMaintainer->SetAppStreamMuted(appUid, streamType, true);
974 EXPECT_EQ(volumeDataMaintainer->IsAppStreamMuted(appUid, streamType), true);
975
976 // Test setting unmute
977 volumeDataMaintainer->SetAppStreamMuted(appUid, streamType, false);
978 EXPECT_EQ(volumeDataMaintainer->IsAppStreamMuted(appUid, streamType), false);
979
980 // Test setting mute repeatedly
981 volumeDataMaintainer->SetAppStreamMuted(appUid, streamType, true);
982 volumeDataMaintainer->SetAppStreamMuted(appUid, streamType, true);
983 EXPECT_EQ(volumeDataMaintainer->IsAppStreamMuted(appUid, streamType), true);
984
985 // Test setting mute for another app stream
986 const int32_t anotherAppUid = 456;
987 volumeDataMaintainer->SetAppStreamMuted(anotherAppUid, streamType, true);
988 EXPECT_EQ(volumeDataMaintainer->IsAppStreamMuted(anotherAppUid, streamType), true);
989
990 // Test multiple stream types
991 const AudioStreamType anotherStreamType = AudioStreamType::STREAM_VOICE_COMMUNICATION;
992 volumeDataMaintainer->SetAppStreamMuted(appUid, anotherStreamType, true);
993 EXPECT_EQ(volumeDataMaintainer->IsAppStreamMuted(appUid, anotherStreamType), true);
994 EXPECT_EQ(volumeDataMaintainer->IsAppStreamMuted(appUid, streamType), true);
995
996 // Test delete an app entry
997 volumeDataMaintainer->SetAppStreamMuted(appUid, streamType, false);
998 volumeDataMaintainer->SetAppStreamMuted(appUid, anotherStreamType, false);
999 EXPECT_EQ(volumeDataMaintainer->IsAppStreamMuted(appUid, streamType), false);
1000 EXPECT_EQ(volumeDataMaintainer->IsAppStreamMuted(appUid, anotherStreamType), false);
1001 }
1002 } // AudioStandardnamespace
1003 } // OHOSnamespace
1004