1 /*
2 * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "audio_background_manager_unit_test.h"
17 #include "audio_common_utils.h"
18
19 using namespace testing;
20 using namespace testing::ext;
21
22 namespace OHOS {
23 namespace AudioStandard {
24
SetUp(void)25 void AudioBackgroundManagerUnitTest::SetUp(void) {}
26
TearDown(void)27 void AudioBackgroundManagerUnitTest::TearDown(void) {}
28
29 /**
30 * @tc.name : Test SubscribeBackgroundTask API
31 * @tc.type : FUNC
32 * @tc.number: AudioBackgroundManager_001
33 * @tc.desc : Test SubscribeBackgroundTask
34 */
35 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_001, TestSize.Level1)
36 {
37 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
38 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
39 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
40
41 audioBackgroundManagerTest_->backgroundTaskListener_ = nullptr;
42 audioBackgroundManagerTest_->SubscribeBackgroundTask();
43 ASSERT_TRUE(audioBackgroundManagerTest_->backgroundTaskListener_ != nullptr);
44 }
45
46 /**
47 * @tc.name : Test SubscribeBackgroundTask API
48 * @tc.type : FUNC
49 * @tc.number: AudioBackgroundManager_002
50 * @tc.desc : Test SubscribeBackgroundTask
51 */
52 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_002, TestSize.Level1)
53 {
54 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
55 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
56 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
57
58 audioBackgroundManagerTest_->backgroundTaskListener_ = std::make_shared<BackgroundTaskListener>();
59
60 audioBackgroundManagerTest_->SubscribeBackgroundTask();
61 ASSERT_TRUE(audioBackgroundManagerTest_->backgroundTaskListener_ != nullptr);
62 }
63
64
65 /**
66 * @tc.name : Test IsAllowedPlayback API
67 * @tc.type : FUNC
68 * @tc.number: AudioBackgroundManager_003
69 * @tc.desc : Test IsAllowedPlayback
70 */
71 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_003, TestSize.Level1)
72 {
73 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
74 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
75 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
76
77 int32_t pid = 0;
78 AppState appState;
79 audioBackgroundManagerTest_->appStatesMap_.clear();
80 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
81
82 bool ret = audioBackgroundManagerTest_->IsAllowedPlayback(0, pid);
83 EXPECT_EQ(ret, true);
84 }
85
86 /**
87 * @tc.name : Test IsAllowedPlayback API
88 * @tc.type : FUNC
89 * @tc.number: AudioBackgroundManager_004
90 * @tc.desc : Test IsAllowedPlayback
91 */
92 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_004, TestSize.Level1)
93 {
94 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
95 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
96 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
97
98 int32_t pid = 0;
99 AppState appState;
100 audioBackgroundManagerTest_->appStatesMap_.clear();
101 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
102
103 bool ret = audioBackgroundManagerTest_->IsAllowedPlayback(1, 1);
104 EXPECT_EQ(ret, true);
105 }
106
107 /**
108 * @tc.name : Test IsAllowedPlayback API
109 * @tc.type : FUNC
110 * @tc.number: AudioBackgroundManager_005
111 * @tc.desc : Test IsAllowedPlayback
112 */
113 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_005, TestSize.Level1)
114 {
115 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
116 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
117 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
118
119 int32_t pid = 0;
120 AppState appState;
121 appState.isBack = false;
122 audioBackgroundManagerTest_->appStatesMap_.clear();
123 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
124
125 bool ret = audioBackgroundManagerTest_->IsAllowedPlayback(1, 1);
126 EXPECT_EQ(ret, true);
127 }
128
129 /**
130 * @tc.name : Test IsAllowedPlayback API
131 * @tc.type : FUNC
132 * @tc.number: AudioBackgroundManager_006
133 * @tc.desc : Test IsAllowedPlayback
134 */
135 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_006, TestSize.Level1)
136 {
137 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
138 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
139 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
140
141 int32_t pid = 0;
142 AppState appState;
143 appState.isBack = true;
144 appState.hasBackTask = true;
145 appState.hasSession = true;
146 audioBackgroundManagerTest_->appStatesMap_.clear();
147 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
148
149 bool ret = audioBackgroundManagerTest_->IsAllowedPlayback(1, pid);
150 EXPECT_EQ(ret, true);
151 }
152
153 /**
154 * @tc.name : Test IsAllowedPlayback API
155 * @tc.type : FUNC
156 * @tc.number: AudioBackgroundManager_007
157 * @tc.desc : Test IsAllowedPlayback
158 */
159 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_007, TestSize.Level1)
160 {
161 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
162 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
163 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
164
165 int32_t pid = 0;
166 AppState appState;
167 appState.isBack = true;
168 appState.hasBackTask = false;
169 appState.isBinder = true;
170 appState.hasSession = true;
171 audioBackgroundManagerTest_->appStatesMap_.clear();
172 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
173
174 bool ret = audioBackgroundManagerTest_->IsAllowedPlayback(1, pid);
175 EXPECT_EQ(ret, true);
176 }
177
178 /**
179 * @tc.name : Test IsAllowedPlayback API
180 * @tc.type : FUNC
181 * @tc.number: AudioBackgroundManager_008
182 * @tc.desc : Test IsAllowedPlayback
183 */
184 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_008, TestSize.Level1)
185 {
186 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
187 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
188 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
189
190 int32_t pid = 0;
191 AppState appState;
192 appState.isBack = true;
193 appState.hasBackTask = false;
194 appState.isBinder = false;
195 appState.hasSession = true;
196 audioBackgroundManagerTest_->appStatesMap_.clear();
197 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
198
199 bool ret = audioBackgroundManagerTest_->IsAllowedPlayback(1, pid);
200 EXPECT_EQ(ret, true);
201 }
202
203 /**
204 * @tc.name : Test IsAllowedPlayback API
205 * @tc.type : FUNC
206 * @tc.number: AudioBackgroundManager_009
207 * @tc.desc : Test IsAllowedPlayback
208 */
209 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_009, TestSize.Level1)
210 {
211 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
212 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
213 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
214
215 int32_t pid = 0;
216 AppState appState;
217 appState.isBack = true;
218 appState.hasBackTask = false;
219 appState.isBinder = false;
220 appState.hasSession = false;
221 audioBackgroundManagerTest_->appStatesMap_.clear();
222 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
223
224 bool ret = audioBackgroundManagerTest_->IsAllowedPlayback(1, pid);
225 EXPECT_EQ(ret, true);
226 }
227
228 /**
229 * @tc.name : Test IsAllowedPlayback API
230 * @tc.type : FUNC
231 * @tc.number: AudioBackgroundManager_010
232 * @tc.desc : Test IsAllowedPlayback
233 */
234 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_010, TestSize.Level1)
235 {
236 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
237 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
238 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
239
240 int32_t pid = 0;
241 AppState appState;
242 appState.isBack = true;
243 appState.hasBackTask = false;
244 appState.isBinder = true;
245 appState.hasSession = false;
246 audioBackgroundManagerTest_->appStatesMap_.clear();
247 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
248
249 bool ret = audioBackgroundManagerTest_->IsAllowedPlayback(1, pid);
250 EXPECT_EQ(ret, true);
251 }
252
253 /**
254 * @tc.name : Test NotifyAppStateChange API
255 * @tc.type : FUNC
256 * @tc.number: AudioBackgroundManager_011
257 * @tc.desc : Test NotifyAppStateChange
258 */
259 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_011, TestSize.Level1)
260 {
261 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
262 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
263 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
264
265 int32_t pid = 0;
266 int32_t uid = 0;
267 AppIsBackState state = STATE_END;
268 AppState appState;
269
270 audioBackgroundManagerTest_->appStatesMap_.clear();
271 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
272 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
273
274 audioBackgroundManagerTest_->NotifyAppStateChange(uid, pid, state);
275 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), true);
276 }
277
278 /**
279 * @tc.name : Test NotifyAppStateChange API
280 * @tc.type : FUNC
281 * @tc.number: AudioBackgroundManager_012
282 * @tc.desc : Test NotifyAppStateChange
283 */
284 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_012, TestSize.Level1)
285 {
286 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
287 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
288 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
289
290 int32_t pid = 0;
291 int32_t uid = 0;
292 AppIsBackState state = STATE_FOREGROUND;
293
294 audioBackgroundManagerTest_->appStatesMap_.clear();
295 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), true);
296
297 audioBackgroundManagerTest_->NotifyAppStateChange(uid, pid, state);
298 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
299 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].isBack, false);
300 }
301
302 /**
303 * @tc.name : Test NotifyAppStateChange API
304 * @tc.type : FUNC
305 * @tc.number: AudioBackgroundManager_013
306 * @tc.desc : Test NotifyAppStateChange
307 */
308 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_013, TestSize.Level1)
309 {
310 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
311 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
312 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
313
314 int32_t pid = 0;
315 int32_t uid = 0;
316 AppIsBackState state = STATE_BACKGROUND;
317
318 audioBackgroundManagerTest_->appStatesMap_.clear();
319 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), true);
320
321 audioBackgroundManagerTest_->NotifyAppStateChange(uid, pid, state);
322 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
323 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].isBack, true);
324 }
325
326 /**
327 * @tc.name : Test NotifyAppStateChange API
328 * @tc.type : FUNC
329 * @tc.number: AudioBackgroundManager_014
330 * @tc.desc : Test NotifyAppStateChange
331 */
332 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_014, TestSize.Level1)
333 {
334 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
335 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
336 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
337
338 int32_t pid = 0;
339 int32_t uid = 0;
340 AppIsBackState state = STATE_BACKGROUND;
341
342 AppState appState;
343 appState.isBack = true;
344 audioBackgroundManagerTest_->appStatesMap_.clear();
345 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
346 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
347
348 audioBackgroundManagerTest_->NotifyAppStateChange(uid, pid, state);
349 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
350 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].isBack, true);
351 }
352
353 /**
354 * @tc.name : Test NotifyAppStateChange API
355 * @tc.type : FUNC
356 * @tc.number: AudioBackgroundManager_015
357 * @tc.desc : Test NotifyAppStateChange
358 */
359 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_015, TestSize.Level1)
360 {
361 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
362 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
363 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
364
365 int32_t pid = 0;
366 int32_t uid = 0;
367 AppIsBackState state = STATE_BACKGROUND;
368
369 AppState appState;
370 appState.isBack = false;
371 audioBackgroundManagerTest_->appStatesMap_.clear();
372 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
373 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
374
375 audioBackgroundManagerTest_->NotifyAppStateChange(uid, pid, state);
376 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
377 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].isBack, false);
378 }
379
380 /**
381 * @tc.name : Test NotifyAppStateChange API
382 * @tc.type : FUNC
383 * @tc.number: AudioBackgroundManager_016
384 * @tc.desc : Test NotifyAppStateChange
385 */
386 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_016, TestSize.Level1)
387 {
388 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
389 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
390 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
391
392 int32_t pid = 0;
393 int32_t uid = 0;
394 AppIsBackState state = STATE_FOREGROUND;
395
396 AppState appState;
397 appState.isBack = true;
398 audioBackgroundManagerTest_->appStatesMap_.clear();
399 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
400 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
401
402 audioBackgroundManagerTest_->NotifyAppStateChange(uid, pid, state);
403 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
404 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].isBack, true);
405 }
406
407 /**
408 * @tc.name : Test NotifyAppStateChange API
409 * @tc.type : FUNC
410 * @tc.number: AudioBackgroundManager_017
411 * @tc.desc : Test NotifyAppStateChange
412 */
413 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_017, TestSize.Level1)
414 {
415 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
416 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
417 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
418
419 int32_t pid = 0;
420 int32_t uid = 0;
421 AppIsBackState state = STATE_BACKGROUND;
422
423 AppState appState;
424 appState.isBack = false;
425 appState.hasSession = false;
426 audioBackgroundManagerTest_->appStatesMap_.clear();
427 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
428 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
429 VolumeUtils::SetPCVolumeEnable(false);
430 audioBackgroundManagerTest_->NotifyAppStateChange(uid, pid, state);
431 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
432 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].isBack, false);
433 }
434
435 /**
436 * @tc.name : Test NotifyAppStateChange API
437 * @tc.type : FUNC
438 * @tc.number: AudioBackgroundManager_018
439 * @tc.desc : Test NotifyAppStateChange
440 */
441 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_018, TestSize.Level1)
442 {
443 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
444 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
445 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
446
447 int32_t pid = 0;
448 int32_t uid = 0;
449 AppIsBackState state = STATE_BACKGROUND;
450
451 AppState appState;
452 appState.isBack = false;
453 appState.hasSession = true;
454 audioBackgroundManagerTest_->appStatesMap_.clear();
455 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
456 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
457 VolumeUtils::SetPCVolumeEnable(false);
458 audioBackgroundManagerTest_->NotifyAppStateChange(uid, pid, state);
459 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
460 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].isBack, false);
461 }
462
463 /**
464 * @tc.name : Test NotifyAppStateChange API
465 * @tc.type : FUNC
466 * @tc.number: AudioBackgroundManager_019
467 * @tc.desc : Test NotifyAppStateChange
468 */
469 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_019, TestSize.Level1)
470 {
471 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
472 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
473 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
474
475 int32_t pid = 0;
476 int32_t uid = 0;
477 AppIsBackState state = STATE_BACKGROUND;
478
479 AppState appState;
480 appState.isBack = false;
481 appState.hasSession = false;
482 audioBackgroundManagerTest_->appStatesMap_.clear();
483 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
484 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
485 VolumeUtils::SetPCVolumeEnable(true);
486 audioBackgroundManagerTest_->NotifyAppStateChange(uid, pid, state);
487 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
488 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].isBack, false);
489 }
490
491 /**
492 * @tc.name : Test NotifyBackgroundTaskStateChange API
493 * @tc.type : FUNC
494 * @tc.number: AudioBackgroundManager_020
495 * @tc.desc : Test NotifyBackgroundTaskStateChange
496 */
497 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_020, TestSize.Level1)
498 {
499 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
500 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
501 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
502
503 int32_t pid = 0;
504 int32_t uid = 0;
505 bool hasBackgroundTask = true;
506
507 audioBackgroundManagerTest_->appStatesMap_.clear();
508 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), true);
509
510 audioBackgroundManagerTest_->NotifyBackgroundTaskStateChange(uid, pid, hasBackgroundTask);
511 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
512 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].hasBackTask, true);
513 }
514
515 /**
516 * @tc.name : Test NotifyBackgroundTaskStateChange API
517 * @tc.type : FUNC
518 * @tc.number: AudioBackgroundManager_021
519 * @tc.desc : Test NotifyBackgroundTaskStateChange
520 */
521 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_021, TestSize.Level1)
522 {
523 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
524 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
525 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
526
527 int32_t pid = 0;
528 int32_t uid = 0;
529 bool hasBackgroundTask = true;
530 AppState appState;
531 appState.hasBackTask = true;
532 audioBackgroundManagerTest_->appStatesMap_.clear();
533 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
534 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
535
536 audioBackgroundManagerTest_->NotifyBackgroundTaskStateChange(uid, pid, hasBackgroundTask);
537 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
538 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].hasBackTask, true);
539 }
540
541 /**
542 * @tc.name : Test NotifyBackgroundTaskStateChange API
543 * @tc.type : FUNC
544 * @tc.number: AudioBackgroundManager_022
545 * @tc.desc : Test NotifyBackgroundTaskStateChange
546 */
547 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_022, TestSize.Level1)
548 {
549 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
550 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
551 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
552
553 int32_t pid = 0;
554 int32_t uid = 0;
555 bool hasBackgroundTask = true;
556 AppState appState;
557 appState.hasBackTask = false;
558 appState.isFreeze = false;
559 audioBackgroundManagerTest_->appStatesMap_.clear();
560 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
561 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
562
563 audioBackgroundManagerTest_->NotifyBackgroundTaskStateChange(uid, pid, hasBackgroundTask);
564 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
565 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].hasBackTask, true);
566 }
567
568 /**
569 * @tc.name : Test NotifyBackgroundTaskStateChange API
570 * @tc.type : FUNC
571 * @tc.number: AudioBackgroundManager_023
572 * @tc.desc : Test NotifyBackgroundTaskStateChange
573 */
574 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_023, TestSize.Level1)
575 {
576 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
577 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
578 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
579
580 int32_t pid = 0;
581 int32_t uid = 0;
582 bool hasBackgroundTask = true;
583 AppState appState;
584 appState.hasBackTask = false;
585 appState.isFreeze = true;
586 audioBackgroundManagerTest_->appStatesMap_.clear();
587 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
588 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
589
590 audioBackgroundManagerTest_->NotifyBackgroundTaskStateChange(uid, pid, hasBackgroundTask);
591 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
592 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].hasBackTask, true);
593 }
594
595 /**
596 * @tc.name : Test NotifyBackgroundTaskStateChange API
597 * @tc.type : FUNC
598 * @tc.number: AudioBackgroundManager_024
599 * @tc.desc : Test NotifyBackgroundTaskStateChange
600 */
601 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_024, TestSize.Level1)
602 {
603 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
604 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
605 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
606
607 int32_t pid = 0;
608 int32_t uid = 0;
609 bool hasBackgroundTask = false;
610 AppState appState;
611 appState.hasBackTask = true;
612 appState.isFreeze = false;
613 audioBackgroundManagerTest_->appStatesMap_.clear();
614 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
615 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
616
617 audioBackgroundManagerTest_->NotifyBackgroundTaskStateChange(uid, pid, hasBackgroundTask);
618 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
619 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].hasBackTask, false);
620 }
621
622 /**
623 * @tc.name : Test NotifySessionStateChange API
624 * @tc.type : FUNC
625 * @tc.number: AudioBackgroundManager_025
626 * @tc.desc : Test NotifySessionStateChange
627 */
628 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_025, TestSize.Level1)
629 {
630 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
631 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
632 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
633
634 int32_t pid = 0;
635 int32_t uid = 0;
636 bool hasSession = false;
637
638 audioBackgroundManagerTest_->appStatesMap_.clear();
639 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), true);
640
641 int32_t ret = audioBackgroundManagerTest_->NotifySessionStateChange(uid, pid, hasSession);
642 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
643 EXPECT_EQ(ret, SUCCESS);
644 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].hasSession, false);
645 }
646
647 /**
648 * @tc.name : Test NotifySessionStateChange API
649 * @tc.type : FUNC
650 * @tc.number: AudioBackgroundManager_026
651 * @tc.desc : Test NotifySessionStateChange
652 */
653 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_026, TestSize.Level1)
654 {
655 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
656 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
657 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
658
659 int32_t pid = 0;
660 int32_t uid = 0;
661 bool hasSession = false;
662 AppState appState;
663 appState.hasSession = true;
664 audioBackgroundManagerTest_->appStatesMap_.clear();
665 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
666 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
667
668 int32_t ret = audioBackgroundManagerTest_->NotifySessionStateChange(uid, pid, hasSession);
669 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
670 EXPECT_EQ(ret, SUCCESS);
671 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].hasSession, false);
672 }
673
674 /**
675 * @tc.name : Test HandleSessionStateChange API
676 * @tc.type : FUNC
677 * @tc.number: AudioBackgroundManager_027
678 * @tc.desc : Test HandleSessionStateChange
679 */
680 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_027, TestSize.Level1)
681 {
682 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
683 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
684 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
685
686 int32_t pid = 0;
687 int32_t uid = 1003;
688 AppState appState;
689 appState.hasSession = true;
690 audioBackgroundManagerTest_->appStatesMap_.clear();
691 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
692 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
693
694 audioBackgroundManagerTest_->HandleSessionStateChange(uid, pid);
695 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
696 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].hasSession, true);
697 }
698
699 /**
700 * @tc.name : Test HandleSessionStateChange API
701 * @tc.type : FUNC
702 * @tc.number: AudioBackgroundManager_028
703 * @tc.desc : Test HandleSessionStateChange
704 */
705 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_028, TestSize.Level1)
706 {
707 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
708 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
709 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
710
711 int32_t pid = 0;
712 int32_t uid = 0;
713 AppState appState;
714 appState.hasSession = false;
715 appState.isBack = true;
716 audioBackgroundManagerTest_->appStatesMap_.clear();
717 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
718 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
719 VolumeUtils::SetPCVolumeEnable(true);
720
721 audioBackgroundManagerTest_->HandleSessionStateChange(uid, pid);
722 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
723 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].isBack, true);
724 }
725
726 /**
727 * @tc.name : Test HandleSessionStateChange API
728 * @tc.type : FUNC
729 * @tc.number: AudioBackgroundManager_029
730 * @tc.desc : Test HandleSessionStateChange
731 */
732 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_029, TestSize.Level1)
733 {
734 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
735 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
736 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
737
738 int32_t pid = 0;
739 int32_t uid = 0;
740 AppState appState;
741 appState.hasSession = false;
742 appState.isBack = true;
743 audioBackgroundManagerTest_->appStatesMap_.clear();
744 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
745 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
746 VolumeUtils::SetPCVolumeEnable(false);
747
748 audioBackgroundManagerTest_->HandleSessionStateChange(uid, pid);
749 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
750 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].hasSession, false);
751 }
752
753 /**
754 * @tc.name : Test NotifyFreezeStateChange API
755 * @tc.type : FUNC
756 * @tc.number: AudioBackgroundManager_030
757 * @tc.desc : Test NotifyFreezeStateChange
758 */
759 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_030, TestSize.Level1)
760 {
761 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
762 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
763 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
764
765 std::set<int32_t> pidList;
766 bool isFreeze = false;
767
768 int32_t ret = audioBackgroundManagerTest_->NotifyFreezeStateChange(pidList, isFreeze);
769 EXPECT_EQ(ret, SUCCESS);
770 }
771
772 /**
773 * @tc.name : Test NotifyFreezeStateChange API
774 * @tc.type : FUNC
775 * @tc.number: AudioBackgroundManager_031
776 * @tc.desc : Test NotifyFreezeStateChange
777 */
778 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_031, TestSize.Level1)
779 {
780 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
781 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
782 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
783
784 std::set<int32_t> pidList;
785 bool isFreeze = false;
786 int32_t pid = 0;
787 AppState appState;
788 appState.isFreeze = true;
789 pidList.insert(pid);
790 audioBackgroundManagerTest_->appStatesMap_.clear();
791 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
792 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
793
794 int32_t ret = audioBackgroundManagerTest_->NotifyFreezeStateChange(pidList, isFreeze);
795 EXPECT_EQ(ret, SUCCESS);
796 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].isFreeze, false);
797 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].isBinder, true);
798 }
799
800 /**
801 * @tc.name : Test NotifyFreezeStateChange API
802 * @tc.type : FUNC
803 * @tc.number: AudioBackgroundManager_032
804 * @tc.desc : Test NotifyFreezeStateChange
805 */
806 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_032, TestSize.Level1)
807 {
808 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
809 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
810 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
811
812 std::set<int32_t> pidList;
813 bool isFreeze = false;
814 int32_t pid = 0;
815 pidList.insert(pid);
816 audioBackgroundManagerTest_->appStatesMap_.clear();
817 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), true);
818
819 int32_t ret = audioBackgroundManagerTest_->NotifyFreezeStateChange(pidList, isFreeze);
820 EXPECT_EQ(ret, SUCCESS);
821 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
822 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].isFreeze, false);
823 }
824
825 /**
826 * @tc.name : Test ResetAllProxy API
827 * @tc.type : FUNC
828 * @tc.number: AudioBackgroundManager_033
829 * @tc.desc : Test ResetAllProxy
830 */
831 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_033, TestSize.Level1)
832 {
833 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
834 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
835 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
836
837 audioBackgroundManagerTest_->appStatesMap_.clear();
838 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), true);
839
840 int32_t ret = audioBackgroundManagerTest_->ResetAllProxy();
841 EXPECT_EQ(ret, SUCCESS);
842 }
843
844 /**
845 * @tc.name : Test ResetAllProxy API
846 * @tc.type : FUNC
847 * @tc.number: AudioBackgroundManager_034
848 * @tc.desc : Test ResetAllProxy
849 */
850 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_034, TestSize.Level1)
851 {
852 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
853 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
854 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
855
856 int32_t pid = 0;
857 AppState appState;
858 appState.isFreeze = true;
859 appState.isBinder = true;
860
861 audioBackgroundManagerTest_->appStatesMap_.clear();
862 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
863 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
864
865 int32_t ret = audioBackgroundManagerTest_->ResetAllProxy();
866 EXPECT_EQ(ret, SUCCESS);
867 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].isFreeze, false);
868 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].isBinder, false);
869 }
870
871 /**
872 * @tc.name : Test HandleFreezeStateChange API
873 * @tc.type : FUNC
874 * @tc.number: AudioBackgroundManager_035
875 * @tc.desc : Test HandleFreezeStateChange
876 */
877 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_035, TestSize.Level1)
878 {
879 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
880 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
881 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
882
883 int32_t pid = 0;
884 AppState appState;
885 appState.hasBackTask = true;
886 bool isFreeze = true;
887
888 audioBackgroundManagerTest_->appStatesMap_.clear();
889 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
890 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
891
892 audioBackgroundManagerTest_->HandleFreezeStateChange(pid, isFreeze);
893 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].hasBackTask, true);
894 }
895
896 /**
897 * @tc.name : Test HandleFreezeStateChange API
898 * @tc.type : FUNC
899 * @tc.number: AudioBackgroundManager_036
900 * @tc.desc : Test HandleFreezeStateChange
901 */
902 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_036, TestSize.Level1)
903 {
904 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
905 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
906 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
907
908 int32_t pid = 0;
909 AppState appState;
910 appState.hasBackTask = false;
911 bool isFreeze = true;
912
913 audioBackgroundManagerTest_->appStatesMap_.clear();
914 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
915 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
916
917 audioBackgroundManagerTest_->HandleFreezeStateChange(pid, isFreeze);
918 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].hasBackTask, false);
919 }
920
921 /**
922 * @tc.name : Test HandleFreezeStateChange API
923 * @tc.type : FUNC
924 * @tc.number: AudioBackgroundManager_037
925 * @tc.desc : Test HandleFreezeStateChange
926 */
927 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_037, TestSize.Level1)
928 {
929 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
930 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
931 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
932
933 int32_t pid = 0;
934 AppState appState;
935 appState.hasBackTask = false;
936 bool isFreeze = false;
937
938 audioBackgroundManagerTest_->appStatesMap_.clear();
939 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
940 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
941
942 audioBackgroundManagerTest_->HandleFreezeStateChange(pid, isFreeze);
943 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].hasBackTask, false);
944 }
945
946 /**
947 * @tc.name : Test HandleFreezeStateChange API
948 * @tc.type : FUNC
949 * @tc.number: AudioBackgroundManager_038
950 * @tc.desc : Test HandleFreezeStateChange
951 */
952 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_038, TestSize.Level1)
953 {
954 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
955 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
956 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
957
958 int32_t pid = 0;
959 AppState appState;
960 appState.hasBackTask = true;
961 bool isFreeze = false;
962
963 audioBackgroundManagerTest_->appStatesMap_.clear();
964 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
965 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
966
967 audioBackgroundManagerTest_->HandleFreezeStateChange(pid, isFreeze);
968 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_[pid].hasBackTask, true);
969 }
970
971 /**
972 * @tc.name : Test DeleteFromMap API
973 * @tc.type : FUNC
974 * @tc.number: AudioBackgroundManager_039
975 * @tc.desc : Test DeleteFromMap
976 */
977 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_039, TestSize.Level1)
978 {
979 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
980 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
981 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
982
983 int32_t pid = 0;
984 AppState appState;
985
986 audioBackgroundManagerTest_->appStatesMap_.clear();
987 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
988 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
989
990 audioBackgroundManagerTest_->DeleteFromMap(1000);
991 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
992 }
993
994 /**
995 * @tc.name : Test DeleteFromMap API
996 * @tc.type : FUNC
997 * @tc.number: AudioBackgroundManager_040
998 * @tc.desc : Test DeleteFromMap
999 */
1000 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_040, TestSize.Level1)
1001 {
1002 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
1003 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
1004 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
1005
1006 int32_t pid = 0;
1007 AppState appState;
1008
1009 audioBackgroundManagerTest_->appStatesMap_.clear();
1010 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
1011 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
1012
1013 audioBackgroundManagerTest_->DeleteFromMap(pid);
1014 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), true);
1015 }
1016
1017 /**
1018 * @tc.name : Test DeleteFromMap API
1019 * @tc.type : FUNC
1020 * @tc.number: AudioBackgroundManager_041
1021 * @tc.desc : Test DeleteFromMap
1022 */
1023 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_041, TestSize.Level1)
1024 {
1025 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
1026 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
1027 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
1028
1029 int32_t pid = 0;
1030 audioBackgroundManagerTest_->appStatesMap_.clear();
1031 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), true);
1032
1033 audioBackgroundManagerTest_->DeleteFromMap(pid);
1034 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), true);
1035 }
1036
1037 /**
1038 * @tc.name : Test FindKeyInMap API
1039 * @tc.type : FUNC
1040 * @tc.number: AudioBackgroundManager_042
1041 * @tc.desc : Test FindKeyInMap
1042 */
1043 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_042, TestSize.Level1)
1044 {
1045 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
1046 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
1047 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
1048
1049 int32_t pid = 0;
1050 AppState appState;
1051
1052 audioBackgroundManagerTest_->appStatesMap_.clear();
1053 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
1054 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
1055
1056 bool ret = audioBackgroundManagerTest_->FindKeyInMap(pid);
1057 EXPECT_EQ(ret, true);
1058 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
1059 }
1060
1061 /**
1062 * @tc.name : Test FindKeyInMap API
1063 * @tc.type : FUNC
1064 * @tc.number: AudioBackgroundManager_043
1065 * @tc.desc : Test FindKeyInMap
1066 */
1067 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_043, TestSize.Level1)
1068 {
1069 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
1070 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
1071 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
1072
1073 int32_t pid = 0;
1074
1075 audioBackgroundManagerTest_->appStatesMap_.clear();
1076 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), true);
1077
1078 bool ret = audioBackgroundManagerTest_->FindKeyInMap(pid);
1079 EXPECT_EQ(ret, false);
1080 }
1081
1082 /**
1083 * @tc.name : Test FindKeyInMap API
1084 * @tc.type : FUNC
1085 * @tc.number: AudioBackgroundManager_044
1086 * @tc.desc : Test FindKeyInMap
1087 */
1088 HWTEST(AudioBackgroundManagerUnitTest, AudioBackgroundManager_044, TestSize.Level1)
1089 {
1090 AudioBackgroundManager* audioBackgroundManagerTest_ = nullptr;
1091 audioBackgroundManagerTest_ = &AudioBackgroundManager::GetInstance();
1092 ASSERT_TRUE(audioBackgroundManagerTest_ != nullptr);
1093
1094 int32_t pid = 0;
1095 AppState appState;
1096
1097 audioBackgroundManagerTest_->appStatesMap_.clear();
1098 audioBackgroundManagerTest_->InsertIntoAppStatesMap(pid, appState);
1099 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
1100
1101 bool ret = audioBackgroundManagerTest_->FindKeyInMap(1000);
1102 EXPECT_EQ(ret, false);
1103 EXPECT_EQ(audioBackgroundManagerTest_->appStatesMap_.empty(), false);
1104 }
1105 } // namespace AudioStandard
1106 } // namespace OHOS
1107