1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include <gtest/gtest.h>
16 #include "audio_stream_checker.h"
17 #include "audio_errors.h"
18 #include "audio_utils.h"
19
20 using namespace testing::ext;
21
22 namespace OHOS {
23 namespace AudioStandard {
24
25 const uint64_t DEFAULT_TIME = 3711509424L;
26
27 class AudioStreamCheckerTest : public testing::Test {
28 public:
29 static void SetUpTestCase(void);
30 static void TearDownTestCase(void);
31 void SetUp();
32 void TearDown();
33 };
34
SetUpTestCase(void)35 void AudioStreamCheckerTest::SetUpTestCase(void)
36 {
37 // input testsuit setup step，setup invoked before all testcases
38 }
39
TearDownTestCase(void)40 void AudioStreamCheckerTest::TearDownTestCase(void)
41 {
42 // input testsuit teardown step，teardown invoked after all testcases
43 }
44
SetUp(void)45 void AudioStreamCheckerTest::SetUp(void)
46 {
47 // input testcase setup step，setup invoked before each testcases
48 }
49
TearDown(void)50 void AudioStreamCheckerTest::TearDown(void)
51 {
52 // input testcase teardown step，teardown invoked after each testcases
53 }
54
55 /**
56 * @tc.name : Test InitChecker API
57 * @tc.type : FUNC
58 * @tc.number: InitCheckerTest_001
59 */
60 HWTEST(AudioStreamCheckerTest, InitCheckerTest_001, TestSize.Level1)
61 {
62 AudioProcessConfig cfg;
63 DataTransferMonitorParam para;
64 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
65 checker->InitChecker(para, 100000, 100000);
66 checker->InitChecker(para, 100000, 100000);
67 int32_t size = checker->checkParaVector_.size();
68 EXPECT_GT(size, 0);
69 }
70
71 /**
72 * @tc.name : Test RecordFrame API
73 * @tc.type : FUNC
74 * @tc.number: RecordFrame_001
75 */
76 HWTEST(AudioStreamCheckerTest, RecordFrame_001, TestSize.Level1)
77 {
78 AudioProcessConfig cfg;
79 DataTransferMonitorParam para;
80 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
81 checker->InitChecker(para, 100000, 100000);
82 checker->RecordMuteFrame();
83 int32_t num = checker->checkParaVector_[0].muteFrameNum;
84 EXPECT_GT(num, 0);
85 checker->RecordNodataFrame();
86 num = checker->checkParaVector_[0].noDataFrameNum;
87 EXPECT_GT(num, 0);
88 checker->RecordNormalFrame();
89 num = checker->checkParaVector_[0].normalFrameCount;
90 EXPECT_GT(num, 0);
91 }
92
93 /**
94 * @tc.name : Test GetAppUid API
95 * @tc.type : FUNC
96 * @tc.number: GetAppUid_001
97 */
98 HWTEST(AudioStreamCheckerTest, GetAppUid_001, TestSize.Level1)
99 {
100 AudioProcessConfig cfg;
101 cfg.appInfo.appUid = 20002000;
102 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
103 int32_t uid = checker->GetAppUid();
104 EXPECT_EQ(uid, 20002000);
105 }
106
107 /**
108 * @tc.name : Test DeleteCheckerPara API
109 * @tc.type : FUNC
110 * @tc.number: DeleteCheckerPara_001
111 */
112 HWTEST(AudioStreamCheckerTest, DeleteCheckerPara_001, TestSize.Level1)
113 {
114 AudioProcessConfig cfg;
115 DataTransferMonitorParam para;
116 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
117 checker->InitChecker(para, 100000, 100000);
118 checker->DeleteCheckerPara(100000, 100000);
119 int32_t size = checker->checkParaVector_.size();
120 EXPECT_EQ(size, 0);
121 }
122
123 /**
124 * @tc.name : Test MonitorCheckFrame API
125 * @tc.type : FUNC
126 * @tc.number: MonitorCheckFrame_001
127 */
128 HWTEST(AudioStreamCheckerTest, MonitorCheckFrame_001, TestSize.Level1)
129 {
130 AudioProcessConfig cfg;
131 DataTransferMonitorParam para;
132 para.badDataTransferTypeBitMap = 3;
133 para.timeInterval = 0;
134 para.badFramesRatio = 50;
135 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
136 checker->InitChecker(para, 100000, 100000);
137 checker->RecordMuteFrame();
138 checker->RecordNormalFrame();
139 checker->MonitorCheckFrame();
140 DataTransferStateChangeType status = checker->checkParaVector_[0].lastStatus;
141 EXPECT_EQ(status, DATA_TRANS_STOP);
142 }
143
144 /**
145 * @tc.name : Test MonitorCheckFrame API
146 * @tc.type : FUNC
147 * @tc.number: MonitorCheckFrame_002
148 */
149 HWTEST(AudioStreamCheckerTest, MonitorCheckFrame_002, TestSize.Level1)
150 {
151 AudioProcessConfig cfg;
152 DataTransferMonitorParam para;
153 para.badDataTransferTypeBitMap = 3;
154 para.timeInterval = 0;
155 para.badFramesRatio = 50;
156 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
157 checker->InitChecker(para, 100000, 100000);
158 for (int i = 0; i < 4; i++) {
159 checker->RecordNormalFrame();
160 }
161 checker->MonitorCheckFrame();
162 DataTransferStateChangeType status = checker->checkParaVector_[0].lastStatus;
163 EXPECT_EQ(status, DATA_TRANS_RESUME);
164 }
165
166 /**
167 * @tc.name : Test MonitorCheckFrame API
168 * @tc.type : FUNC
169 * @tc.number: MonitorCheckFrame_003
170 */
171 HWTEST(AudioStreamCheckerTest, MonitorCheckFrame_003, TestSize.Level1)
172 {
173 AudioProcessConfig cfg;
174 DataTransferMonitorParam para;
175 para.badDataTransferTypeBitMap = 3;
176 para.timeInterval = 0;
177 para.badFramesRatio = 50;
178 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
179 checker->InitChecker(para, 100000, 100000);
180 checker->RecordMuteFrame();
181 checker->RecordNormalFrame();
182 checker->MonitorCheckFrame();
183 for (int i = 0; i < 4; i++) {
184 checker->RecordNormalFrame();
185 }
186 checker->MonitorCheckFrame();
187 DataTransferStateChangeType status = checker->checkParaVector_[0].lastStatus;
188 EXPECT_EQ(status, DATA_TRANS_RESUME);
189 }
190
191 /**
192 * @tc.name : Test MonitorOnAllCallback API
193 * @tc.type : FUNC
194 * @tc.number: MonitorOnAllCallback_001
195 */
196 HWTEST(AudioStreamCheckerTest, MonitorOnAllCallback_001, TestSize.Level1)
197 {
198 AudioProcessConfig cfg;
199 DataTransferMonitorParam para;
200 para.badDataTransferTypeBitMap = 3;
201 para.timeInterval = 2000000000;
202 para.badFramesRatio = 50;
203 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
204 checker->InitChecker(para, 100000, 100000);
205 checker->MonitorOnAllCallback(AUDIO_STREAM_START, false);
206 int32_t size = checker->checkParaVector_.size();
207 EXPECT_GT(size, 0);
208 }
209
210 /**
211 * @tc.name : Test MonitorOnAllCallback API
212 * @tc.type : FUNC
213 * @tc.number: MonitorOnAllCallback_002
214 */
215 HWTEST(AudioStreamCheckerTest, MonitorOnAllCallback_002, TestSize.Level1)
216 {
217 AudioProcessConfig cfg;
218 DataTransferMonitorParam para;
219 para.badDataTransferTypeBitMap = 2;
220 para.timeInterval = 2000000000;
221 para.badFramesRatio = 50;
222 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
223 checker->InitChecker(para, 100000, 100000);
224 checker->MonitorOnAllCallback(DATA_TRANS_RESUME, true);
225 int32_t size = checker->checkParaVector_.size();
226 EXPECT_GT(size, 0);
227 }
228
229 /**
230 * @tc.name : Test MonitorOnAllCallback API
231 * @tc.type : FUNC
232 * @tc.number: MonitorOnAllCallback_003
233 */
234 HWTEST(AudioStreamCheckerTest, MonitorOnAllCallback_003, TestSize.Level1)
235 {
236 AudioProcessConfig cfg;
237 DataTransferMonitorParam para;
238 para.badDataTransferTypeBitMap = 2;
239 para.timeInterval = 2000000000;
240 para.badFramesRatio = 50;
241 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
242 checker->InitChecker(para, 100000, 100000);
243 checker->monitorSwitch_ = false;
244 checker->MonitorOnAllCallback(DATA_TRANS_RESUME, true);
245 int32_t size = checker->checkParaVector_.size();
246 EXPECT_GT(size, 0);
247 }
248
249 /**
250 * @tc.name : Test OnRemoteAppDied API
251 * @tc.type : FUNC
252 * @tc.number: OnRemoteAppDied_001
253 */
254 HWTEST(AudioStreamCheckerTest, OnRemoteAppDied_001, TestSize.Level1)
255 {
256 AudioProcessConfig cfg;
257 DataTransferMonitorParam para;
258 para.badDataTransferTypeBitMap = 3;
259 para.timeInterval = 2000000000;
260 para.badFramesRatio = 50;
261 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
262 checker->InitChecker(para, 100000, 100000);
263 checker->OnRemoteAppDied(100000);
264 int size = checker->checkParaVector_.size();
265 EXPECT_EQ(size, 0);
266 }
267
268 /**
269 * @tc.name : Test MonitorCheckFrameSub API
270 * @tc.type : FUNC
271 * @tc.number: MonitorCheckFrameSub_001
272 */
273 HWTEST(AudioStreamCheckerTest, MonitorCheckFrameSub_001, TestSize.Level1)
274 {
275 AudioProcessConfig cfg;
276 DataTransferMonitorParam para;
277 para.badDataTransferTypeBitMap = 3;
278 para.timeInterval = 2000000000;
279 para.badFramesRatio = 50;
280 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
281 checker->InitChecker(para, 100000, 100000);
282 CheckerParam checkerPara;
283 checkerPara.hasInitCheck = false;
284 checker->MonitorCheckFrameSub(checkerPara);
285 int size = checker->checkParaVector_.size();
286 EXPECT_GT(size, 0);
287 }
288
289 /**
290 * @tc.name : Test MonitorCheckFrameSub API
291 * @tc.type : FUNC
292 * @tc.number: MonitorCheckFrameSub_002
293 */
294 HWTEST(AudioStreamCheckerTest, MonitorCheckFrameSub_002, TestSize.Level1)
295 {
296 AudioProcessConfig cfg;
297 DataTransferMonitorParam para;
298 para.badDataTransferTypeBitMap = 3;
299 para.timeInterval = 2000000000;
300 para.badFramesRatio = 50;
301 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
302 checker->InitChecker(para, 100000, 100000);
303 CheckerParam checkerPara;
304 checkerPara.hasInitCheck = true;
305 checkerPara.isMonitorMuteFrame = true;
306 checkerPara.isMonitorNoDataFrame = true;
307 checker->MonitorCheckFrameSub(checkerPara);
308 int size = checker->checkParaVector_.size();
309 EXPECT_GT(size, 0);
310 }
311
312 /**
313 * @tc.name : Test MonitorCheckFrameSub API
314 * @tc.type : FUNC
315 * @tc.number: MonitorCheckFrameSub_003
316 */
317 HWTEST(AudioStreamCheckerTest, MonitorCheckFrameSub_003, TestSize.Level1)
318 {
319 AudioProcessConfig cfg;
320 DataTransferMonitorParam para;
321 para.badDataTransferTypeBitMap = 3;
322 para.timeInterval = 2000000000;
323 para.badFramesRatio = 50;
324 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
325 checker->InitChecker(para, 100000, 100000);
326 CheckerParam checkerPara;
327 checkerPara.hasInitCheck = true;
328 checkerPara.para.timeInterval = 2000000000;
329 checkerPara.lastUpdateTime = ClockTime::GetCurNano();
330 checker->MonitorCheckFrameSub(checkerPara);
331 int size = checker->checkParaVector_.size();
332 EXPECT_GT(size, 0);
333 }
334
335 /**
336 * @tc.name : Test MonitorCheckFrameAction API
337 * @tc.type : FUNC
338 * @tc.number: MonitorCheckFrameAction_001
339 */
340 HWTEST(AudioStreamCheckerTest, MonitorCheckFrameAction_001, TestSize.Level1)
341 {
342 AudioProcessConfig cfg;
343 DataTransferMonitorParam para;
344 para.badDataTransferTypeBitMap = 3;
345 para.timeInterval = 2000000000;
346 para.badFramesRatio = 50;
347 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
348 checker->InitChecker(para, 100000, 100000);
349 CheckerParam checkerPara;
350 checkerPara.lastStatus = DATA_TRANS_STOP;
351 checkerPara.sumFrameCount = 100;
352 int64_t abnormalFrameNum = 60;
353 float badFrameRatio = 0.5f;
354 checker->MonitorCheckFrameAction(checkerPara, abnormalFrameNum, badFrameRatio);
355 int size = checker->checkParaVector_.size();
356 EXPECT_GT(size, 0);
357 }
358
359 /**
360 * @tc.name : Test MonitorCheckFrameAction API
361 * @tc.type : FUNC
362 * @tc.number: MonitorCheckFrameAction_002
363 */
364 HWTEST(AudioStreamCheckerTest, MonitorCheckFrameAction_002, TestSize.Level1)
365 {
366 AudioProcessConfig cfg;
367 DataTransferMonitorParam para;
368 para.badDataTransferTypeBitMap = 3;
369 para.timeInterval = 2000000000;
370 para.badFramesRatio = 50;
371 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
372 checker->InitChecker(para, 100000, 100000);
373 CheckerParam checkerPara;
374 checkerPara.lastStatus = AUDIO_STREAM_PAUSE;
375 checkerPara.sumFrameCount = 100;
376 int64_t abnormalFrameNum = 60;
377 float badFrameRatio = 0.5f;
378 checker->MonitorCheckFrameAction(checkerPara, abnormalFrameNum, badFrameRatio);
379 int size = checker->checkParaVector_.size();
380 EXPECT_GT(size, 0);
381 }
382
383 /**
384 * @tc.name : Test MonitorCheckFrameAction API
385 * @tc.type : FUNC
386 * @tc.number: MonitorCheckFrameAction_003
387 */
388 HWTEST(AudioStreamCheckerTest, MonitorCheckFrameAction_003, TestSize.Level1)
389 {
390 AudioProcessConfig cfg;
391 DataTransferMonitorParam para;
392 para.badDataTransferTypeBitMap = 3;
393 para.timeInterval = 2000000000;
394 para.badFramesRatio = 50;
395 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
396 checker->InitChecker(para, 100000, 100000);
397 CheckerParam checkerPara;
398 checkerPara.lastStatus = AUDIO_STREAM_START;
399 checkerPara.sumFrameCount = 100;
400 int64_t abnormalFrameNum = 60;
401 float badFrameRatio = 0.5f;
402 checker->MonitorCheckFrameAction(checkerPara, abnormalFrameNum, badFrameRatio);
403 int size = checker->checkParaVector_.size();
404 EXPECT_GT(size, 0);
405 }
406
407 /**
408 * @tc.name : Test MonitorCheckFrameAction API
409 * @tc.type : FUNC
410 * @tc.number: MonitorCheckFrameAction_004
411 */
412 HWTEST(AudioStreamCheckerTest, MonitorCheckFrameAction_004, TestSize.Level1)
413 {
414 AudioProcessConfig cfg;
415 DataTransferMonitorParam para;
416 para.badDataTransferTypeBitMap = 3;
417 para.timeInterval = 2000000000;
418 para.badFramesRatio = 50;
419 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
420 checker->InitChecker(para, 100000, 100000);
421 CheckerParam checkerPara;
422 checkerPara.lastStatus = DATA_TRANS_RESUME;
423 checkerPara.sumFrameCount = 100;
424 int64_t abnormalFrameNum = 40;
425 float badFrameRatio = 0.5f;
426 checker->MonitorCheckFrameAction(checkerPara, abnormalFrameNum, badFrameRatio);
427 int size = checker->checkParaVector_.size();
428 EXPECT_GT(size, 0);
429 }
430 /**
431 * @tc.name : Test MonitorCheckFrameAction API
432 * @tc.type : FUNC
433 * @tc.number: MonitorCheckFrameAction_005
434 */
435 HWTEST(AudioStreamCheckerTest, MonitorCheckFrameAction_005, TestSize.Level1)
436 {
437 AudioProcessConfig cfg;
438 DataTransferMonitorParam para;
439 para.badDataTransferTypeBitMap = 3;
440 para.timeInterval = 2000000000;
441 para.badFramesRatio = 50;
442 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
443 checker->InitChecker(para, 100000, 100000);
444 CheckerParam checkerPara;
445 checkerPara.lastStatus = AUDIO_STREAM_PAUSE;
446 checkerPara.sumFrameCount = 100;
447 int64_t abnormalFrameNum = 40;
448 float badFrameRatio = 0.5f;
449 checker->MonitorCheckFrameAction(checkerPara, abnormalFrameNum, badFrameRatio);
450 int size = checker->checkParaVector_.size();
451 EXPECT_GT(size, 0);
452 }
453 /**
454 * @tc.name : Test MonitorCheckFrameAction API
455 * @tc.type : FUNC
456 * @tc.number: MonitorCheckFrameAction_006
457 */
458 HWTEST(AudioStreamCheckerTest, MonitorCheckFrameAction_006, TestSize.Level1)
459 {
460 AudioProcessConfig cfg;
461 DataTransferMonitorParam para;
462 para.badDataTransferTypeBitMap = 3;
463 para.timeInterval = 2000000000;
464 para.badFramesRatio = 50;
465 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
466 checker->InitChecker(para, 100000, 100000);
467 CheckerParam checkerPara;
468 checkerPara.lastStatus = DATA_TRANS_STOP;
469 checkerPara.sumFrameCount = 100;
470 int64_t abnormalFrameNum = 40;
471 float badFrameRatio = 0.5f;
472 checker->MonitorCheckFrameAction(checkerPara, abnormalFrameNum, badFrameRatio);
473 int size = checker->checkParaVector_.size();
474 EXPECT_GT(size, 0);
475 }
476
477 /**
478 * @tc.name : Test MonitorOnCallback API
479 * @tc.type : FUNC
480 * @tc.number: MonitorOnCallback_001
481 */
482 HWTEST(AudioStreamCheckerTest, MonitorOnCallback_001, TestSize.Level1)
483 {
484 AudioProcessConfig cfg;
485 DataTransferMonitorParam para;
486 para.badDataTransferTypeBitMap = 3;
487 para.timeInterval = 2000000000;
488 para.badFramesRatio = 50;
489 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
490 checker->InitChecker(para, 100000, 100000);
491 checker->monitorSwitch_ = false;
492 CheckerParam checkerPara;
493 checker->MonitorOnCallback(AUDIO_STREAM_START, true, checkerPara);
494 int size = checker->checkParaVector_.size();
495 EXPECT_GT(size, 0);
496 }
497
498 /**
499 * @tc.name : Test MonitorOnCallback API
500 * @tc.type : FUNC
501 * @tc.number: MonitorOnCallback_002
502 */
503 HWTEST(AudioStreamCheckerTest, MonitorOnCallback_002, TestSize.Level1)
504 {
505 AudioProcessConfig cfg;
506 DataTransferMonitorParam para;
507 para.badDataTransferTypeBitMap = 3;
508 para.timeInterval = 2000000000;
509 para.badFramesRatio = 50;
510 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
511 checker->InitChecker(para, 100000, 100000);
512 CheckerParam checkerPara;
513 checkerPara.sumFrameCount = 0;
514 checkerPara.hasInitCheck = true;
515 checker->MonitorOnCallback(AUDIO_STREAM_START, true, checkerPara);
516 int size = checker->checkParaVector_.size();
517 EXPECT_GT(size, 0);
518 }
519
520 /**
521 * @tc.name : Test MonitorOnCallback API
522 * @tc.type : FUNC
523 * @tc.number: MonitorOnCallback_003
524 */
525 HWTEST(AudioStreamCheckerTest, MonitorOnCallback_003, TestSize.Level1)
526 {
527 AudioProcessConfig cfg;
528 DataTransferMonitorParam para;
529 para.badDataTransferTypeBitMap = 3;
530 para.timeInterval = 2000000000;
531 para.badFramesRatio = 50;
532 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
533 checker->InitChecker(para, 100000, 100000);
534 CheckerParam checkerPara;
535 checkerPara.sumFrameCount = 100;
536 checkerPara.hasInitCheck = true;
537 checker->MonitorOnCallback(AUDIO_STREAM_START, true, checkerPara);
538 int size = checker->checkParaVector_.size();
539 EXPECT_GT(size, 0);
540 }
541
542 /**
543 * @tc.name : Test RecordStandbyTime API
544 * @tc.type : FUNC
545 * @tc.number: RecordStandbyTime_001
546 */
547 HWTEST(AudioStreamCheckerTest, RecordStandbyTime_001, TestSize.Level1)
548 {
549 AudioProcessConfig cfg;
550 DataTransferMonitorParam para;
551 para.badDataTransferTypeBitMap = 3;
552 para.timeInterval = 2000000000;
553 para.badFramesRatio = 50;
554 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
555 checker->InitChecker(para, 100000, 100000);
556 checker->RecordStandbyTime(true);
557 int64_t time = checker->checkParaVector_[0].standbyStartTime;
558 EXPECT_GT(time, 0);
559 }
560
561 /**
562 * @tc.name : Test RecordStandbyTime API
563 * @tc.type : FUNC
564 * @tc.number: RecordStandbyTime_002
565 */
566 HWTEST(AudioStreamCheckerTest, RecordStandbyTime_002, TestSize.Level1)
567 {
568 AudioProcessConfig cfg;
569 DataTransferMonitorParam para;
570 para.badDataTransferTypeBitMap = 3;
571 para.timeInterval = 2000000000;
572 para.badFramesRatio = 50;
573 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
574 checker->InitChecker(para, 100000, 100000);
575 checker->RecordStandbyTime(false);
576 int64_t time = checker->checkParaVector_[0].standbyStopTime;
577 EXPECT_GT(time, 0);
578 }
579
580 /**
581 * @tc.name : Test CalculateFrameAfterStandby API
582 * @tc.type : FUNC
583 * @tc.number: CalculateFrameAfterStandby_001
584 */
585 HWTEST(AudioStreamCheckerTest, CalculateFrameAfterStandby_001, TestSize.Level1)
586 {
587 AudioProcessConfig cfg;
588 DataTransferMonitorParam para;
589 para.badDataTransferTypeBitMap = 3;
590 para.timeInterval = 2000000000;
591 para.badFramesRatio = 50;
592 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
593 checker->InitChecker(para, 100000, 100000);
594 CheckerParam checkerPara;
595 checkerPara.isMonitorNoDataFrame = true;
596 checkerPara.standbyStartTime = ClockTime::GetCurNano();
597 checkerPara.standbyStopTime = checkerPara.standbyStartTime + 1000000000;
598 int64_t abnormalFrameNum = 0;
599 checker->CalculateFrameAfterStandby(checkerPara, abnormalFrameNum);
600 EXPECT_GT(abnormalFrameNum, 0);
601 }
602
603 /**
604 * @tc.name : Test CalculateFrameAfterStandby API
605 * @tc.type : FUNC
606 * @tc.number: CalculateFrameAfterStandby_002
607 */
608 HWTEST(AudioStreamCheckerTest, CalculateFrameAfterStandby_002, TestSize.Level1)
609 {
610 AudioProcessConfig cfg;
611 DataTransferMonitorParam para;
612 para.badDataTransferTypeBitMap = 3;
613 para.timeInterval = 2000000000;
614 para.badFramesRatio = 50;
615 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
616 checker->InitChecker(para, 100000, 100000);
617 CheckerParam checkerPara;
618 checkerPara.isMonitorNoDataFrame = true;
619 checkerPara.standbyStartTime = ClockTime::GetCurNano() - 1000000000;
620 checkerPara.standbyStopTime = 0;
621 int64_t abnormalFrameNum = 0;
622 checker->CalculateFrameAfterStandby(checkerPara, abnormalFrameNum);
623 EXPECT_GT(abnormalFrameNum, 0);
624 }
625
626 /**
627 * @tc.name : Test CalculateFrameAfterStandby API
628 * @tc.type : FUNC
629 * @tc.number: CalculateFrameAfterStandby_003
630 */
631 HWTEST(AudioStreamCheckerTest, CalculateFrameAfterStandby_003, TestSize.Level1)
632 {
633 AudioProcessConfig cfg;
634 DataTransferMonitorParam para;
635 para.badDataTransferTypeBitMap = 3;
636 para.timeInterval = 2000000000;
637 para.badFramesRatio = 50;
638 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
639 checker->InitChecker(para, 100000, 100000);
640 CheckerParam checkerPara;
641 checkerPara.isMonitorNoDataFrame = true;
642 checkerPara.standbyStartTime = 0;
643 checkerPara.lastUpdateTime = ClockTime::GetCurNano();
644 checkerPara.standbyStopTime = checkerPara.lastUpdateTime + 1000000000;
645 int64_t abnormalFrameNum = 0;
646 checker->CalculateFrameAfterStandby(checkerPara, abnormalFrameNum);
647 EXPECT_GT(abnormalFrameNum, 0);
648 }
649
650 /**
651 * @tc.name : Test CalculateFrameAfterStandby API
652 * @tc.type : FUNC
653 * @tc.number: CalculateFrameAfterStandby_004
654 */
655 HWTEST(AudioStreamCheckerTest, CalculateFrameAfterStandby_004, TestSize.Level1)
656 {
657 AudioProcessConfig cfg;
658 DataTransferMonitorParam para;
659 para.badDataTransferTypeBitMap = 3;
660 para.timeInterval = 2000000000;
661 para.badFramesRatio = 50;
662 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
663 checker->InitChecker(para, 100000, 100000);
664 CheckerParam checkerPara;
665 checkerPara.isMonitorNoDataFrame = true;
666 checkerPara.standbyStartTime = 0;
667 checkerPara.standbyStopTime = 0;
668 int64_t abnormalFrameNum = 0;
669 checker->CalculateFrameAfterStandby(checkerPara, abnormalFrameNum);
670 EXPECT_EQ(abnormalFrameNum, 0);
671 }
672
673 /**
674 * @tc.name : Test UpdateAppState API
675 * @tc.type : FUNC
676 * @tc.number: UpdateAppState_001
677 */
678 HWTEST(AudioStreamCheckerTest, UpdateAppState_001, TestSize.Level1)
679 {
680 AudioProcessConfig cfg;
681 DataTransferMonitorParam para;
682 para.badDataTransferTypeBitMap = 3;
683 para.timeInterval = 2000000000;
684 para.badFramesRatio = 50;
685 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
686 checker->InitChecker(para, 100000, 100000);
687 checker->UpdateAppState(true);
688 EXPECT_EQ(checker->isBackground_, true);
689 }
690
691 /**
692 * @tc.name : Test UpdateAppState API
693 * @tc.type : FUNC
694 * @tc.number: UpdateAppState_002
695 */
696 HWTEST(AudioStreamCheckerTest, UpdateAppState_002, TestSize.Level1)
697 {
698 AudioProcessConfig cfg;
699 DataTransferMonitorParam para;
700 para.badDataTransferTypeBitMap = 3;
701 para.timeInterval = 2000000000;
702 para.badFramesRatio = 50;
703 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
704 checker->InitChecker(para, 100000, 100000);
705 checker->UpdateAppState(false);
706 EXPECT_EQ(checker->isBackground_, false);
707 }
708
709 /**
710 * @tc.name : Test InitChecker API
711 * @tc.type : FUNC
712 * @tc.number: InitCheckerTest_002
713 */
714 HWTEST(AudioStreamCheckerTest, InitCheckerTest_002, TestSize.Level1)
715 {
716 DataTransferMonitorParam para;
717 int32_t pid = 100000;
718 int32_t callbackId = 100000;
719 CheckerParam checkerParamTest;
720
721 AudioProcessConfig cfg;
722 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
723 checkerParamTest.pid = pid;
724 checkerParamTest.callbackId = callbackId;
725 checkerParamTest.hasInitCheck = false;
726 checker->checkParaVector_.clear();
727 checker->checkParaVector_.push_back(checkerParamTest);
728
729 checker->InitChecker(para, pid, callbackId);
730 int32_t size = checker->checkParaVector_.size();
731 EXPECT_EQ(size, 1);
732 }
733
734 /**
735 * @tc.name : Test InitChecker API
736 * @tc.type : FUNC
737 * @tc.number: InitCheckerTest_003
738 */
739 HWTEST(AudioStreamCheckerTest, InitCheckerTest_003, TestSize.Level1)
740 {
741 AudioProcessConfig cfg;
742 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
743 DataTransferMonitorParam para;
744 int32_t pid = 100000;
745 int32_t callbackId = 100000;
746 CheckerParam checkerParamTest;
747
748 checkerParamTest.pid = 0;
749 checkerParamTest.callbackId = callbackId;
750 checkerParamTest.hasInitCheck = false;
751 checker->checkParaVector_.clear();
752 checker->checkParaVector_.push_back(checkerParamTest);
753 checker->isNeedCreateThread_.store(false);
754
755 checker->InitChecker(para, pid, callbackId);
756 int32_t size = checker->checkParaVector_.size();
757 EXPECT_EQ(size, 2);
758 }
759
760 /**
761 * @tc.name : Test InitChecker API
762 * @tc.type : FUNC
763 * @tc.number: InitCheckerTest_004
764 */
765 HWTEST(AudioStreamCheckerTest, InitCheckerTest_004, TestSize.Level1)
766 {
767 AudioProcessConfig cfg;
768 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
769 DataTransferMonitorParam para;
770 int32_t pid = 100000;
771 int32_t callbackId = 100000;
772 CheckerParam checkerParamTest;
773
774 checkerParamTest.pid = pid;
775 checkerParamTest.callbackId = 0;
776 checkerParamTest.hasInitCheck = false;
777 checker->checkParaVector_.clear();
778 checker->checkParaVector_.push_back(checkerParamTest);
779 checker->isNeedCreateThread_.store(true);
780
781 checker->InitChecker(para, pid, callbackId);
782 EXPECT_EQ(checker->isNeedCreateThread_.load(), false);
783 int32_t size = checker->checkParaVector_.size();
784 EXPECT_EQ(size, 2);
785 }
786
787 /**
788 * @tc.name : Test InitChecker API
789 * @tc.type : FUNC
790 * @tc.number: InitCheckerTest_005
791 */
792 HWTEST(AudioStreamCheckerTest, InitCheckerTest_005, TestSize.Level1)
793 {
794 AudioProcessConfig cfg;
795 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
796 DataTransferMonitorParam para;
797 int32_t pid = 100000;
798 int32_t callbackId = 100000;
799 CheckerParam checkerParamTest;
800 checkerParamTest.pid = 0;
801 checkerParamTest.callbackId = 0;
802 checkerParamTest.hasInitCheck = false;
803 checker->checkParaVector_.clear();
804 checker->checkParaVector_.push_back(checkerParamTest);
805 checker->isNeedCreateThread_.store(true);
806
807 checker->InitChecker(para, pid, callbackId);
808 EXPECT_EQ(checker->isNeedCreateThread_.load(), false);
809 int32_t size = checker->checkParaVector_.size();
810 EXPECT_EQ(size, 2);
811 }
812
813 /**
814 * @tc.name : Test DeleteCheckerPara API
815 * @tc.type : FUNC
816 * @tc.number: DeleteCheckerParaTest_002
817 */
818 HWTEST(AudioStreamCheckerTest, DeleteCheckerParaTest_002, TestSize.Level1)
819 {
820 AudioProcessConfig cfg;
821 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
822 CheckerParam checkerParamTest;
823 DataTransferMonitorParam para;
824
825 checkerParamTest.pid = 0;
826 checkerParamTest.callbackId = 0;
827 checkerParamTest.hasInitCheck = false;
828 checker->checkParaVector_.clear();
829 checker->checkParaVector_.push_back(checkerParamTest);
830 checker->isNeedCreateThread_.store(false);
831
832 checker->InitChecker(para, 100000, 100000);
833 checker->DeleteCheckerPara(100000, 100000);
834
835 int32_t size = checker->checkParaVector_.size();
836 EXPECT_EQ(size, 1);
837 EXPECT_EQ(checker->isNeedCreateThread_.load(), false);
838 }
839
840 /**
841 * @tc.name : Test DeleteCheckerPara API
842 * @tc.type : FUNC
843 * @tc.number: DeleteCheckerParaTest_003
844 */
845 HWTEST(AudioStreamCheckerTest, DeleteCheckerParaTest_003, TestSize.Level1)
846 {
847 AudioProcessConfig cfg;
848 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
849 CheckerParam checkerParamTest;
850 DataTransferMonitorParam para;
851
852 checkerParamTest.pid = 0;
853 checkerParamTest.callbackId = 0;
854 checkerParamTest.hasInitCheck = false;
855 checker->checkParaVector_.clear();
856 checker->checkParaVector_.push_back(checkerParamTest);
857 checker->isNeedCreateThread_.store(false);
858
859 checker->InitChecker(para, 100000, 100000);
860 checker->DeleteCheckerPara(100000, 0);
861
862 int32_t size = checker->checkParaVector_.size();
863 EXPECT_EQ(size, 2);
864 EXPECT_EQ(checker->isNeedCreateThread_.load(), false);
865 }
866
867 /**
868 * @tc.name : Test DeleteCheckerPara API
869 * @tc.type : FUNC
870 * @tc.number: DeleteCheckerParaTest_004
871 */
872 HWTEST(AudioStreamCheckerTest, DeleteCheckerParaTest_004, TestSize.Level1)
873 {
874 AudioProcessConfig cfg;
875 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
876 CheckerParam checkerParamTest;
877 DataTransferMonitorParam para;
878
879 checkerParamTest.pid = 0;
880 checkerParamTest.callbackId = 0;
881 checkerParamTest.hasInitCheck = false;
882 checker->checkParaVector_.clear();
883 checker->checkParaVector_.push_back(checkerParamTest);
884 checker->isNeedCreateThread_.store(false);
885
886 checker->InitChecker(para, 100000, 100000);
887 checker->DeleteCheckerPara(0, 100000);
888
889 int32_t size = checker->checkParaVector_.size();
890 EXPECT_EQ(size, 2);
891 EXPECT_EQ(checker->isNeedCreateThread_.load(), false);
892 }
893
894 /**
895 * @tc.name : Test CalculateFrameAfterStandby API
896 * @tc.type : FUNC
897 * @tc.number: CalculateFrameAfterStandby_005
898 */
899 HWTEST(AudioStreamCheckerTest, CalculateFrameAfterStandby_005, TestSize.Level1)
900 {
901 AudioProcessConfig cfg;
902 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
903 CheckerParam para;
904 int64_t abnormalFrameNum = 0;
905
906 para.standbyStartTime = 1;
907 para.standbyStopTime = 20000001;
908 para.isMonitorNoDataFrame = true;
909 checker->streamConfig_.rendererInfo.rendererFlags = 0;
910 checker->CalculateFrameAfterStandby(para, abnormalFrameNum);
911 EXPECT_EQ(abnormalFrameNum, 1);
912 }
913
914 /**
915 * @tc.name : Test CalculateFrameAfterStandby API
916 * @tc.type : FUNC
917 * @tc.number: CalculateFrameAfterStandby_006
918 */
919 HWTEST(AudioStreamCheckerTest, CalculateFrameAfterStandby_006, TestSize.Level1)
920 {
921 AudioProcessConfig cfg;
922 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
923 CheckerParam para;
924 int64_t abnormalFrameNum = 0;
925
926 para.standbyStartTime = 0;
927 para.standbyStopTime = 20000000;
928 para.lastUpdateTime = 0;
929 para.isMonitorNoDataFrame = true;
930 checker->streamConfig_.rendererInfo.rendererFlags = 0;
931 checker->CalculateFrameAfterStandby(para, abnormalFrameNum);
932 EXPECT_EQ(abnormalFrameNum, 1);
933 }
934
935 /**
936 * @tc.name : Test OnRemoteAppDied API
937 * @tc.type : FUNC
938 * @tc.number: OnRemoteAppDied_002
939 */
940 HWTEST(AudioStreamCheckerTest, OnRemoteAppDied_002, TestSize.Level1)
941 {
942 AudioProcessConfig cfg;
943 DataTransferMonitorParam para;
944 para.badDataTransferTypeBitMap = 3;
945 para.timeInterval = 2000000000;
946 para.badFramesRatio = 50;
947 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
948 checker->InitChecker(para, 100000, 200000);
949 checker->InitChecker(para, 100001, 200001);
950
951 checker->OnRemoteAppDied(100000);
952 int size = checker->checkParaVector_.size();
953 EXPECT_EQ(size, 1);
954 }
955
956 /**
957 * @tc.name : Test OnRemoteAppDied API
958 * @tc.type : FUNC
959 * @tc.number: OnRemoteAppDied_003
960 */
961 HWTEST(AudioStreamCheckerTest, OnRemoteAppDied_003, TestSize.Level1)
962 {
963 AudioProcessConfig cfg;
964 DataTransferMonitorParam para;
965 para.badDataTransferTypeBitMap = 3;
966 para.timeInterval = 2000000000;
967 para.badFramesRatio = 50;
968 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
969 checker->InitChecker(para, 100000, 200000);
970 checker->InitChecker(para, 100001, 200001);
971 checker->InitChecker(para, 100002, 200002);
972
973 checker->OnRemoteAppDied(100000);
974 checker->OnRemoteAppDied(100001);
975 int size = checker->checkParaVector_.size();
976 EXPECT_EQ(size, 1);
977 }
978
979 /**
980 * @tc.name : Test OnRemoteAppDied API
981 * @tc.type : FUNC
982 * @tc.number: OnRemoteAppDied_004
983 */
984 HWTEST(AudioStreamCheckerTest, OnRemoteAppDied_004, TestSize.Level1)
985 {
986 AudioProcessConfig cfg;
987 DataTransferMonitorParam para;
988 para.badDataTransferTypeBitMap = 3;
989 para.timeInterval = 2000000000;
990 para.badFramesRatio = 50;
991 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
992 checker->InitChecker(para, 100000, 200000);
993 checker->InitChecker(para, 100001, 200001);
994
995 checker->OnRemoteAppDied(100003);
996 int size = checker->checkParaVector_.size();
997 EXPECT_EQ(size, 2);
998 }
999
1000 /**
1001 * @tc.name : Test OnRemoteAppDied API
1002 * @tc.type : FUNC
1003 * @tc.number: OnRemoteAppDied_005
1004 */
1005 HWTEST(AudioStreamCheckerTest, OnRemoteAppDied_005, TestSize.Level1)
1006 {
1007 AudioProcessConfig cfg;
1008 DataTransferMonitorParam para;
1009 para.badDataTransferTypeBitMap = 3;
1010 para.timeInterval = 2000000000;
1011 para.badFramesRatio = 50;
1012 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1013 checker->InitChecker(para, 100000, 100000);
1014 checker->OnRemoteAppDied(100000);
1015
1016 EXPECT_EQ(checker->isNeedCreateThread_.load(), true);
1017 EXPECT_EQ(checker->isKeepCheck_.load(), false);
1018 }
1019
1020 /**
1021 * @tc.name : Test MonitorCheckFrame API
1022 * @tc.type : FUNC
1023 * @tc.number: MonitorCheckFrame_004
1024 */
1025 HWTEST(AudioStreamCheckerTest, MonitorCheckFrame_004, TestSize.Level1)
1026 {
1027 AudioProcessConfig cfg;
1028 DataTransferMonitorParam para;
1029 para.badDataTransferTypeBitMap = 3;
1030 para.timeInterval = 2000000000;
1031 para.badFramesRatio = 50;
1032 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1033 checker->InitChecker(para, 100000, 100000);
1034 checker->monitorSwitch_ = false;
1035
1036 checker->MonitorCheckFrame();
1037 int size = checker->checkParaVector_.size();
1038 EXPECT_EQ(size, 1);
1039 }
1040
1041 /**
1042 * @tc.name : Test MonitorCheckFrameAction API
1043 * @tc.type : FUNC
1044 * @tc.number: MonitorCheckFrameAction_007
1045 */
1046 HWTEST(AudioStreamCheckerTest, MonitorCheckFrameAction_007, TestSize.Level1)
1047 {
1048 AudioProcessConfig cfg;
1049 DataTransferMonitorParam para;
1050 para.badDataTransferTypeBitMap = 3;
1051 para.timeInterval = 2000000000;
1052 para.badFramesRatio = 50;
1053 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1054 checker->InitChecker(para, 100000, 100000);
1055 CheckerParam checkerPara;
1056 checkerPara.lastStatus = AUDIO_STREAM_PAUSE;
1057 checkerPara.sumFrameCount = 100;
1058 int64_t abnormalFrameNum = 40;
1059 float badFrameRatio = 0.5f;
1060
1061 checker->MonitorCheckFrameAction(checkerPara, abnormalFrameNum, badFrameRatio);
1062 int size = checker->checkParaVector_.size();
1063 EXPECT_GT(size, 0);
1064 }
1065
1066 /**
1067 * @tc.name : Test MonitorCheckFrameAction API
1068 * @tc.type : FUNC
1069 * @tc.number: MonitorCheckFrameAction_008
1070 */
1071 HWTEST(AudioStreamCheckerTest, MonitorCheckFrameAction_008, TestSize.Level1)
1072 {
1073 AudioProcessConfig cfg;
1074 DataTransferMonitorParam para;
1075 para.badDataTransferTypeBitMap = 3;
1076 para.timeInterval = 2000000000;
1077 para.badFramesRatio = 50;
1078 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1079 checker->InitChecker(para, 100000, 100000);
1080 CheckerParam checkerPara;
1081 checkerPara.lastStatus = DATA_TRANS_STOP;
1082 checkerPara.sumFrameCount = 100;
1083 int64_t abnormalFrameNum = 40;
1084 float badFrameRatio = 0.5f;
1085
1086 checker->MonitorCheckFrameAction(checkerPara, abnormalFrameNum, badFrameRatio);
1087 int size = checker->checkParaVector_.size();
1088 EXPECT_GT(size, 0);
1089 }
1090
1091 /**
1092 * @tc.name : Test MonitorCheckFrameSub API
1093 * @tc.type : FUNC
1094 * @tc.number: MonitorCheckFrameSub_004
1095 */
1096 HWTEST(AudioStreamCheckerTest, MonitorCheckFrameSub_004, TestSize.Level1)
1097 {
1098 AudioProcessConfig cfg;
1099 DataTransferMonitorParam para;
1100 para.badDataTransferTypeBitMap = 3;
1101 para.timeInterval = 2000000000;
1102 para.badFramesRatio = 50;
1103 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1104 checker->InitChecker(para, 100000, 100000);
1105 CheckerParam checkerPara;
1106 checkerPara.lastStatus = DATA_TRANS_STOP;
1107 checkerPara.sumFrameCount = 100;
1108 checkerPara.hasInitCheck = false;
1109
1110 checker->MonitorCheckFrameSub(checkerPara);
1111 int size = checker->checkParaVector_.size();
1112 EXPECT_GT(size, 0);
1113 }
1114
1115 /**
1116 * @tc.name : Test MonitorCheckFrameSub API
1117 * @tc.type : FUNC
1118 * @tc.number: MonitorCheckFrameSub_005
1119 */
1120 HWTEST(AudioStreamCheckerTest, MonitorCheckFrameSub_005, TestSize.Level1)
1121 {
1122 AudioProcessConfig cfg;
1123 DataTransferMonitorParam para;
1124 para.badDataTransferTypeBitMap = 3;
1125 para.timeInterval = 2000000000;
1126 para.badFramesRatio = 50;
1127 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1128 checker->InitChecker(para, 100000, 100000);
1129 CheckerParam checkerPara;
1130 checkerPara.lastStatus = DATA_TRANS_STOP;
1131 checkerPara.sumFrameCount = 100;
1132 checkerPara.hasInitCheck = true;
1133 checkerPara.isMonitorMuteFrame = true;
1134
1135 checker->MonitorCheckFrameSub(checkerPara);
1136 int size = checker->checkParaVector_.size();
1137 EXPECT_GT(size, 0);
1138 }
1139
1140 /**
1141 * @tc.name : Test MonitorOnAllCallback API
1142 * @tc.type : FUNC
1143 * @tc.number: MonitorOnAllCallback_004
1144 */
1145 HWTEST(AudioStreamCheckerTest, MonitorOnAllCallback_004, TestSize.Level1)
1146 {
1147 AudioProcessConfig cfg;
1148 DataTransferMonitorParam para;
1149 para.badDataTransferTypeBitMap = 3;
1150 para.timeInterval = 2000000000;
1151 para.badFramesRatio = 50;
1152 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1153 checker->InitChecker(para, 100000, 100000);
1154 checker->monitorSwitch_ = false;
1155 DataTransferStateChangeType type = AUDIO_STREAM_START;
1156
1157 checker->MonitorOnAllCallback(type, true);
1158 int size = checker->checkParaVector_.size();
1159 EXPECT_EQ(size, 1);
1160 }
1161
1162 /**
1163 * @tc.name : Test MonitorOnAllCallback API
1164 * @tc.type : FUNC
1165 * @tc.number: MonitorOnAllCallback_005
1166 */
1167 HWTEST(AudioStreamCheckerTest, MonitorOnAllCallback_005, TestSize.Level1)
1168 {
1169 AudioProcessConfig cfg;
1170 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1171 CheckerParam checkerParamTest;
1172 checkerParamTest.pid = 0;
1173 checkerParamTest.callbackId = 0;
1174 checkerParamTest.isMonitorNoDataFrame = false;
1175 checker->checkParaVector_.clear();
1176 checker->checkParaVector_.push_back(checkerParamTest);
1177
1178 checker->monitorSwitch_ = true;
1179 DataTransferStateChangeType type = DATA_TRANS_RESUME;
1180
1181 checker->MonitorOnAllCallback(type, true);
1182 int size = checker->checkParaVector_.size();
1183 EXPECT_EQ(size, 1);
1184 }
1185
1186 /**
1187 * @tc.name : Test RecordStandbyTime API
1188 * @tc.type : FUNC
1189 * @tc.number: RecordStandbyTime_003
1190 */
1191 HWTEST(AudioStreamCheckerTest, RecordStandbyTime_003, TestSize.Level1)
1192 {
1193 AudioProcessConfig cfg;
1194 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1195 CheckerParam checkerParamTest;
1196 checkerParamTest.pid = 0;
1197 checkerParamTest.standbyStartTime = 0;
1198 checkerParamTest.isMonitorNoDataFrame = false;
1199 checker->checkParaVector_.clear();
1200 checker->checkParaVector_.push_back(checkerParamTest);
1201
1202 checker->RecordStandbyTime(false);
1203 int size = checker->checkParaVector_.size();
1204 EXPECT_EQ(size, 1);
1205 EXPECT_TRUE(checker->checkParaVector_[0].standbyStopTime > 0);
1206 EXPECT_EQ(checker->checkParaVector_[0].isInStandby, false);
1207 }
1208
1209 /**
1210 * @tc.name : Test MonitorOnCallback API
1211 * @tc.type : FUNC
1212 * @tc.number: MMonitorOnCallback_004
1213 */
1214 HWTEST(AudioStreamCheckerTest, MonitorOnCallback_004, TestSize.Level1)
1215 {
1216 AudioProcessConfig cfg;
1217 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1218 CheckerParam checkerParamTest;
1219 checkerParamTest.pid = 0;
1220 checkerParamTest.lastUpdateTime = 0;
1221 checkerParamTest.hasInitCheck = true;
1222 checker->checkParaVector_.clear();
1223 checker->checkParaVector_.push_back(checkerParamTest);
1224
1225 DataTransferStateChangeType type = AUDIO_STREAM_START;
1226 checker->monitorSwitch_ = false;
1227
1228 checker->MonitorOnCallback(type, true, checkerParamTest);
1229 int size = checker->checkParaVector_.size();
1230 EXPECT_EQ(size, 1);
1231 EXPECT_TRUE(checkerParamTest.lastUpdateTime > 0);
1232 }
1233
1234 /**
1235 * @tc.name : Test MonitorOnCallback API
1236 * @tc.type : FUNC
1237 * @tc.number: MMonitorOnCallback_005
1238 */
1239 HWTEST(AudioStreamCheckerTest, MonitorOnCallback_005, TestSize.Level1)
1240 {
1241 AudioProcessConfig cfg;
1242 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1243 CheckerParam checkerParamTest;
1244 checkerParamTest.sumFrameCount = 1;
1245 checkerParamTest.lastUpdateTime = 0;
1246 checkerParamTest.hasInitCheck = true;
1247 checker->checkParaVector_.clear();
1248 checker->checkParaVector_.push_back(checkerParamTest);
1249
1250 DataTransferStateChangeType type = AUDIO_STREAM_START;
1251 checker->monitorSwitch_ = true;
1252
1253 checker->MonitorOnCallback(type, true, checkerParamTest);
1254 EXPECT_EQ(checkerParamTest.lastStatus, AUDIO_STREAM_START);
1255 EXPECT_TRUE(checkerParamTest.lastUpdateTime > 0);
1256 }
1257
1258 /**
1259 * @tc.name : Test IsMonitorMuteFrame API
1260 * @tc.type : FUNC
1261 * @tc.number: IsMonitorMuteFrame_001
1262 */
1263 HWTEST(AudioStreamCheckerTest, IsMonitorMuteFrame_001, TestSize.Level1)
1264 {
1265 AudioProcessConfig cfg;
1266 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1267 CheckerParam checkerParamTest;
1268 checkerParamTest.hasInitCheck = false;
1269
1270 bool ret = checker->IsMonitorMuteFrame(checkerParamTest);
1271 EXPECT_EQ(ret, false);
1272 }
1273
1274 /**
1275 * @tc.name : Test IsMonitorNoDataFrame API
1276 * @tc.type : FUNC
1277 * @tc.number: IsMonitorNoDataFrame_001
1278 */
1279 HWTEST(AudioStreamCheckerTest, IsMonitorNoDataFrame_001, TestSize.Level1)
1280 {
1281 AudioProcessConfig cfg;
1282 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1283 CheckerParam checkerParamTest;
1284 checkerParamTest.hasInitCheck = false;
1285
1286 bool ret = checker->IsMonitorNoDataFrame(checkerParamTest);
1287 EXPECT_EQ(ret, false);
1288 }
1289
1290 /**
1291 * @tc.name : Test DeleteCheckerPara API
1292 * @tc.type : FUNC
1293 * @tc.number: DeleteCheckerPara_002
1294 */
1295 HWTEST(AudioStreamCheckerTest, DeleteCheckerPara_002, TestSize.Level1)
1296 {
1297 AudioProcessConfig cfg;
1298 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1299 checker->checkParaVector_.push_back({1, 1});
1300 checker->DeleteCheckerPara(1, 1);
1301 EXPECT_EQ(checker->checkParaVector_.size(), 0);
1302 }
1303
1304 /**
1305 * @tc.name : Test DeleteCheckerPara API
1306 * @tc.type : FUNC
1307 * @tc.number: DeleteCheckerPara_003
1308 */
1309 HWTEST(AudioStreamCheckerTest, DeleteCheckerPara_003, TestSize.Level1)
1310 {
1311 AudioProcessConfig cfg;
1312 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1313 checker->checkParaVector_.push_back({1, 1});
1314 checker->DeleteCheckerPara(2, 2);
1315 EXPECT_EQ(checker->checkParaVector_.size(), 1);
1316 }
1317
1318 /**
1319 * @tc.name : Test DeleteCheckerPara API
1320 * @tc.type : FUNC
1321 * @tc.number: DeleteCheckerPara_004
1322 */
1323 HWTEST(AudioStreamCheckerTest, DeleteCheckerPara_004, TestSize.Level1)
1324 {
1325 AudioProcessConfig cfg;
1326 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1327 checker->DeleteCheckerPara(1, 1);
1328 EXPECT_EQ(checker->checkParaVector_.size(), 0);
1329 }
1330
1331 /**
1332 * @tc.name : Test OnRemoteAppDied API
1333 * @tc.type : FUNC
1334 * @tc.number: OnRemoteAppDied_006
1335 */
1336 HWTEST(AudioStreamCheckerTest, OnRemoteAppDied_006, TestSize.Level1)
1337 {
1338 AudioProcessConfig cfg;
1339 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1340 int32_t pid = 1234;
1341 checker->checkParaVector_.push_back({pid, 0});
1342 checker->OnRemoteAppDied(pid);
1343 EXPECT_EQ(checker->checkParaVector_.size(), 0);
1344 EXPECT_EQ(checker->isNeedCreateThread_.load(), true);
1345 EXPECT_EQ(checker->isKeepCheck_.load(), false);
1346 }
1347
1348 /**
1349 * @tc.name : Test OnRemoteAppDied API
1350 * @tc.type : FUNC
1351 * @tc.number: OnRemoteAppDied_007
1352 */
1353 HWTEST(AudioStreamCheckerTest, OnRemoteAppDied_007, TestSize.Level1)
1354 {
1355 AudioProcessConfig cfg;
1356 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1357 int32_t pid = 1234;
1358 checker->checkParaVector_.push_back({5678, 0});
1359 checker->OnRemoteAppDied(pid);
1360 EXPECT_EQ(checker->checkParaVector_.size(), 1);
1361 EXPECT_EQ(checker->isNeedCreateThread_.load(), true);
1362 EXPECT_NE(checker->isKeepCheck_.load(), true);
1363 }
1364
1365 /**
1366 * @tc.name : Test OnRemoteAppDied API
1367 * @tc.type : FUNC
1368 * @tc.number: OnRemoteAppDied_008
1369 */
1370 HWTEST(AudioStreamCheckerTest, OnRemoteAppDied_008, TestSize.Level1)
1371 {
1372 AudioProcessConfig cfg;
1373 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1374 int32_t pid = 1234;
1375 checker->OnRemoteAppDied(pid);
1376 EXPECT_EQ(checker->checkParaVector_.size(), 0);
1377 EXPECT_EQ(checker->isNeedCreateThread_.load(), true);
1378 EXPECT_EQ(checker->isKeepCheck_.load(), false);
1379 }
1380
1381 /**
1382 * @tc.name : Test MonitorCheckFrame API
1383 * @tc.type : FUNC
1384 * @tc.number: MonitorCheckFrame_005
1385 */
1386 HWTEST(AudioStreamCheckerTest, MonitorCheckFrame_005, TestSize.Level0)
1387 {
1388 AudioProcessConfig cfg;
1389 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1390 checker->monitorSwitch_ = false;
1391 checker->MonitorCheckFrame();
1392 EXPECT_FALSE(checker->monitorSwitch_);
1393 }
1394
1395 /**
1396 * @tc.name : Test MonitorCheckFrame API
1397 * @tc.type : FUNC
1398 * @tc.number: MonitorCheckFrame_006
1399 */
1400 HWTEST(AudioStreamCheckerTest, MonitorCheckFrame_006, TestSize.Level0)
1401 {
1402 AudioProcessConfig cfg;
1403 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1404 checker->monitorSwitch_ = true;
1405 CheckerParam checkerParamTest;
1406 checkerParamTest.pid = 0;
1407 checkerParamTest.lastUpdateTime = 0;
1408 checkerParamTest.hasInitCheck = true;
1409 checker->checkParaVector_.clear();
1410 checker->checkParaVector_.push_back(checkerParamTest); // Assuming CheckPara is a valid struct
1411 checker->MonitorCheckFrame();
1412 EXPECT_TRUE(checker->monitorSwitch_);
1413 }
1414
1415 /**
1416 * @tc.name : Test CalculateFrameAfterStandby API
1417 * @tc.type : FUNC
1418 * @tc.number: CalculateFrameAfterStandby_007
1419 */
1420 HWTEST(AudioStreamCheckerTest, CalculateFrameAfterStandby_007, TestSize.Level0)
1421 {
1422 AudioProcessConfig cfg;
1423 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1424 CheckerParam para;
1425 para.standbyStartTime = 0;
1426 para.standbyStopTime = 0;
1427 int64_t abnormalFrameNum = 0;
1428 checker->CalculateFrameAfterStandby(para, abnormalFrameNum);
1429 EXPECT_EQ(abnormalFrameNum, 0);
1430 }
1431
1432 /**
1433 * @tc.name : Test CalculateFrameAfterStandby API
1434 * @tc.type : FUNC
1435 * @tc.number: CalculateFrameAfterStandby_008
1436 */
1437 HWTEST(AudioStreamCheckerTest, CalculateFrameAfterStandby_008, TestSize.Level0)
1438 {
1439 AudioProcessConfig cfg;
1440 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1441 CheckerParam para;
1442 para.standbyStartTime = 0;
1443 para.standbyStopTime = 200;
1444 int64_t abnormalFrameNum = 0;
1445 checker->CalculateFrameAfterStandby(para, abnormalFrameNum);
1446 EXPECT_NE(abnormalFrameNum, 10);
1447 }
1448
1449 /**
1450 * @tc.name : Test MonitorCheckFrameSub API
1451 * @tc.type : FUNC
1452 * @tc.number: MonitorCheckFrameSub_006
1453 */
1454 HWTEST(AudioStreamCheckerTest, MonitorCheckFrameSub_006, TestSize.Level0)
1455 {
1456 AudioProcessConfig cfg;
1457 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1458 CheckerParam para;
1459 para.hasInitCheck = false;
1460 para.para.clientUID = 12345;
1461 checker->MonitorCheckFrameSub(para);
1462 EXPECT_NE(para.lastStatus, -1); // Assuming lastStatus is updated in the function
1463 }
1464
1465 /**
1466 * @tc.name : Test MonitorCheckFrameSub API
1467 * @tc.type : FUNC
1468 * @tc.number: MonitorCheckFrameSub_007
1469 */
1470 HWTEST(AudioStreamCheckerTest, MonitorCheckFrameSub_007, TestSize.Level0)
1471 {
1472 AudioProcessConfig cfg;
1473 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1474 CheckerParam para;
1475 para.hasInitCheck = true;
1476 para.isMonitorMuteFrame = true;
1477 para.muteFrameNum = 10;
1478 checker->MonitorCheckFrameSub(para);
1479 EXPECT_NE(para.lastStatus, -1); // Assuming lastStatus is updated in the function
1480 }
1481
1482 /**
1483 * @tc.name : Test MonitorOnAllCallback API
1484 * @tc.type : FUNC
1485 * @tc.number: MonitorOnAllCallback_008
1486 */
1487 HWTEST(AudioStreamCheckerTest, MonitorOnAllCallback_008, TestSize.Level1)
1488 {
1489 AudioProcessConfig cfg;
1490 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1491 checker->monitorSwitch_ = false;
1492 checker->MonitorOnAllCallback(DATA_TRANS_RESUME, false);
1493 EXPECT_FALSE(checker->monitorSwitch_);
1494 }
1495
1496 /**
1497 * @tc.name : Test MonitorOnAllCallback API
1498 * @tc.type : FUNC
1499 * @tc.number: MonitorOnAllCallback_009
1500 */
1501 HWTEST(AudioStreamCheckerTest, MonitorOnAllCallback_009, TestSize.Level1)
1502 {
1503 AudioProcessConfig cfg;
1504 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1505 checker->monitorSwitch_ = true;
1506 CheckerParam checkerParamTest;
1507 checkerParamTest.pid = 0;
1508 checkerParamTest.lastUpdateTime = 0;
1509 checkerParamTest.hasInitCheck = true;
1510 checker->checkParaVector_.clear();
1511 checker->checkParaVector_.push_back(checkerParamTest);
1512 checker->MonitorOnAllCallback(DATA_TRANS_RESUME, true);
1513 EXPECT_TRUE(checker->monitorSwitch_);
1514 }
1515
1516 /**
1517 * @tc.name : Test MonitorOnAllCallback API
1518 * @tc.type : FUNC
1519 * @tc.number: MonitorOnAllCallback_0010
1520 */
1521 HWTEST(AudioStreamCheckerTest, MonitorOnAllCallback_010, TestSize.Level1)
1522 {
1523 AudioProcessConfig cfg;
1524 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1525 checker->monitorSwitch_ = true;
1526 CheckerParam checkerParamTest;
1527 checkerParamTest.pid = 0;
1528 checkerParamTest.lastUpdateTime = 0;
1529 checkerParamTest.hasInitCheck = false;
1530 checker->checkParaVector_.clear();
1531 checker->checkParaVector_.push_back(checkerParamTest);
1532 checker->MonitorOnAllCallback(DATA_TRANS_RESUME, false);
1533 EXPECT_TRUE(checker->monitorSwitch_);
1534 }
1535
1536 /**
1537 * @tc.name : Test CheckVolume API
1538 * @tc.type : FUNC
1539 * @tc.number: CheckVolume_001
1540 */
1541 HWTEST(AudioStreamCheckerTest, CheckVolume_001, TestSize.Level1)
1542 {
1543 AudioProcessConfig cfg;
1544 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1545
1546 checker->curVolume_ = 0.0f;
1547 checker->preVolume_ = 0.0f;
1548 checker->CheckVolume();
1549 EXPECT_EQ(checker->curVolume_, checker->preVolume_);
1550
1551 checker->curVolume_ = 0.0f;
1552 checker->preVolume_ = 1.0f;
1553 checker->CheckVolume();
1554 EXPECT_EQ(checker->curVolume_, checker->preVolume_);
1555
1556 checker->curVolume_ = 1.0f;
1557 checker->preVolume_ = 0.0f;
1558 checker->CheckVolume();
1559 EXPECT_EQ(checker->curVolume_, checker->preVolume_);
1560
1561 checker->curVolume_ = 1.0f;
1562 checker->preVolume_ = 1.0f;
1563 checker->CheckVolume();
1564 EXPECT_EQ(checker->curVolume_, checker->preVolume_);
1565 }
1566
1567 /**
1568 * @tc.name : Test MonitorCheckFrameSub API
1569 * @tc.type : FUNC
1570 * @tc.number: MonitorCheckFrameSub_008
1571 */
1572 HWTEST(AudioStreamCheckerTest, MonitorCheckFrameSub_008, TestSize.Level1)
1573 {
1574 AudioProcessConfig cfg;
1575 DataTransferMonitorParam para;
1576 para.badDataTransferTypeBitMap = 3;
1577 para.timeInterval = 2000000000;
1578 para.badFramesRatio = 50;
1579 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1580 checker->InitChecker(para, 100000, 100000);
1581 CheckerParam checkerPara;
1582 checkerPara.hasInitCheck = true;
1583 checkerPara.isMonitorMuteFrame = false;
1584 checkerPara.isMonitorNoDataFrame = true;
1585 checker->MonitorCheckFrameSub(checkerPara);
1586 int size = checker->checkParaVector_.size();
1587 EXPECT_NE(0, size);
1588 }
1589
1590 /**
1591 * @tc.name : Test MonitorOnCallback API
1592 * @tc.type : FUNC
1593 * @tc.number: MonitorOnCallback_006
1594 */
1595 HWTEST(AudioStreamCheckerTest, MonitorOnCallback_006, TestSize.Level1)
1596 {
1597 AudioProcessConfig cfg;
1598 DataTransferMonitorParam para;
1599 para.badDataTransferTypeBitMap = 3;
1600 para.timeInterval = 2000000000;
1601 para.badFramesRatio = 50;
1602 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1603 checker->InitChecker(para, 100000, 100000);
1604 CheckerParam checkerPara;
1605 checker->monitorSwitch_ = false;
1606
1607 checker->MonitorOnCallback(AUDIO_STREAM_START, true, checkerPara);
1608 EXPECT_EQ(DATA_TRANS_RESUME, checkerPara.lastStatus);
1609
1610 checkerPara.pid = 100;
1611 checker->MonitorOnCallback(AUDIO_STREAM_PAUSE, true, checkerPara);
1612 EXPECT_EQ(0, checkerPara.sumFrameCount);
1613
1614 checker->monitorSwitch_ = true;
1615 checkerPara.sumFrameCount = 100;
1616 checker->MonitorOnCallback(AUDIO_STREAM_START, false, checkerPara);
1617 EXPECT_EQ(0, checkerPara.callbackId);
1618 }
1619
1620 /**
1621 * @tc.name : Test CalculateFrameAfterStandby API
1622 * @tc.type : FUNC
1623 * @tc.number: CalculateFrameAfterStandby_009
1624 */
1625 HWTEST(AudioStreamCheckerTest, CalculateFrameAfterStandby_009, TestSize.Level1)
1626 {
1627 AudioProcessConfig cfg;
1628 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1629 CheckerParam para;
1630 int64_t abnormalFrameNum = 0;
1631 checker->streamConfig_.rendererInfo.rendererFlags = 0;
1632
1633 checker->CalculateFrameAfterStandby(para, abnormalFrameNum);
1634 EXPECT_EQ(false, para.isMonitorNoDataFrame);
1635
1636 para.standbyStopTime = DEFAULT_TIME;
1637 para.isMonitorNoDataFrame = true;
1638 checker->CalculateFrameAfterStandby(para, abnormalFrameNum);
1639 EXPECT_EQ(0, para.sumFrameCount);
1640
1641 para.isInStandby = 1;
1642 checker->CalculateFrameAfterStandby(para, abnormalFrameNum);
1643 EXPECT_EQ(DATA_TRANS_RESUME, para.lastStatus);
1644 }
1645
1646 /**
1647 * @tc.name : Test MonitorCheckFrame API
1648 * @tc.type : FUNC
1649 * @tc.number: MonitorCheckFrame_007
1650 */
1651 HWTEST(AudioStreamCheckerTest, MonitorCheckFrame_007, TestSize.Level1)
1652 {
1653 AudioProcessConfig cfg;
1654 DataTransferMonitorParam para;
1655 para.badDataTransferTypeBitMap = 3;
1656 para.timeInterval = 2000000000;
1657 para.badFramesRatio = 50;
1658 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1659 checker->InitChecker(para, 100000, 100000);
1660 checker->monitorSwitch_ = true;
1661
1662 checker->MonitorCheckFrame();
1663 int size = checker->checkParaVector_.size();
1664 EXPECT_EQ(1, size);
1665 }
1666
1667 /**
1668 * @tc.name : Test MonitorCheckFrameAction API
1669 * @tc.type : FUNC
1670 * @tc.number: MonitorCheckFrameAction_009
1671 */
1672 HWTEST(AudioStreamCheckerTest, MonitorCheckFrameAction_009, TestSize.Level1)
1673 {
1674 AudioProcessConfig cfg;
1675 DataTransferMonitorParam para;
1676 para.badDataTransferTypeBitMap = 3;
1677 para.timeInterval = 2000000000;
1678 para.badFramesRatio = 50;
1679 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1680 checker->InitChecker(para, 100000, 100000);
1681 CheckerParam checkerPara;
1682 checkerPara.sumFrameCount = 100;
1683 int64_t abnormalFrameNum = 40;
1684 float badFrameRatio = 0.5f;
1685
1686 checkerPara.lastStatus = DATA_TRANS_STOP;
1687 checker->MonitorCheckFrameAction(checkerPara, abnormalFrameNum, badFrameRatio);
1688 EXPECT_EQ(0, checkerPara.noDataFrameNum);
1689
1690 checkerPara.lastStatus = AUDIO_STREAM_STOP;
1691 checker->MonitorCheckFrameAction(checkerPara, abnormalFrameNum, badFrameRatio);
1692 EXPECT_EQ(0, checker->streamConfig_.originalSessionId);
1693 }
1694
1695 /**
1696 * @tc.name : Test MonitorOnAllCallback API
1697 * @tc.type : FUNC
1698 * @tc.number: MonitorOnAllCallback_006
1699 */
1700 HWTEST(AudioStreamCheckerTest, MonitorOnAllCallback_006, TestSize.Level1)
1701 {
1702 AudioProcessConfig cfg;
1703 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1704 CheckerParam checkerParamTest;
1705 checkerParamTest.pid = 0;
1706 checkerParamTest.callbackId = 0;
1707 checkerParamTest.isMonitorNoDataFrame = false;
1708 checker->checkParaVector_.clear();
1709 checker->checkParaVector_.push_back(checkerParamTest);
1710
1711 checker->monitorSwitch_ = true;
1712 DataTransferStateChangeType type = DATA_TRANS_RESUME;
1713
1714 checker->MonitorOnAllCallback(type, false);
1715 int size = checker->checkParaVector_.size();
1716 EXPECT_EQ(1, size);
1717 }
1718
1719 /**
1720 * @tc.name : Test IsMonitorNoDataFrame API
1721 * @tc.type : FUNC
1722 * @tc.number: IsMonitorNoDataFrame_002
1723 */
1724 HWTEST(AudioStreamCheckerTest, IsMonitorNoDataFrame_002, TestSize.Level1)
1725 {
1726 AudioProcessConfig cfg;
1727 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1728 CheckerParam checkerParamTest;
1729 checkerParamTest.hasInitCheck = true;
1730 bool ret = checker->IsMonitorNoDataFrame(checkerParamTest);
1731 EXPECT_EQ(false, ret);
1732 }
1733
1734 /**
1735 * @tc.name : Test CheckStreamThread API
1736 * @tc.type : FUNC
1737 * @tc.number: CheckStreamThread_001
1738 */
1739 HWTEST(AudioStreamCheckerTest, CheckStreamThread_001, TestSize.Level1)
1740 {
1741 AudioProcessConfig cfg;
1742 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1743 checker->CheckStreamThread();
1744 EXPECT_EQ(false, checker->isKeepCheck_);
1745 }
1746
1747 /**
1748 * @tc.name : Test IsMonitorMuteFrame API
1749 * @tc.type : FUNC
1750 * @tc.number: IsMonitorMuteFrame_002
1751 */
1752 HWTEST(AudioStreamCheckerTest, IsMonitorMuteFrame_002, TestSize.Level1)
1753 {
1754 AudioProcessConfig cfg;
1755 std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
1756 CheckerParam checkerParamTest;
1757 checkerParamTest.hasInitCheck = true;
1758
1759 bool ret = checker->IsMonitorMuteFrame(checkerParamTest);
1760 EXPECT_EQ(false, ret);
1761 }
1762 }
1763 }