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 <gtest/gtest.h>
17
18 #include "audio_service_log.h"
19 #include "audio_errors.h"
20 #include "audio_volume.h"
21 #include "audio_utils.h"
22
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace AudioStandard {
27 const int32_t STREAM_MUSIC_TEST = STREAM_MUSIC;
28 const int32_t STREAM_VOICE_TEST = STREAM_VOICE_CALL;
29 const int32_t STREAM_USAGE_MEDIA_TEST = 1;
30
31 class AudioVolumeUnitTest : public testing::Test {
32 public:
33 static void SetUpTestCase(void);
34 static void TearDownTestCase(void);
35 void SetUp();
36 void TearDown();
37 public:
38 AudioVolume* audioVolumeTest;
39 };
40
SetUpTestCase(void)41 void AudioVolumeUnitTest::SetUpTestCase(void)
42 {
43 }
44
TearDownTestCase(void)45 void AudioVolumeUnitTest::TearDownTestCase(void)
46 {
47 }
48
SetUp(void)49 void AudioVolumeUnitTest::SetUp(void)
50 {
51 uint32_t sessionId = 1;
52 int32_t streamType = STREAM_MUSIC_TEST;
53 int32_t streamUsage = STREAM_USAGE_MEDIA_TEST;
54 int32_t uid = 1000;
55 int32_t pid = 1000;
56 int32_t mode = 1;
57 bool isVKB = false;
58 StreamVolumeParams streamVolumeParams = { sessionId, streamType, streamUsage, uid, pid, false, mode, isVKB };
59 AudioVolume::GetInstance()->AddStreamVolume(streamVolumeParams);
60
61 audioVolumeTest = AudioVolume::GetInstance();
62 EXPECT_NE(nullptr, audioVolumeTest);
63 }
64
TearDown(void)65 void AudioVolumeUnitTest::TearDown(void)
66 {
67 uint32_t sessionId = 1;
68 AudioVolume::GetInstance()->RemoveStreamVolume(sessionId);
69
70 audioVolumeTest = nullptr;
71 }
72
73 /**
74 * @tc.name : Test AudioVolume API
75 * @tc.type : FUNC
76 * @tc.number: GetVolume_001
77 * @tc.desc : Test AudioVolume interface.
78 */
79 HWTEST_F(AudioVolumeUnitTest, GetVolume_001, TestSize.Level1)
80 {
81 uint32_t sessionId = 1;
82 int32_t volumeType = STREAM_MUSIC_TEST;
83 std::string deviceClass = "speaker";
84 struct VolumeValues volumes = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f};
85 float volume = AudioVolume::GetInstance()->GetVolume(sessionId, volumeType, deviceClass, &volumes);
86 EXPECT_EQ(volume, 1.0f);
87 }
88
89 /**
90 * @tc.name : Test AudioVolume API
91 * @tc.type : FUNC
92 * @tc.number: GetVolume_002
93 * @tc.desc : Test AudioVolume interface.
94 */
95 HWTEST_F(AudioVolumeUnitTest, GetVolume_002, TestSize.Level1)
96 {
97 uint32_t sessionId = 1;
98 int32_t volumeType = STREAM_VOICE_TEST;
99 std::string deviceClass = "speaker";
100 AudioVolume::GetInstance()->SetVgsVolumeSupported(true);
101 struct VolumeValues volumes = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f};
102 float volume = AudioVolume::GetInstance()->GetVolume(sessionId, volumeType, deviceClass, &volumes);
103 EXPECT_EQ(volume, 1.0f);
104 }
105
106 /**
107 * @tc.name : Test AudioVolume API
108 * @tc.type : FUNC
109 * @tc.number: GetVolume_003
110 * @tc.desc : Test AudioVolume interface.
111 */
112 HWTEST_F(AudioVolumeUnitTest, GetVolume_003, TestSize.Level1)
113 {
114 uint32_t sessionId = 2;
115 int32_t volumeType = STREAM_MUSIC;
116 std::string deviceClass = "speaker";
117 int32_t streamType = STREAM_MUSIC;
118 int32_t streamUsage = STREAM_USAGE_MUSIC;
119 int32_t uid = 1000;
120 int32_t pid = 1000;
121 int32_t mode = 1;
122 bool isVKB = true;
123 ASSERT_TRUE(AudioVolume::GetInstance() != nullptr);
124 StreamVolumeParams streamVolumeParams = { sessionId, streamType, streamUsage, uid, pid, false, mode, isVKB };
125 AudioVolume::GetInstance()->AddStreamVolume(streamVolumeParams);
126
127 SystemVolume systemVolume(STREAM_MUSIC, "speaker", 0.5f, 5, true);
128 AudioVolume::GetInstance()->SetSystemVolume(systemVolume);
129
130 struct VolumeValues volumes = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f};
131 float volume = AudioVolume::GetInstance()->GetVolume(sessionId, volumeType, deviceClass, &volumes);
132 EXPECT_EQ(volume, 0.0f);
133 }
134
135 /**
136 * @tc.name : Test AudioVolume API
137 * @tc.type : FUNC
138 * @tc.number: GetVolume_004
139 * @tc.desc : Test AudioVolume interface.
140 */
141 HWTEST_F(AudioVolumeUnitTest, GetVolume_004, TestSize.Level1)
142 {
143 uint32_t sessionId = 2;
144 int32_t volumeType = STREAM_MUSIC;
145 std::string deviceClass = "speaker";
146 int32_t streamType = STREAM_MUSIC;
147 int32_t streamUsage = STREAM_USAGE_MUSIC;
148 int32_t uid = 1000;
149 int32_t pid = 1000;
150 int32_t mode = 1;
151 bool isVKB = true;
152 ASSERT_TRUE(AudioVolume::GetInstance() != nullptr);
153 StreamVolumeParams streamVolumeParams = { sessionId, streamType, streamUsage, uid, pid, false, mode, isVKB };
154 AudioVolume::GetInstance()->AddStreamVolume(streamVolumeParams);
155
156 SystemVolume systemVolume(STREAM_MUSIC, "speaker", 0.5f, 5, false);
157 AudioVolume::GetInstance()->SetSystemVolume(systemVolume);
158
159 struct VolumeValues volumes = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f};
160 float volume = AudioVolume::GetInstance()->GetVolume(sessionId, volumeType, deviceClass, &volumes);
161 EXPECT_EQ(volume, 1.0f);
162 }
163
164 /**
165 * @tc.name : Test AudioVolume API
166 * @tc.type : FUNC
167 * @tc.number: GetHistoryVolume_001
168 * @tc.desc : Test AudioVolume interface.
169 */
170 HWTEST_F(AudioVolumeUnitTest, GetHistoryVolume_001, TestSize.Level1)
171 {
172 uint32_t sessionId = 1;
173 float volume = AudioVolume::GetInstance()->GetHistoryVolume(sessionId);
174 EXPECT_EQ(volume, 0.0f);
175 }
176
177 /**
178 * @tc.name : Test AudioVolume API
179 * @tc.type : FUNC
180 * @tc.number: GetHistoryVolume_001
181 * @tc.desc : Test AudioVolume interface.
182 */
183 HWTEST_F(AudioVolumeUnitTest, SetHistoryVolume_001, TestSize.Level1)
184 {
185 uint32_t sessionId = 1;
186 float volume = 0.5f;
187 AudioVolume::GetInstance()->SetHistoryVolume(sessionId, volume);
188 float getVolume = AudioVolume::GetInstance()->GetHistoryVolume(sessionId);
189 EXPECT_EQ(getVolume, volume);
190 }
191
192 /**
193 * @tc.name : Test AudioVolume API
194 * @tc.type : FUNC
195 * @tc.number: SetStreamVolume_001
196 * @tc.desc : Test AudioVolume interface.
197 */
198 HWTEST_F(AudioVolumeUnitTest, SetStreamVolume_001, TestSize.Level1)
199 {
200 uint32_t sessionId = 1;
201 float volume = 0.5f;
202 AudioVolume::GetInstance()->SetStreamVolume(sessionId, volume);
203 float retVolume = AudioVolume::GetInstance()->GetStreamVolume(sessionId);
204 EXPECT_EQ(retVolume, volume);
205 }
206
207 /**
208 * @tc.name : Test AudioVolume API
209 * @tc.type : FUNC
210 * @tc.number: SetStreamVolume_002
211 * @tc.desc : Test AudioVolume interface.
212 */
213 HWTEST_F(AudioVolumeUnitTest, SetStreamVolume_002, TestSize.Level1)
214 {
215 uint32_t sessionId = 1;
216 AudioVolume::GetInstance()->streamVolume_.clear();
217 AudioVolume::GetInstance()->SetStreamVolume(sessionId, 1.0f);
218 auto it = AudioVolume::GetInstance()->streamVolume_.find(sessionId);
219 EXPECT_EQ(it == AudioVolume::GetInstance()->streamVolume_.end(), true);
220 }
221
222 /**
223 * @tc.name : Test AudioVolume API
224 * @tc.type : FUNC
225 * @tc.number: SetStreamVolumeDuckFactor_001
226 * @tc.desc : Test AudioVolume interface.
227 */
228 HWTEST_F(AudioVolumeUnitTest, SetStreamVolumeDuckFactor_001, TestSize.Level1)
229 {
230 uint32_t sessionId = 1;
231 float duckFactor = 0.5f;
232 AudioVolume::GetInstance()->SetStreamVolumeDuckFactor(sessionId, duckFactor);
233 float retVolume = AudioVolume::GetInstance()->GetStreamVolume(sessionId);
234 EXPECT_EQ(retVolume, duckFactor);
235 }
236
237 /**
238 * @tc.name : Test AudioVolume API
239 * @tc.type : FUNC
240 * @tc.number: SetStreamVolumeLowPowerFactor_001
241 * @tc.desc : Test AudioVolume interface.
242 */
243 HWTEST_F(AudioVolumeUnitTest, SetStreamVolumeLowPowerFactor_001, TestSize.Level1)
244 {
245 uint32_t sessionId = 1;
246 float lowPowerFactor = 0.5f;
247 AudioVolume::GetInstance()->SetStreamVolumeLowPowerFactor(sessionId, lowPowerFactor);
248 float retVolume = AudioVolume::GetInstance()->GetStreamVolume(sessionId);
249 EXPECT_EQ(retVolume, lowPowerFactor);
250 }
251
252 /**
253 * @tc.name : Test AudioVolume API
254 * @tc.type : FUNC
255 * @tc.number: SetStreamVolumeMute_001
256 * @tc.desc : Test AudioVolume interface.
257 */
258 HWTEST_F(AudioVolumeUnitTest, SetStreamVolumeMute_001, TestSize.Level1)
259 {
260 uint32_t sessionId = 1;
261 bool isMuted = true;
262 AudioVolume::GetInstance()->SetStreamVolumeMute(sessionId, isMuted);
263 float retVolume = AudioVolume::GetInstance()->GetStreamVolume(sessionId);
264 EXPECT_EQ(retVolume, 0);
265 }
266
267 /**
268 * @tc.name : Test AudioVolume API
269 * @tc.type : FUNC
270 * @tc.number: SetSystemVolume_001
271 * @tc.desc : Test AudioVolume interface.
272 */
273 HWTEST_F(AudioVolumeUnitTest, SetSystemVolume_001, TestSize.Level1)
274 {
275 SystemVolume systemVolume(STREAM_MUSIC_TEST, "speaker", 0.5f, 5, false);
276 AudioVolume::GetInstance()->SetSystemVolume(systemVolume);
277 auto it = AudioVolume::GetInstance()->systemVolume_.find("1speaker");
278 EXPECT_TRUE(it != AudioVolume::GetInstance()->systemVolume_.end());
279 }
280
281 /**
282 * @tc.name : Test AudioVolume API
283 * @tc.type : FUNC
284 * @tc.number: SetSystemVolume_002
285 * @tc.desc : Test AudioVolume interface.
286 */
287 HWTEST_F(AudioVolumeUnitTest, SetSystemVolume_002, TestSize.Level1)
288 {
289 SystemVolume systemVolume(STREAM_MUSIC_TEST, "speaker", 0.5f, 5, false);
290 AudioVolume::GetInstance()->SetSystemVolume(systemVolume);
291 SystemVolume systemVolume2(STREAM_MUSIC_TEST, "speaker", 1.0f, 5, false);
292 AudioVolume::GetInstance()->SetSystemVolume(systemVolume2);
293 auto it = AudioVolume::GetInstance()->systemVolume_.find("1speaker");
294 EXPECT_EQ(it->second.volume_, 1.0f);
295 }
296
297 /**
298 * @tc.name : Test AudioVolume API
299 * @tc.type : FUNC
300 * @tc.number: SetSystemVolume_003
301 * @tc.desc : Test AudioVolume interface.
302 */
303 HWTEST_F(AudioVolumeUnitTest, SetSystemVolume_003, TestSize.Level1)
304 {
305 AudioVolume::GetInstance()->SetSystemVolume(STREAM_MUSIC_TEST, "speaker", 0.5f, 5);
306 auto it = AudioVolume::GetInstance()->systemVolume_.find("1speaker");
307 EXPECT_TRUE(it != AudioVolume::GetInstance()->systemVolume_.end());
308 }
309
310 /**
311 * @tc.name : Test AudioVolume API
312 * @tc.type : FUNC
313 * @tc.number: SetSystemVolume_004
314 * @tc.desc : Test AudioVolume interface.
315 */
316 HWTEST_F(AudioVolumeUnitTest, SetSystemVolume_004, TestSize.Level1)
317 {
318 AudioVolume::GetInstance()->SetSystemVolume(STREAM_MUSIC_TEST, "speaker", 0.5f, 5);
319 AudioVolume::GetInstance()->SetSystemVolume(STREAM_MUSIC_TEST, "speaker", 1.0f, 5);
320 auto it = AudioVolume::GetInstance()->systemVolume_.find("1speaker");
321 EXPECT_EQ(it->second.volume_, 1.0f);
322 }
323 /**
324 * @tc.name : Test AudioVolume API
325 * @tc.type : FUNC
326 * @tc.number: SetSystemVolumeMute_001
327 * @tc.desc : Test AudioVolume interface.
328 */
329 HWTEST_F(AudioVolumeUnitTest, SetSystemVolumeMute_001, TestSize.Level1)
330 {
331 int32_t volumeType = STREAM_MUSIC_TEST;
332 std::string deviceClass = "speaker";
333 bool isMuted = true;
334 AudioVolume::GetInstance()->SetSystemVolumeMute(volumeType, deviceClass, isMuted);
335 auto it = AudioVolume::GetInstance()->systemVolume_.find("1speaker");
336 EXPECT_TRUE(it != AudioVolume::GetInstance()->systemVolume_.end());
337 }
338
339 /**
340 * @tc.name : Test AudioVolume API
341 * @tc.type : FUNC
342 * @tc.number: SetSystemVolumeMute_002
343 * @tc.desc : Test AudioVolume interface.
344 */
345 HWTEST_F(AudioVolumeUnitTest, SetSystemVolumeMute_002, TestSize.Level1)
346 {
347 int32_t volumeType = STREAM_MUSIC_TEST;
348 std::string deviceClass = "test";
349 bool isMuted = true;
350 AudioVolume::GetInstance()->SetSystemVolumeMute(volumeType, deviceClass, isMuted);
351 auto it = AudioVolume::GetInstance()->systemVolume_.find("1test");
352 EXPECT_TRUE(it != AudioVolume::GetInstance()->systemVolume_.end());
353 }
354
355 /**
356 * @tc.name : Test AudioVolume API
357 * @tc.type : FUNC
358 * @tc.number: SetFadeoutState_001
359 * @tc.desc : Test AudioVolume interface.
360 */
361 HWTEST_F(AudioVolumeUnitTest, SetFadeoutState_001, TestSize.Level1)
362 {
363 uint32_t streamIndex = 1;
364 uint32_t fadeoutState = DO_FADE;
365 AudioVolume::GetInstance()->SetFadeoutState(streamIndex, fadeoutState);
366 uint32_t getFadeoutState = AudioVolume::GetInstance()->GetFadeoutState(streamIndex);
367 EXPECT_EQ(getFadeoutState, fadeoutState);
368 }
369
370 /**
371 * @tc.name : Test AudioVolume API
372 * @tc.type : FUNC
373 * @tc.number: SetFadeoutState_002
374 * @tc.desc : Test AudioVolume interface.
375 */
376 HWTEST_F(AudioVolumeUnitTest, SetFadeoutState_002, TestSize.Level1)
377 {
378 uint32_t streamIndex = 1;
379 AudioVolume::GetInstance()->fadeoutState_.clear();
380 uint32_t ret = AudioVolume::GetInstance()->GetFadeoutState(streamIndex);
381 EXPECT_EQ(ret, INVALID_STATE);
382 }
383 /**
384 * @tc.name : Test AudioVolume API
385 * @tc.type : FUNC
386 * @tc.number: GetStreamVolume_001
387 * @tc.desc : Test AudioVolume interface.
388 */
389 HWTEST_F(AudioVolumeUnitTest, GetStreamVolume_001, TestSize.Level1)
390 {
391 float volumeStream = AudioVolume::GetInstance()->GetStreamVolume(1);
392 EXPECT_EQ(volumeStream, 1.0f);
393 }
394
395 /**
396 * @tc.name : Test AudioVolume API
397 * @tc.type : FUNC
398 * @tc.number: AddStreamVolume_001
399 * @tc.desc : Test AudioVolume interface.
400 */
401 HWTEST_F(AudioVolumeUnitTest, AddStreamVolume_001, TestSize.Level1)
402 {
403 uint32_t sessionId = 1;
404 int32_t streamType = STREAM_MUSIC_TEST;
405 int32_t streamUsage = STREAM_USAGE_MEDIA_TEST;
406 int32_t uid = 1000;
407 int32_t pid = 1000;
408 int32_t mode = 1;
409 bool isVKB = true;
410 ASSERT_TRUE(AudioVolume::GetInstance() != nullptr);
411 StreamVolumeParams streamVolumeParams = { sessionId, streamType, streamUsage, uid, pid, false, mode, isVKB };
412 AudioVolume::GetInstance()->AddStreamVolume(streamVolumeParams);
413 }
414
415 /**
416 * @tc.name : Test AudioVolume API
417 * @tc.type : FUNC
418 * @tc.number: ConvertStreamTypeStrToInt_001
419 * @tc.desc : Test AudioVolume interface.
420 */
421 HWTEST_F(AudioVolumeUnitTest, ConvertStreamTypeStrToInt_001, TestSize.Level1)
422 {
423 std::string streamType ="ring";
424 int32_t ret = AudioVolume::GetInstance()->ConvertStreamTypeStrToInt(streamType);
425 EXPECT_EQ(ret, 2);
426 }
427
428 /**
429 * @tc.name : Test AudioVolume API
430 * @tc.type : FUNC
431 * @tc.number: ConvertStreamTypeStrToInt_002
432 * @tc.desc : Test AudioVolume interface.
433 */
434 HWTEST_F(AudioVolumeUnitTest, ConvertStreamTypeStrToInt_002, TestSize.Level1)
435 {
436 std::string streamType ="test";
437 int32_t ret = AudioVolume::GetInstance()->ConvertStreamTypeStrToInt(streamType);
438 EXPECT_EQ(ret, 1);
439 }
440
441 /**
442 * @tc.name : Test AudioVolume API
443 * @tc.type : FUNC
444 * @tc.number: SaveAdjustStreamVolumeInfo_001
445 * @tc.desc : Test AudioVolume interface.
446 */
447 HWTEST_F(AudioVolumeUnitTest, SaveAdjustStreamVolumeInfo_001, TestSize.Level1)
448 {
449 auto audioVolume = std::make_shared<AudioVolume>();
450 ASSERT_TRUE(audioVolume != nullptr);
451
452 float volume = 0.5f;
453 uint32_t sessionId = 0;
454 std::string invocationTime = GetTime();
455 uint32_t code = static_cast<uint32_t>(AdjustStreamVolume::STREAM_VOLUME_INFO);
456 audioVolume->SaveAdjustStreamVolumeInfo(volume, sessionId, invocationTime, code);
457 auto ret = audioVolume->GetStreamVolumeInfo(AdjustStreamVolume::STREAM_VOLUME_INFO);
458 EXPECT_TRUE(ret.size() != 0);
459
460 code = static_cast<uint32_t>(AdjustStreamVolume::LOW_POWER_VOLUME_INFO);
461 audioVolume->SaveAdjustStreamVolumeInfo(volume, sessionId, invocationTime, code);
462 ret = audioVolume->GetStreamVolumeInfo(AdjustStreamVolume::LOW_POWER_VOLUME_INFO);
463 EXPECT_TRUE(ret.size() != 0);
464
465 code = static_cast<uint32_t>(AdjustStreamVolume::DUCK_VOLUME_INFO);
466 audioVolume->SaveAdjustStreamVolumeInfo(volume, sessionId, invocationTime, code);
467 ret = audioVolume->GetStreamVolumeInfo(AdjustStreamVolume::DUCK_VOLUME_INFO);
468 EXPECT_TRUE(ret.size() != 0);
469 }
470
471 /**
472 * @tc.name : Test AudioVolume API
473 * @tc.type : FUNC
474 * @tc.number: RemoveStreamVolume_001
475 * @tc.desc : Test AudioVolume interface.
476 */
477 HWTEST_F(AudioVolumeUnitTest, RemoveStreamVolume_001, TestSize.Level1)
478 {
479 auto audioVolume = std::make_shared<AudioVolume>();
480 ASSERT_TRUE(audioVolume != nullptr);
481
482 uint32_t sessionId = 1;
483 audioVolume->RemoveStreamVolume(sessionId);
484 }
485
486 /**
487 * @tc.name : Test AudioVolume API
488 * @tc.type : FUNC
489 * @tc.number: SaveAdjustStreamVolumeInfo_002
490 * @tc.desc : Test AudioVolume interface.
491 */
492 HWTEST_F(AudioVolumeUnitTest, SaveAdjustStreamVolumeInfo_002, TestSize.Level1)
493 {
494 auto audioVolume = std::make_shared<AudioVolume>();
495 ASSERT_TRUE(audioVolume != nullptr);
496
497 float volume = 0.5f;
498 uint32_t sessionId = 0;
499 std::string invocationTime = GetTime();
500 uint32_t code = 10;
501 audioVolume->SaveAdjustStreamVolumeInfo(volume, sessionId, invocationTime, code);
502 AdjustStreamVolume adjustStreamVolume = static_cast<AdjustStreamVolume>(10);
503 auto ret = audioVolume->GetStreamVolumeInfo(adjustStreamVolume);
504 EXPECT_TRUE(ret.size() == 0);
505 }
506
507 /**
508 * @tc.name : Test AudioVolume API
509 * @tc.type : FUNC
510 * @tc.number: GetAppVolume_001
511 * @tc.desc : Test AudioVolume interface.
512 */
513 HWTEST_F(AudioVolumeUnitTest, GetAppVolume_001, TestSize.Level1)
514 {
515 auto audioVolume = std::make_shared<AudioVolume>();
516 ASSERT_TRUE(audioVolume != nullptr);
517
518 int32_t appUid = 0;
519 float volume = 0.1f;
520 int32_t volumeLevel = 1;
521 bool isMuted = true;
522 AppVolume appVolume(appUid, volume, volumeLevel, isMuted);
523 AudioVolumeMode mode = AUDIOSTREAM_VOLUMEMODE_SYSTEM_GLOBAL;
524 auto ret = audioVolume->GetAppVolume(appUid, mode);
525 EXPECT_EQ(ret, 1.0f);
526
527 audioVolume->appVolume_.insert({appUid, appVolume});
528 ret = audioVolume->GetAppVolume(appUid, mode);
529 EXPECT_EQ(ret, 1.0f);
530 }
531
532 /**
533 * @tc.name : Test AudioVolume API
534 * @tc.type : FUNC
535 * @tc.number: SetAppVolumeMute_001
536 * @tc.desc : Test AudioVolume interface.
537 */
538 HWTEST_F(AudioVolumeUnitTest, SetAppVolumeMute_001, TestSize.Level1)
539 {
540 auto audioVolume = std::make_shared<AudioVolume>();
541 ASSERT_TRUE(audioVolume != nullptr);
542
543 int32_t appUid = 0;
544 float volume = 0.1f;
545 int32_t volumeLevel = 1;
546 bool isMuted = true;
547 AppVolume appVolume(appUid, volume, volumeLevel, isMuted);
548 audioVolume->appVolume_.insert({appUid, appVolume});
549
550 audioVolume->SetAppVolumeMute(appUid, false);
551 }
552
553 /**
554 * @tc.name : Test AudioVolume API
555 * @tc.type : FUNC
556 * @tc.number: SetAppVolume_001
557 * @tc.desc : Test AudioVolume interface.
558 */
559 HWTEST_F(AudioVolumeUnitTest, SetAppVolume_001, TestSize.Level1)
560 {
561 auto audioVolume = std::make_shared<AudioVolume>();
562 ASSERT_TRUE(audioVolume != nullptr);
563
564 int32_t appUid = 0;
565 float volume = 0.1f;
566 int32_t volumeLevel = 1;
567 bool isMuted = true;
568 AppVolume appVolume(appUid, volume, volumeLevel, isMuted);
569 audioVolume->appVolume_.insert({appUid, appVolume});
570
571 audioVolume->SetAppVolume(appVolume);
572 }
573
574 /**
575 * @tc.name : Test AudioVolume API
576 * @tc.type : FUNC
577 * @tc.number: Monitor_001
578 * @tc.desc : Test AudioVolume interface.
579 */
580 HWTEST_F(AudioVolumeUnitTest, Monitor_001, TestSize.Level1)
581 {
582 auto audioVolume = std::make_shared<AudioVolume>();
583 ASSERT_TRUE(audioVolume != nullptr);
584
585 uint32_t sessionId = 0;
586 int32_t streamType = 0;
587 int32_t streamUsage = 0;
588 int32_t uid = 0;
589 int32_t pid = 0;
590 bool isSystemApp = false;
591 int32_t mode = 0;
592 bool isVKB = true;
593 StreamVolume streamVolume(sessionId, streamType, streamUsage, uid, pid, isSystemApp, mode, isVKB);
594 audioVolume->streamVolume_.insert({sessionId, streamVolume});
595 audioVolume->Monitor(sessionId, true);
596 }
597
598 /**
599 * @tc.name : Test AudioVolume API
600 * @tc.type : FUNC
601 * @tc.number: GetStopFadeoutState_001
602 * @tc.desc : Test AudioVolume interface.
603 */
604 HWTEST_F(AudioVolumeUnitTest, GetStopFadeoutState_001, TestSize.Level1)
605 {
606 auto audioVolume = std::make_shared<AudioVolume>();
607 ASSERT_TRUE(audioVolume != nullptr);
608
609 uint32_t streamIndex = 0;
610 auto ret = audioVolume->GetStopFadeoutState(streamIndex);
611 EXPECT_EQ(ret, INVALID_STATE);
612 }
613
614 /**
615 * @tc.name : Test AudioVolume API
616 * @tc.type : FUNC
617 * @tc.number: GetStopFadeoutState_002
618 * @tc.desc : Test AudioVolume interface.
619 */
620 HWTEST_F(AudioVolumeUnitTest, GetStopFadeoutState_002, TestSize.Level1)
621 {
622 auto audioVolume = std::make_shared<AudioVolume>();
623 ASSERT_TRUE(audioVolume != nullptr);
624
625 uint32_t streamIndex = 0;
626 audioVolume->stopFadeoutState_.insert({0, 0});
627 auto ret = audioVolume->GetStopFadeoutState(streamIndex);
628 EXPECT_EQ(ret, 0);
629 }
630
631 /**
632 * @tc.name : Test AudioVolume API
633 * @tc.type : FUNC
634 * @tc.number: GetSimpleBufferAvg_001
635 * @tc.desc : Test AudioVolume interface.
636 */
637 HWTEST_F(AudioVolumeUnitTest, GetSimpleBufferAvg_001, TestSize.Level1)
638 {
639 uint8_t ffer = 0;
640 uint8_t *buffer = &ffer;
641 int32_t length = 0;
642 auto ret = GetSimpleBufferAvg(buffer, length);
643 EXPECT_EQ(ret, -1);
644
645 length = 1;
646 GetSimpleBufferAvg(buffer, length);
647 }
648
649 /**
650 * @tc.name : Test AudioVolume API
651 * @tc.type : FUNC
652 * @tc.number: GetFadeStrategy_001
653 * @tc.desc : Test AudioVolume interface.
654 */
655 HWTEST_F(AudioVolumeUnitTest, GetFadeStrategy_001, TestSize.Level1)
656 {
657 auto audioVolume = std::make_shared<AudioVolume>();
658 ASSERT_TRUE(audioVolume != nullptr);
659
660 uint64_t expectedPlaybackDurationMs = 0;
661 auto ret = GetFadeStrategy(expectedPlaybackDurationMs);
662 EXPECT_EQ(ret, FADE_STRATEGY_DEFAULT);
663
664 expectedPlaybackDurationMs = 50;
665 ret = GetFadeStrategy(expectedPlaybackDurationMs);
666 EXPECT_EQ(ret, FADE_STRATEGY_DEFAULT);
667 }
668
669 /**
670 * @tc.name : Test AudioVolume API
671 * @tc.type : FUNC
672 * @tc.number: GetFadeStrategy_002
673 * @tc.desc : Test AudioVolume interface.
674 */
675 HWTEST_F(AudioVolumeUnitTest, GetFadeStrategy_002, TestSize.Level1)
676 {
677 auto audioVolume = std::make_shared<AudioVolume>();
678 ASSERT_TRUE(audioVolume != nullptr);
679
680 uint64_t expectedPlaybackDurationMs = 5;
681 auto ret = GetFadeStrategy(expectedPlaybackDurationMs);
682 EXPECT_EQ(ret, FADE_STRATEGY_NONE);
683
684 expectedPlaybackDurationMs = -1;
685 ret = GetFadeStrategy(expectedPlaybackDurationMs);
686 EXPECT_EQ(ret, FADE_STRATEGY_DEFAULT);
687
688 expectedPlaybackDurationMs = 15;
689 ret = GetFadeStrategy(expectedPlaybackDurationMs);
690 EXPECT_EQ(ret, FADE_STRATEGY_SHORTER);
691
692 expectedPlaybackDurationMs = 15;
693 ret = GetFadeStrategy(expectedPlaybackDurationMs);
694 EXPECT_EQ(ret, FADE_STRATEGY_SHORTER);
695 }
696
697 /**
698 * @tc.name : Test AudioVolume API
699 * @tc.type : FUNC
700 * @tc.number: SetDoNotDisturbStatusWhiteListVolume_001
701 * @tc.desc : Test AudioVolume interface.
702 */
703 HWTEST_F(AudioVolumeUnitTest, SetDoNotDisturbStatusWhiteListVolume_001, TestSize.Level1)
704 {
705 std::vector<std::map<std::string, std::string>> doNotDisturbStatusWhiteList;
706 std::map<std::string, std::string> obj;
707 obj["123"] = "1";
708 doNotDisturbStatusWhiteList.push_back(obj);
709 int32_t doNotDisturbStatusVolume = 1;
710 int32_t volumeType = 5;
711 int32_t appUid = 123;
712 int32_t sessionId = 123;
713 AudioVolume::GetInstance()->SetDoNotDisturbStatusWhiteListVolume(doNotDisturbStatusWhiteList);
714 int32_t ret = AudioVolume::GetInstance()->GetDoNotDisturbStatusVolume(volumeType, appUid, sessionId);
715 EXPECT_EQ(ret, doNotDisturbStatusVolume);
716 }
717
718 /**
719 * @tc.name : Test AudioVolume API
720 * @tc.type : FUNC
721 * @tc.number: SetDoNotDisturbStatus_001
722 * @tc.desc : Test AudioVolume interface.
723 */
724 HWTEST_F(AudioVolumeUnitTest, SetDoNotDisturbStatus_001, TestSize.Level1)
725 {
726 bool isDoNotDisturbStatus = true;
727 int32_t doNotDisturbStatusVolume = 0;
728 int32_t volumeType = 5;
729 int32_t appUid = 123;
730 int32_t sessionId = 123;
731 AudioVolume::GetInstance()->SetDoNotDisturbStatus(isDoNotDisturbStatus);
732 int32_t ret = AudioVolume::GetInstance()->GetDoNotDisturbStatusVolume(volumeType, appUid, sessionId);
733 EXPECT_EQ(ret, doNotDisturbStatusVolume);
734 }
735
736 /**
737 * @tc.name : Test GetVolume API
738 * @tc.type : FUNC
739 * @tc.number: GetVolume_005
740 * @tc.desc : Test GetVolume interface.
741 */
742 HWTEST_F(AudioVolumeUnitTest, GetVolume_005, TestSize.Level1)
743 {
744 uint32_t sessionId = 123;
745 int32_t streamType = 5;
746 const std::string deviceClass = "test";
747 VolumeValues volumes;
748
749 audioVolumeTest->streamVolume_.clear();
750
751 int32_t streamUsage = 0;
752 int32_t uid = 0;
753 int32_t pid = 0;
754 bool isSystemApp = true;
755 int32_t mode = 0;
756 bool isVKB = false;
757 StreamVolume streamVolume(sessionId, streamType, streamUsage, uid, pid, isSystemApp, mode, isVKB);
758 audioVolumeTest->streamVolume_.insert({sessionId, streamVolume});
759
760 audioVolumeTest->GetVolume(sessionId, streamType, deviceClass, &volumes);
761 EXPECT_EQ(audioVolumeTest->streamVolume_.empty(), false);
762 }
763
764 /**
765 * @tc.name : Test GetDoNotDisturbStatusVolume API
766 * @tc.type : FUNC
767 * @tc.number: GetDoNotDisturbStatusVolume_001
768 * @tc.desc : Test GetDoNotDisturbStatusVolume interface.
769 */
770 HWTEST_F(AudioVolumeUnitTest, GetDoNotDisturbStatusVolume_001, TestSize.Level1)
771 {
772 int32_t volumeType = STREAM_MEDIA;
773 int32_t appUid = 123;
774 uint32_t sessionId = 123;
775
776 audioVolumeTest->isDoNotDisturbStatus_ = true;
777
778 int32_t streamType = 0;
779 int32_t streamUsage = 0;
780 int32_t uid = 0;
781 int32_t pid = 0;
782 bool isSystemApp = true;
783 int32_t mode = 0;
784 bool isVKB = false;
785 StreamVolume streamVolume(sessionId, streamType, streamUsage, uid, pid, isSystemApp, mode, isVKB);
786 audioVolumeTest->streamVolume_.insert({sessionId, streamVolume});
787
788 uint32_t ret = audioVolumeTest->GetDoNotDisturbStatusVolume(volumeType, appUid, sessionId);
789 EXPECT_EQ(ret, 1);
790 }
791
792 /**
793 * @tc.name : Test GetDoNotDisturbStatusVolume API
794 * @tc.type : FUNC
795 * @tc.number: GetDoNotDisturbStatusVolume_002
796 * @tc.desc : Test GetDoNotDisturbStatusVolume interface.
797 */
798 HWTEST_F(AudioVolumeUnitTest, GetDoNotDisturbStatusVolume_002, TestSize.Level1)
799 {
800 int32_t volumeType = STREAM_MEDIA;
801 int32_t appUid = 5523;
802 uint32_t sessionId = 123;
803
804 audioVolumeTest->isDoNotDisturbStatus_ = true;
805
806 int32_t streamType = 0;
807 int32_t streamUsage = 0;
808 int32_t uid = 0;
809 int32_t pid = 0;
810 bool isSystemApp = false;
811 int32_t mode = 0;
812 StreamVolume streamVolume(sessionId, streamType, streamUsage, uid, pid, isSystemApp, mode, false);
813 audioVolumeTest->streamVolume_.insert({sessionId, streamVolume});
814
815 uint32_t ret = audioVolumeTest->GetDoNotDisturbStatusVolume(volumeType, appUid, sessionId);
816 EXPECT_EQ(ret, 1);
817 }
818
819 /**
820 * @tc.name : Test GetDoNotDisturbStatusVolume API
821 * @tc.type : FUNC
822 * @tc.number: GetDoNotDisturbStatusVolume_003
823 * @tc.desc : Test GetDoNotDisturbStatusVolume interface.
824 */
825 HWTEST_F(AudioVolumeUnitTest, GetDoNotDisturbStatusVolume_003, TestSize.Level1)
826 {
827 int32_t volumeType = STREAM_MEDIA;
828 int32_t appUid = 123;
829 uint32_t sessionId = 123;
830
831 audioVolumeTest->isDoNotDisturbStatus_ = true;
832
833 int32_t streamType = 0;
834 int32_t streamUsage = 0;
835 int32_t uid = 0;
836 int32_t pid = 0;
837 bool isSystemApp = false;
838 int32_t mode = 0;
839 StreamVolume streamVolume(sessionId, streamType, streamUsage, uid, pid, isSystemApp, mode, false);
840 audioVolumeTest->streamVolume_.insert({sessionId, streamVolume});
841 audioVolumeTest->doNotDisturbStatusWhiteListVolume_.insert({appUid, 1});
842
843 uint32_t ret = audioVolumeTest->GetDoNotDisturbStatusVolume(volumeType, appUid, sessionId);
844 EXPECT_EQ(ret, 1);
845 }
846
847 /**
848 * @tc.name : Test GetDoNotDisturbStatusVolume API
849 * @tc.type : FUNC
850 * @tc.number: GetDoNotDisturbStatusVolume_004
851 * @tc.desc : Test GetDoNotDisturbStatusVolume interface.
852 */
853 HWTEST_F(AudioVolumeUnitTest, GetDoNotDisturbStatusVolume_004, TestSize.Level1)
854 {
855 int32_t volumeType = STREAM_MEDIA;
856 int32_t appUid = 123;
857 uint32_t sessionId = 123;
858
859 audioVolumeTest->isDoNotDisturbStatus_ = true;
860
861 int32_t streamType = 0;
862 int32_t streamUsage = 0;
863 int32_t uid = 0;
864 int32_t pid = 0;
865 bool isSystemApp = false;
866 int32_t mode = 0;
867 StreamVolume streamVolume(sessionId, streamType, streamUsage, uid, pid, isSystemApp, mode, false);
868 audioVolumeTest->streamVolume_.insert({sessionId, streamVolume});
869 audioVolumeTest->doNotDisturbStatusWhiteListVolume_.insert({1, 1});
870
871 uint32_t ret = audioVolumeTest->GetDoNotDisturbStatusVolume(volumeType, appUid, sessionId);
872 EXPECT_EQ(ret, 1);
873 }
874
875 /**
876 * @tc.name : Test GetDoNotDisturbStatusVolume API
877 * @tc.type : FUNC
878 * @tc.number: GetDoNotDisturbStatusVolume_005
879 * @tc.desc : Test GetDoNotDisturbStatusVolume interface.
880 */
881 HWTEST_F(AudioVolumeUnitTest, GetDoNotDisturbStatusVolume_005, TestSize.Level1)
882 {
883 int32_t volumeType = STREAM_MEDIA;
884 int32_t appUid = 123;
885 uint32_t sessionId = 123;
886
887 audioVolumeTest->isDoNotDisturbStatus_ = true;
888
889 int32_t streamType = 0;
890 int32_t streamUsage = 0;
891 int32_t uid = 0;
892 int32_t pid = 0;
893 bool isSystemApp = false;
894 int32_t mode = 0;
895 StreamVolume streamVolume(sessionId, streamType, streamUsage, uid, pid, isSystemApp, mode, false);
896 audioVolumeTest->streamVolume_.insert({sessionId, streamVolume});
897 audioVolumeTest->doNotDisturbStatusWhiteListVolume_.insert({1, 1});
898
899 uint32_t ret = audioVolumeTest->GetDoNotDisturbStatusVolume(volumeType, appUid, sessionId);
900 EXPECT_EQ(ret, 1);
901 }
902
903 /**
904 * @tc.name : Test GetDoNotDisturbStatusVolume API
905 * @tc.type : FUNC
906 * @tc.number: GetDoNotDisturbStatusVolume_006
907 * @tc.desc : Test GetDoNotDisturbStatusVolume interface.
908 */
909 HWTEST_F(AudioVolumeUnitTest, GetDoNotDisturbStatusVolume_006, TestSize.Level1)
910 {
911 int32_t volumeType = STREAM_DTMF;
912 int32_t appUid = 123;
913 uint32_t sessionId = 123;
914
915 audioVolumeTest->isDoNotDisturbStatus_ = true;
916
917 uint32_t ret = audioVolumeTest->GetDoNotDisturbStatusVolume(volumeType, appUid, sessionId);
918 EXPECT_EQ(ret, 0);
919 }
920
921 /**
922 * @tc.name : Test GetDoNotDisturbStatusVolume API
923 * @tc.type : FUNC
924 * @tc.number: GetDoNotDisturbStatusVolume_007
925 * @tc.desc : Test GetDoNotDisturbStatusVolume interface.
926 */
927 HWTEST_F(AudioVolumeUnitTest, GetDoNotDisturbStatusVolume_007, TestSize.Level1)
928 {
929 int32_t volumeType = STREAM_MEDIA;
930 int32_t appUid = 123;
931 uint32_t sessionId = 123;
932
933 audioVolumeTest->isDoNotDisturbStatus_ = true;
934 audioVolumeTest->streamVolume_.clear();
935 uint32_t ret = audioVolumeTest->GetDoNotDisturbStatusVolume(volumeType, appUid, sessionId);
936 EXPECT_EQ(ret, 1);
937 }
938
939 /**
940 * @tc.name : Test AudioVolume API
941 * @tc.type : FUNC
942 * @tc.number: SetStreamVolume_003
943 * @tc.desc : Test AudioVolume interface.
944 */
945 HWTEST_F(AudioVolumeUnitTest, SetStreamVolume_003, TestSize.Level1)
946 {
947 uint32_t sessionId = 1;
948
949 audioVolumeTest->streamVolume_.clear();
950
951 float ret = audioVolumeTest->GetStreamVolume(sessionId);
952 EXPECT_EQ(ret, 1.0f);
953 }
954
955 /**
956 * @tc.name : Test SaveAdjustStreamVolumeInfo API
957 * @tc.type : FUNC
958 * @tc.number: SetStreamVolume_003
959 * @tc.desc : Test AudioVolume interface.
960 */
961 HWTEST_F(AudioVolumeUnitTest, SaveAdjustStreamVolumeInfo_003, TestSize.Level1)
962 {
963 uint32_t sessionId = 1;
964 float volume = 0.1f;
965 std::string invocationTime = "test";
966 uint32_t code = 3;
967
968 audioVolumeTest->SaveAdjustStreamVolumeInfo(volume, sessionId, invocationTime, code);
969 EXPECT_NE(nullptr, audioVolumeTest);
970 }
971
972 /**
973 * @tc.name : Test GetStreamVolumeInfo API
974 * @tc.type : FUNC
975 * @tc.number: GetStreamVolumeInfo_003
976 * @tc.desc : Test AudioVolume interface.
977 */
978 HWTEST_F(AudioVolumeUnitTest, GetStreamVolumeInfo_001, TestSize.Level1)
979 {
980 AdjustStreamVolume volumeType = static_cast<AdjustStreamVolume>(3);
981 std::vector<AdjustStreamVolumeInfo> adjustStreamVolumeInfoTest;
982
983 adjustStreamVolumeInfoTest = audioVolumeTest->GetStreamVolumeInfo(volumeType);
984 EXPECT_EQ(adjustStreamVolumeInfoTest.empty(), true);
985 }
986
987 /**
988 * @tc.name : Test GetAppVolumeInternal API
989 * @tc.type : FUNC
990 * @tc.number: GetAppVolumeInternal_001
991 * @tc.desc : Test AudioVolume interface.
992 */
993 HWTEST_F(AudioVolumeUnitTest, GetAppVolumeInternal_001, TestSize.Level1)
994 {
995 int32_t appUid = 1;
996 AudioVolumeMode mode = AUDIOSTREAM_VOLUMEMODE_SYSTEM_GLOBAL;
997 audioVolumeTest->appVolume_.clear();
998
999 float ret = audioVolumeTest->GetAppVolume(appUid, mode);
1000 EXPECT_EQ(ret, 1.0f);
1001 }
1002
1003 /**
1004 * @tc.name : Test GetAppVolumeInternal API
1005 * @tc.type : FUNC
1006 * @tc.number: GetAppVolumeInternal_002
1007 * @tc.desc : Test AudioVolume interface.
1008 */
1009 HWTEST_F(AudioVolumeUnitTest, GetAppVolumeInternal_002, TestSize.Level1)
1010 {
1011 int32_t appUid = 1;
1012 AudioVolumeMode mode = AUDIOSTREAM_VOLUMEMODE_SYSTEM_GLOBAL;
1013 float volume = 2.0f;
1014 int32_t volumeLevel = 1;
1015 bool isMuted = true;
1016 AppVolume appVolume(appUid, volume, volumeLevel, isMuted);
1017 appVolume.totalVolume_ = 3.0f;
1018 audioVolumeTest->appVolume_.insert({appUid, appVolume});
1019
1020 float ret = audioVolumeTest->GetAppVolume(appUid, mode);
1021 EXPECT_EQ(ret, appVolume.totalVolume_);
1022 EXPECT_EQ(ret, 3.0f);
1023 }
1024
1025 /**
1026 * @tc.name : Test GetAppVolumeInternal API
1027 * @tc.type : FUNC
1028 * @tc.number: GetAppVolumeInternal_003
1029 * @tc.desc : Test AudioVolume interface.
1030 */
1031 HWTEST_F(AudioVolumeUnitTest, GetAppVolumeInternal_003, TestSize.Level1)
1032 {
1033 int32_t appUid = 1;
1034 AudioVolumeMode mode = AUDIOSTREAM_VOLUMEMODE_SYSTEM_GLOBAL;
1035 float volume = 2.0f;
1036 int32_t volumeLevel = 1;
1037 bool isMuted = false;
1038 AppVolume appVolume(appUid, volume, volumeLevel, isMuted);
1039 appVolume.totalVolume_ = 3.0f;
1040 audioVolumeTest->appVolume_.clear();
1041 audioVolumeTest->appVolume_.insert({appUid, appVolume});
1042
1043 float ret = audioVolumeTest->GetAppVolume(appUid, mode);
1044 EXPECT_EQ(ret, 1.0);
1045 }
1046
1047 /**
1048 * @tc.name : Test GetAppVolumeInternal API
1049 * @tc.type : FUNC
1050 * @tc.number: GetAppVolumeInternal_004
1051 * @tc.desc : Test AudioVolume interface.
1052 */
1053 HWTEST_F(AudioVolumeUnitTest, GetAppVolumeInternal_004, TestSize.Level1)
1054 {
1055 int32_t appUid = 1;
1056 AudioVolumeMode mode = AUDIOSTREAM_VOLUMEMODE_APP_INDIVIDUAL;
1057 float volume = 2.0f;
1058 int32_t volumeLevel = 1;
1059 bool isMuted = false;
1060 AppVolume appVolume(appUid, volume, volumeLevel, isMuted);
1061 appVolume.totalVolume_ = 3.0f;
1062 audioVolumeTest->appVolume_.insert({appUid, appVolume});
1063
1064 float ret = audioVolumeTest->GetAppVolume(appUid, mode);
1065 EXPECT_EQ(ret, appVolume.totalVolume_);
1066 EXPECT_EQ(ret, 3.0f);
1067 }
1068
1069 /**
1070 * @tc.name : Test SetAppVolumeMute API
1071 * @tc.type : FUNC
1072 * @tc.number: SetAppVolumeMute_002
1073 * @tc.desc : Test AudioVolume interface.
1074 */
1075 HWTEST_F(AudioVolumeUnitTest, SetAppVolumeMute_002, TestSize.Level1)
1076 {
1077 int32_t appUid = 1;
1078 bool isMuted = false;
1079
1080 audioVolumeTest->appVolume_.clear();
1081 audioVolumeTest->streamVolume_.clear();
1082
1083 audioVolumeTest->SetAppVolumeMute(appUid, isMuted);
1084 EXPECT_EQ(audioVolumeTest->appVolume_.empty(), false);
1085 EXPECT_EQ(audioVolumeTest->streamVolume_.empty(), true);
1086 }
1087
1088 /**
1089 * @tc.name : Test SetAppVolumeMute API
1090 * @tc.type : FUNC
1091 * @tc.number: SetAppVolumeMute_003
1092 * @tc.desc : Test AudioVolume interface stream.GetAppUid() != appUid.
1093 */
1094 HWTEST_F(AudioVolumeUnitTest, SetAppVolumeMute_003, TestSize.Level1)
1095 {
1096 int32_t appUid = 1;
1097 bool isMuted = false;
1098
1099 audioVolumeTest->appVolume_.clear();
1100 audioVolumeTest->streamVolume_.clear();
1101
1102 uint32_t sessionId = 123;
1103 int32_t streamType = 0;
1104 int32_t streamUsage = 0;
1105 int32_t uid = 123;
1106 int32_t pid = 0;
1107 bool isSystemApp = false;
1108 int32_t mode = 0;
1109 StreamVolume streamVolume(sessionId, streamType, streamUsage, uid, pid, isSystemApp, mode, false);
1110 audioVolumeTest->streamVolume_.insert({sessionId, streamVolume});
1111
1112 audioVolumeTest->SetAppVolumeMute(appUid, isMuted);
1113 EXPECT_EQ(audioVolumeTest->appVolume_.empty(), false);
1114 EXPECT_EQ(audioVolumeTest->streamVolume_.empty(), false);
1115 }
1116
1117 /**
1118 * @tc.name : Test SetAppVolumeMute API
1119 * @tc.type : FUNC
1120 * @tc.number: SetAppVolumeMute_004
1121 * @tc.desc : Test AudioVolume interface
1122 */
1123 HWTEST_F(AudioVolumeUnitTest, SetAppVolumeMute_004, TestSize.Level1)
1124 {
1125 int32_t appUid = 1;
1126 bool isMuted = true;
1127
1128 audioVolumeTest->appVolume_.clear();
1129 audioVolumeTest->streamVolume_.clear();
1130
1131 uint32_t sessionId = 123;
1132 int32_t streamType = 0;
1133 int32_t streamUsage = 0;
1134 int32_t uid = 1;
1135 int32_t pid = 0;
1136 bool isSystemApp = false;
1137 int32_t mode = 0;
1138 StreamVolume streamVolume(sessionId, streamType, streamUsage, uid, pid, isSystemApp, mode, false);
1139 audioVolumeTest->streamVolume_.insert({sessionId, streamVolume});
1140
1141 audioVolumeTest->SetAppVolumeMute(appUid, isMuted);
1142 EXPECT_EQ(audioVolumeTest->appVolume_.empty(), false);
1143 EXPECT_EQ(audioVolumeTest->streamVolume_.empty(), false);
1144
1145 auto it = audioVolumeTest->streamVolume_.find(sessionId);
1146 EXPECT_NE(it, audioVolumeTest->streamVolume_.end());
1147 EXPECT_EQ(it->second.appVolume_, 0.0f);
1148 EXPECT_EQ(it->second.totalVolume_, 0.0f);
1149 }
1150
1151 /**
1152 * @tc.name : Test SetAppVolumeMute API
1153 * @tc.type : FUNC
1154 * @tc.number: SetAppVolumeMute_005
1155 * @tc.desc : Test AudioVolume interface
1156 */
1157 HWTEST_F(AudioVolumeUnitTest, SetAppVolumeMute_005, TestSize.Level1)
1158 {
1159 int32_t appUid = 1;
1160 bool isMuted = false;
1161
1162 audioVolumeTest->appVolume_.clear();
1163 audioVolumeTest->streamVolume_.clear();
1164
1165 uint32_t sessionId = 123;
1166 int32_t streamType = 0;
1167 int32_t streamUsage = 0;
1168 int32_t uid = 1;
1169 int32_t pid = 0;
1170 bool isSystemApp = false;
1171 int32_t mode = 0;
1172 StreamVolume streamVolume(sessionId, streamType, streamUsage, uid, pid, isSystemApp, mode, false);
1173 audioVolumeTest->streamVolume_.insert({sessionId, streamVolume});
1174
1175 audioVolumeTest->SetAppVolumeMute(appUid, isMuted);
1176 EXPECT_EQ(audioVolumeTest->appVolume_.empty(), false);
1177 EXPECT_EQ(audioVolumeTest->streamVolume_.empty(), false);
1178
1179 auto it = audioVolumeTest->streamVolume_.find(sessionId);
1180 EXPECT_EQ(it->second.appVolume_, 1.0f);
1181 EXPECT_EQ(it->second.totalVolume_, 1.0f);
1182 }
1183
1184 /**
1185 * @tc.name : Test SetAppVolumeMute API
1186 * @tc.type : FUNC
1187 * @tc.number: SetAppVolumeMute_006
1188 * @tc.desc : Test AudioVolume interface
1189 */
1190 HWTEST_F(AudioVolumeUnitTest, SetAppVolumeMute_006, TestSize.Level1)
1191 {
1192 int32_t appUid = 1;
1193 bool isMuted = false;
1194
1195 audioVolumeTest->appVolume_.clear();
1196 audioVolumeTest->streamVolume_.clear();
1197
1198 uint32_t sessionId = 123;
1199 int32_t streamType = 0;
1200 int32_t streamUsage = 0;
1201 int32_t uid = 1;
1202 int32_t pid = 0;
1203 bool isSystemApp = false;
1204 int32_t mode = 1;
1205 StreamVolume streamVolume(sessionId, streamType, streamUsage, uid, pid, isSystemApp, mode, false);
1206 audioVolumeTest->streamVolume_.insert({sessionId, streamVolume});
1207
1208 audioVolumeTest->SetAppVolumeMute(appUid, isMuted);
1209 EXPECT_EQ(audioVolumeTest->appVolume_.empty(), false);
1210 EXPECT_EQ(audioVolumeTest->streamVolume_.empty(), false);
1211
1212 auto it = audioVolumeTest->streamVolume_.find(sessionId);
1213 EXPECT_EQ(it->second.appVolume_, 1.0f);
1214 EXPECT_EQ(it->second.totalVolume_, 1.0f);
1215 }
1216
1217 /**
1218 * @tc.name : Test SetAppVolume API
1219 * @tc.type : FUNC
1220 * @tc.number: SetAppVolume_002
1221 * @tc.desc : Test AudioVolume interface
1222 */
1223 HWTEST_F(AudioVolumeUnitTest, SetAppVolume_002, TestSize.Level1)
1224 {
1225 int32_t appUid = 1;
1226 float volume = 2.0f;
1227 int32_t volumeLevel = 1;
1228 bool isMuted = true;
1229 AppVolume appVolume(appUid, volume, volumeLevel, isMuted);
1230 appVolume.totalVolume_ = 3.0f;
1231
1232 audioVolumeTest->appVolume_.clear();
1233 audioVolumeTest->streamVolume_.clear();
1234
1235 audioVolumeTest->SetAppVolume(appVolume);
1236 EXPECT_EQ(audioVolumeTest->appVolume_.empty(), false);
1237 EXPECT_EQ(audioVolumeTest->streamVolume_.empty(), true);
1238
1239 EXPECT_EQ(appVolume.totalVolume_, 0.0f);
1240 }
1241
1242 /**
1243 * @tc.name : Test SetAppVolume API
1244 * @tc.type : FUNC
1245 * @tc.number: SetAppVolume_003
1246 * @tc.desc : Test AudioVolume interface stream.GetAppUid() != appUid
1247 */
1248 HWTEST_F(AudioVolumeUnitTest, SetAppVolume_003, TestSize.Level1)
1249 {
1250 int32_t appUid = 1;
1251 float volume = 2.0f;
1252 int32_t volumeLevel = 1;
1253 bool isMuted = false;
1254 AppVolume appVolume(appUid, volume, volumeLevel, isMuted);
1255 appVolume.totalVolume_ = 3.0f;
1256
1257 audioVolumeTest->appVolume_.clear();
1258 audioVolumeTest->streamVolume_.clear();
1259
1260 uint32_t sessionId = 123;
1261 int32_t streamType = 0;
1262 int32_t streamUsage = 0;
1263 int32_t uid = 1;
1264 int32_t pid = 0;
1265 bool isSystemApp = false;
1266 int32_t mode = 1;
1267 StreamVolume streamVolume(sessionId, streamType, streamUsage, uid, pid, isSystemApp, mode, false);
1268 audioVolumeTest->streamVolume_.insert({sessionId, streamVolume});
1269
1270 audioVolumeTest->SetAppVolume(appVolume);
1271 EXPECT_EQ(audioVolumeTest->appVolume_.empty(), false);
1272 EXPECT_EQ(audioVolumeTest->streamVolume_.empty(), false);
1273 EXPECT_EQ(appVolume.totalVolume_, 2.0f);
1274 }
1275
1276 /**
1277 * @tc.name : Test SetAppVolume API
1278 * @tc.type : FUNC
1279 * @tc.number: SetAppVolume_004
1280 * @tc.desc : Test AudioVolume interface
1281 */
1282 HWTEST_F(AudioVolumeUnitTest, SetAppVolume_004, TestSize.Level1)
1283 {
1284 int32_t appUid = 123;
1285 float volume = 2.0f;
1286 int32_t volumeLevel = 1;
1287 bool isMuted = true;
1288 AppVolume appVolume(appUid, volume, volumeLevel, isMuted);
1289 appVolume.totalVolume_ = 3.0f;
1290
1291 audioVolumeTest->appVolume_.clear();
1292 audioVolumeTest->streamVolume_.clear();
1293
1294 uint32_t sessionId = 123;
1295 int32_t streamType = 0;
1296 int32_t streamUsage = 0;
1297 int32_t pid = 0;
1298 bool isSystemApp = false;
1299 int32_t mode = 1;
1300 StreamVolume streamVolume(sessionId, streamType, streamUsage, appUid, pid, isSystemApp, mode, false);
1301 audioVolumeTest->streamVolume_.insert({sessionId, streamVolume});
1302
1303 audioVolumeTest->SetAppVolume(appVolume);
1304 EXPECT_EQ(audioVolumeTest->appVolume_.empty(), false);
1305 EXPECT_EQ(audioVolumeTest->streamVolume_.empty(), false);
1306 EXPECT_EQ(appVolume.totalVolume_, 0.0f);
1307
1308 auto it = audioVolumeTest->streamVolume_.find(appUid);
1309 EXPECT_EQ(it->second.appVolume_, 0.0f);
1310 EXPECT_EQ(it->second.totalVolume_, 0.0f);
1311 }
1312
1313 /**
1314 * @tc.name : Test SetAppVolume API
1315 * @tc.type : FUNC
1316 * @tc.number: SetAppVolume_005
1317 * @tc.desc : Test AudioVolume interface stream.GetVolumeMode() == AUDIOSTREAM_VOLUMEMODE_SYSTEM_GLOBAL
1318 */
1319 HWTEST_F(AudioVolumeUnitTest, SetAppVolume_005, TestSize.Level1)
1320 {
1321 int32_t appUid = 123;
1322 float volume = 2.0f;
1323 int32_t volumeLevel = 1;
1324 bool isMuted = false;
1325 AppVolume appVolume(appUid, volume, volumeLevel, isMuted);
1326 appVolume.totalVolume_ = 3.0f;
1327
1328 audioVolumeTest->appVolume_.clear();
1329 audioVolumeTest->streamVolume_.clear();
1330
1331 uint32_t sessionId = 123;
1332 int32_t streamType = 0;
1333 int32_t streamUsage = 0;
1334 int32_t uid = 1;
1335 int32_t pid = 0;
1336 bool isSystemApp = false;
1337 int32_t mode = 0;
1338 StreamVolume streamVolume(sessionId, streamType, streamUsage, uid, pid, isSystemApp, mode, false);
1339 audioVolumeTest->streamVolume_.insert({sessionId, streamVolume});
1340
1341 audioVolumeTest->SetAppVolume(appVolume);
1342 EXPECT_EQ(audioVolumeTest->appVolume_.empty(), false);
1343 EXPECT_EQ(audioVolumeTest->streamVolume_.empty(), false);
1344 EXPECT_EQ(appVolume.totalVolume_, 2.0f);
1345
1346 auto it = audioVolumeTest->streamVolume_.find(appUid);
1347 EXPECT_EQ(it->second.appVolume_, 1.0f);
1348 EXPECT_EQ(it->second.totalVolume_, 1.0f);
1349 }
1350
1351 /**
1352 * @tc.name : Test SetAppVolume API
1353 * @tc.type : FUNC
1354 * @tc.number: SetAppVolume_006
1355 * @tc.desc : Test AudioVolume interface stream.GetVolumeMode() != AUDIOSTREAM_VOLUMEMODE_SYSTEM_GLOBAL
1356 */
1357 HWTEST_F(AudioVolumeUnitTest, SetAppVolume_006, TestSize.Level1)
1358 {
1359 int32_t appUid = 123;
1360 float volume = 2.0f;
1361 int32_t volumeLevel = 1;
1362 bool isMuted = false;
1363 AppVolume appVolume(appUid, volume, volumeLevel, isMuted);
1364 appVolume.totalVolume_ = 3.0f;
1365
1366 audioVolumeTest->appVolume_.clear();
1367 audioVolumeTest->streamVolume_.clear();
1368
1369 uint32_t sessionId = 123;
1370 int32_t streamType = 0;
1371 int32_t streamUsage = 0;
1372 int32_t pid = 0;
1373 bool isSystemApp = false;
1374 int32_t mode = AUDIOSTREAM_VOLUMEMODE_APP_INDIVIDUAL;
1375 StreamVolume streamVolume(sessionId, streamType, streamUsage, appUid, pid, isSystemApp, mode, false);
1376 audioVolumeTest->streamVolume_.insert({sessionId, streamVolume});
1377
1378 audioVolumeTest->SetAppVolume(appVolume);
1379 EXPECT_EQ(audioVolumeTest->appVolume_.empty(), false);
1380 EXPECT_EQ(audioVolumeTest->streamVolume_.empty(), false);
1381 EXPECT_EQ(appVolume.totalVolume_, 2.0f);
1382
1383 auto it = audioVolumeTest->streamVolume_.find(appUid);
1384 EXPECT_EQ(it->second.appVolume_, 2.0f);
1385 }
1386
1387 /**
1388 * @tc.name : Test SetSystemVolume API
1389 * @tc.type : FUNC
1390 * @tc.number: SetSystemVolume_001
1391 * @tc.desc : Test AudioVolume interface
1392 */
1393 HWTEST_F(AudioVolumeUnitTest, SetSystemVolume_005, TestSize.Level1)
1394 {
1395 audioVolumeTest->systemVolume_.clear();
1396 int32_t volumeType = 0;
1397 std::string deviceClass = "test";
1398 float volume = 2.0f;
1399 int32_t volumeLevel = 2;
1400 audioVolumeTest->SetSystemVolume(volumeType, deviceClass, volume, volumeLevel);
1401
1402 EXPECT_EQ(audioVolumeTest->systemVolume_.empty(), false);
1403
1404 std::string key = std::to_string(volumeType) + deviceClass;
1405 auto it = audioVolumeTest->systemVolume_.find(key);
1406 EXPECT_EQ(it->second.totalVolume_, volume);
1407 }
1408
1409 /**
1410 * @tc.name : Test GetSimpleBufferAvg API
1411 * @tc.type : FUNC
1412 * @tc.number: GetSimpleBufferAvg_002
1413 * @tc.desc : Test GetSimpleBufferAvg interface
1414 */
1415 HWTEST_F(AudioVolumeUnitTest, GetSimpleBufferAvg_002, TestSize.Level1)
1416 {
1417 uint8_t buffer = 1;
1418 int32_t length = 1;
1419 auto ret = GetSimpleBufferAvg(&buffer, length);
1420 EXPECT_EQ(ret, 1);
1421 }
1422 /**
1423 * @tc.name : Test GetCurVolume_001 API
1424 * @tc.type : FUNC
1425 * @tc.number: GetCurVolume_001
1426 * @tc.desc : Test GetCurVolume_001 interface
1427 */
1428 HWTEST_F(AudioVolumeUnitTest, GetCurVolume_001, TestSize.Level1)
1429 {
1430 uint32_t sessionId = 1;
1431 const char *deviceClass = "device";
1432 struct VolumeValues volumes;
1433 float result = GetCurVolume(sessionId, nullptr, deviceClass, &volumes);
1434 EXPECT_FLOAT_EQ(result, 1.0f);
1435
1436 const char *streamType = "stream";
1437 result = GetCurVolume(sessionId, streamType, nullptr, &volumes);
1438 EXPECT_FLOAT_EQ(result, 1.0f);
1439 }
1440
1441 /**
1442 * @tc.name : Test GetCurVolume_002 API
1443 * @tc.type : FUNC
1444 * @tc.number: GetCurVolume_002
1445 * @tc.desc : Test GetCurVolume_002 interface
1446 */
1447 HWTEST_F(AudioVolumeUnitTest, GetStopFadeoutState_003, TestSize.Level1)
1448 {
1449 uint32_t streamIndex = -1;
1450 float result = GetStopFadeoutState(streamIndex);
1451 EXPECT_EQ(result, INVALID_STATE);
1452
1453 streamIndex = 1;
1454 result = GetStopFadeoutState(streamIndex);
1455 EXPECT_EQ(result, INVALID_STATE);
1456 }
1457
1458 /**
1459 * @tc.name : Test GetCurVolume_002 API
1460 * @tc.type : FUNC
1461 * @tc.number: GetCurVolume_002
1462 * @tc.desc : Test GetCurVolume_002 interface
1463 */
1464 HWTEST_F(AudioVolumeUnitTest, GetFadeStrategy_003, TestSize.Level1)
1465 {
1466 uint64_t DURATION_TIME_DEFAULT = 40;
1467 uint64_t DURATION_TIME_SHORT = 10;
1468 uint64_t DURATION_INIT = 0;
1469 EXPECT_EQ(FADE_STRATEGY_DEFAULT, GetFadeStrategy(DURATION_INIT));
1470 EXPECT_EQ(FADE_STRATEGY_DEFAULT, GetFadeStrategy(DURATION_TIME_DEFAULT + 1));
1471 EXPECT_EQ(FADE_STRATEGY_NONE, GetFadeStrategy(DURATION_TIME_SHORT));
1472 EXPECT_EQ(FADE_STRATEGY_NONE, GetFadeStrategy(DURATION_INIT + 1));
1473 EXPECT_EQ(FADE_STRATEGY_SHORTER, GetFadeStrategy(DURATION_TIME_SHORT + 1));
1474 EXPECT_EQ(FADE_STRATEGY_SHORTER, GetFadeStrategy(DURATION_TIME_DEFAULT - 1));
1475 EXPECT_EQ(FADE_STRATEGY_SHORTER, GetFadeStrategy(DURATION_TIME_DEFAULT));
1476 }
1477
1478 /**
1479 * @tc.name : Test SetAppVolumeMute API
1480 * @tc.type : FUNC
1481 * @tc.number: SetAppVolumeMute_007
1482 * @tc.desc : Test AudioVolume interface.
1483 */
1484 HWTEST_F(AudioVolumeUnitTest, SetAppVolumeMute_007, TestSize.Level1)
1485 {
1486 bool isMuted = true;
1487 int32_t appuid = 123;
1488 ASSERT_TRUE(AudioVolume::GetInstance() != nullptr);
1489 AudioVolume::GetInstance()->SetAppVolumeMute(appuid, isMuted);
1490
1491 isMuted = false;
1492 AudioVolume::GetInstance()->SetAppVolumeMute(appuid, isMuted);
1493
1494 appuid = -1;
1495 AudioVolume::GetInstance()->SetAppVolumeMute(appuid, isMuted);
1496 }
1497
1498 /**
1499 * @tc.name : Test AudioVolume API
1500 * @tc.type : FUNC
1501 * @tc.number: SetOffloadType_001
1502 * @tc.desc : Test AudioVolume interface.
1503 */
1504 HWTEST_F(AudioVolumeUnitTest, SetOffloadType_001, TestSize.Level1)
1505 {
1506 uint32_t streamIndex = 1;
1507 int32_t offloadType = OFFLOAD_ACTIVE_BACKGROUND;
1508 AudioVolume::GetInstance()->SetOffloadType(streamIndex, offloadType);
1509 int32_t getOffloadType = AudioVolume::GetInstance()->GetOffloadType(streamIndex);
1510 EXPECT_EQ(getOffloadType, offloadType);
1511 }
1512
1513 /**
1514 * @tc.name : Test AudioVolume API
1515 * @tc.type : FUNC
1516 * @tc.number: SetOffloadType_002
1517 * @tc.desc : Test AudioVolume interface.
1518 */
1519 HWTEST_F(AudioVolumeUnitTest, SetOffloadType_002, TestSize.Level1)
1520 {
1521 uint32_t streamIndex = 1;
1522 AudioVolume::GetInstance()->offloadType_.clear();
1523 uint32_t ret = AudioVolume::GetInstance()->GetOffloadType(streamIndex);
1524 EXPECT_EQ(ret, OFFLOAD_DEFAULT);
1525 }
1526
1527 /**
1528 * @tc.name : Test AudioVolume
1529 * @tc.number: SetAppRingMuted_001
1530 * @tc.desc : Test SetAppRingMuted interface.
1531 */
1532 HWTEST_F(AudioVolumeUnitTest, SetAppRingMuted_001, TestSize.Level1)
1533 {
1534 bool isMuted = true;
1535 int32_t appUid = 123;
1536 int32_t sessionId = 10001;
1537 int32_t pid = 1;
1538 AudioStreamType streamType = STREAM_RING;
1539 StreamUsage streamUsage = STREAM_USAGE_RINGTONE;
1540
1541 AppVolume appVolume(appUid, 1.0f, 0, true);
1542 audioVolumeTest->appVolume_.emplace(appUid, appVolume);
1543
1544 StreamVolume streamVolume(sessionId, streamType, streamUsage, appUid, pid, false, 1, false);
1545 audioVolumeTest->streamVolume_.emplace(sessionId, streamVolume);
1546
1547 bool result = audioVolumeTest->SetAppRingMuted(appUid, isMuted);
1548
1549 EXPECT_EQ(result, true);
1550
1551 audioVolumeTest->appVolume_.clear();
1552 audioVolumeTest->streamVolume_.clear();
1553 }
1554
1555 /**
1556 * @tc.name : Test AudioVolume
1557 * @tc.number: SetAppRingMuted_002
1558 * @tc.desc : Test SetAppRingMuted interface.
1559 */
1560 HWTEST_F(AudioVolumeUnitTest, SetAppRingMuted_002, TestSize.Level1)
1561 {
1562 bool isMuted = false;
1563 int32_t appUid = 123;
1564 int32_t sessionId = 10001;
1565 int32_t pid = 1;
1566 AudioStreamType streamType = STREAM_RING;
1567 StreamUsage streamUsage = STREAM_USAGE_RINGTONE;
1568
1569 StreamVolume streamVolume(sessionId, streamType, streamUsage, appUid, pid, false, 1, false);
1570 audioVolumeTest->streamVolume_.emplace(sessionId, streamVolume);
1571
1572 bool result = audioVolumeTest->SetAppRingMuted(appUid, isMuted);
1573
1574 EXPECT_EQ(result, true);
1575
1576 audioVolumeTest->appVolume_.clear();
1577 audioVolumeTest->streamVolume_.clear();
1578 }
1579
1580 /**
1581 * @tc.name : Test AudioVolume
1582 * @tc.number: SetAppRingMuted_003
1583 * @tc.desc : Test SetAppRingMuted interface.
1584 */
1585 HWTEST_F(AudioVolumeUnitTest, SetAppRingMuted_003, TestSize.Level1)
1586 {
1587 bool isMuted = false;
1588 int32_t appUid = 123;
1589 int32_t sessionId = 10001;
1590 int32_t pid = 1;
1591 AudioStreamType streamType = STREAM_VOICE_COMMUNICATION;
1592 StreamUsage streamUsage = STREAM_USAGE_VOICE_COMMUNICATION;
1593
1594 AppVolume appVolume(appUid, 1.0f, 0, true);
1595 audioVolumeTest->appVolume_.emplace(appUid, appVolume);
1596
1597 StreamVolume streamVolume(sessionId, streamType, streamUsage, appUid, pid, false, 1, false);
1598 audioVolumeTest->streamVolume_.emplace(sessionId, streamVolume);
1599
1600 bool result = audioVolumeTest->SetAppRingMuted(appUid, isMuted);
1601
1602 EXPECT_EQ(result, false);
1603
1604 audioVolumeTest->appVolume_.clear();
1605 audioVolumeTest->streamVolume_.clear();
1606 }
1607
1608 /**
1609 * @tc.name : Test AudioVolume
1610 * @tc.number: SetAppRingMuted_004
1611 * @tc.desc : Test SetAppRingMuted interface.
1612 */
1613 HWTEST_F(AudioVolumeUnitTest, SetAppRingMuted_004, TestSize.Level1)
1614 {
1615 bool isMuted = false;
1616 int32_t appUid = 123;
1617 int32_t anotherAppUid = 456;
1618 int32_t sessionId = 10001;
1619 int32_t pid = 1;
1620 AudioStreamType streamType = STREAM_RING;
1621 StreamUsage streamUsage = STREAM_USAGE_RINGTONE;
1622
1623 AppVolume appVolume(appUid, 1.0f, 0, true);
1624 audioVolumeTest->appVolume_.emplace(appUid, appVolume);
1625
1626 StreamVolume streamVolume(sessionId, streamType, streamUsage, appUid, pid, false, 1, false);
1627 audioVolumeTest->streamVolume_.emplace(sessionId, streamVolume);
1628
1629 bool result = audioVolumeTest->SetAppRingMuted(anotherAppUid, isMuted);
1630
1631 EXPECT_EQ(result, false);
1632
1633 audioVolumeTest->appVolume_.clear();
1634 audioVolumeTest->streamVolume_.clear();
1635 }
1636 } // namespace OHOS::AudioStandard
1637 } // namespace OHOS
1638