1 /*
2  * Copyright (C) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 #include <string>
18 #include "unittest_log.h"
19 #include <cstdlib>
20 #include <string>
21 #include <cmath>
22 #include <chrono>
23 #include <iostream>
24 #include <sstream>
25 #include "common/status.h"
26 #include "securec.h"
27 #define HST_LOG_TAG "Task"
28 #include "osal/task/task.h"
29 #include "osal/task/condition_variable.h"
30 #include "cpp_ext/memory_ext.h"
31 #include "common/log.h"
32 #include "osal/task/pipeline_threadpool.h"
33 
34 namespace {
35 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, LOG_DOMAIN_FOUNDATION, "TaskFuncUnitTest" };
36 }
37 
38 using namespace std;
39 using namespace testing::ext;
40 using namespace OHOS;
41 using namespace OHOS::Media;
42 
43 namespace OHOS {
44 namespace Media {
45 namespace MetaFuncUT {
46 class TaskInnerUnitTest : public testing::Test {
47 public:
48     static void SetUpTestCase(void);
49 
50     static void TearDownTestCase(void);
51 
52     void SetUp(void);
53 
54     void TearDown(void);
55 
56     ConditionVariable cv;
57     Mutex mutex_;
58     std::atomic<bool> isStop_{false};
59     std::string modifyMsg_ = "";
60 };
61 
SetUpTestCase(void)62 void TaskInnerUnitTest::SetUpTestCase(void) {}
63 
TearDownTestCase(void)64 void TaskInnerUnitTest::TearDownTestCase(void) {}
65 
SetUp(void)66 void TaskInnerUnitTest::SetUp(void)
67 {
68     std::cout << "[SetUp]: SetUp!!!, test: ";
69     const ::testing::TestInfo *testInfo_ = ::testing::UnitTest::GetInstance()->current_test_info();
70     std::string testName = testInfo_->name();
71     std::cout << testName << std::endl;
72 }
73 
TearDown(void)74 void TaskInnerUnitTest::TearDown(void)
75 {
76     PipeLineThreadPool::GetInstance().DestroyThread("");
77     std::cout << "[TearDown]: over!!!" << std::endl;
78 }
79 
80 /**
81  * @tc.name: TaskNotRunning
82  * @tc.desc: TaskNotRunning
83  * @tc.type: FUNC
84  */
HWTEST_F(TaskInnerUnitTest, TaskNotRunning, TestSize.Level1)85 HWTEST_F(TaskInnerUnitTest, TaskNotRunning, TestSize.Level1)
86 {
87     std::shared_ptr<Task> task1 = std::make_shared<Task>("workTask1");
88     bool rtv = task1->IsTaskRunning();
89     EXPECT_EQ(false, rtv);
90 }
91 
92 /**
93  * @tc.name: TaskRegisterJobNotRunning
94  * @tc.desc: TaskRegisterJobNotRunning
95  * @tc.type: FUNC
96  */
HWTEST_F(TaskInnerUnitTest, TaskRegisterJobNotRunning, TestSize.Level1)97 HWTEST_F(TaskInnerUnitTest, TaskRegisterJobNotRunning, TestSize.Level1)
98 {
99     std::shared_ptr<Task> task2 = std::make_shared<Task>("workTask2");
100     task2->RegisterJob([]() {
101         bool runningState =true;
102         int count = 0;
103         while (runningState) {
104             count++;
105             MEDIA_LOG_I("Task TaskRegisterJobNotRunning running at " PUBLIC_LOG_U32, count);
106             sleep(1);
107             if (count > 10) { //10 second
108                 runningState = false;
109             }
110         }
111         return 0;
112     });
113     bool rtv = task2->IsTaskRunning();
114     EXPECT_EQ(false, rtv);
115 }
116 
117 
118 /**
119  * @tc.name: TaskRegisterJobRun
120  * @tc.desc: TaskRegisterJobRun
121  * @tc.type: FUNC
122  */
HWTEST_F(TaskInnerUnitTest, TaskRegisterJobRun, TestSize.Level1)123 HWTEST_F(TaskInnerUnitTest, TaskRegisterJobRun, TestSize.Level1)
124 {
125     std::shared_ptr<Task> task3 = std::make_shared<Task>("workTask3");
126     task3->RegisterJob([]() {
127         bool runningState =true;
128         int count = 0;
129         while (runningState) {
130             count++;
131             MEDIA_LOG_I("Task TaskRegisterJobRun running at " PUBLIC_LOG_U32, count);
132             sleep(1);
133             if (count > 10) { //10 second
134                 runningState = false;
135             }
136         }
137         return 0;
138     });
139     task3->Start();
140     sleep(1);
141     bool rtv = task3->IsTaskRunning();
142     EXPECT_EQ(true, rtv);
143 }
144 
145 /**
146  * @tc.name: TaskRegisterJobPause
147  * @tc.desc: TaskRegisterJobPause
148  * @tc.type: FUNC
149  */
HWTEST_F(TaskInnerUnitTest, TaskRegisterJobPause, TestSize.Level1)150 HWTEST_F(TaskInnerUnitTest, TaskRegisterJobPause, TestSize.Level1)
151 {
152     std::shared_ptr<Task> task4 = std::make_shared<Task>("workTask4");
153     task4->RegisterJob([]() {
154         bool runningState =true;
155         int count = 0;
156         while (runningState) {
157             count++;
158             MEDIA_LOG_I("Task TaskRegisterJobPause running at " PUBLIC_LOG_U32, count);
159             sleep(1);
160             if (count > 10) { //10 second
161                 runningState = false;
162             }
163         }
164         return 0;
165     });
166     task4->Start();
167     task4->Pause();
168     sleep(1);
169     bool rtv = task4->IsTaskRunning();
170     EXPECT_EQ(false, rtv);
171     task4->Pause();
172     sleep(1);
173     rtv = task4->IsTaskRunning();
174     EXPECT_EQ(false, rtv);
175 }
176 
177 /**
178  * @tc.name: TaskJobPauseResume
179  * @tc.desc: TaskJobPauseResume
180  * @tc.type: FUNC
181  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseResume, TestSize.Level1)182 HWTEST_F(TaskInnerUnitTest, TaskJobPauseResume, TestSize.Level1)
183 {
184     std::shared_ptr<Task> task5 = std::make_shared<Task>("workTask5");
185     task5->RegisterJob([]() {
186         bool runningState =true;
187         int count = 0;
188         while (runningState) {
189             count++;
190             MEDIA_LOG_I("Task TaskJobPauseResume running at " PUBLIC_LOG_U32, count);
191             sleep(1);
192             if (count > 10) { //10 second
193                 runningState = false;
194             }
195         }
196         return 0;
197     });
198     task5->Start();
199     task5->Pause();
200     sleep(1);
201     bool rtv = task5->IsTaskRunning();
202     EXPECT_EQ(false, rtv);
203     task5->Start();
204     sleep(1);
205     rtv = task5->IsTaskRunning();
206     EXPECT_EQ(true, rtv);
207 }
208 
209 
210 /**
211  * @tc.name: TaskRegisterJobPauseAsync
212  * @tc.desc: TaskRegisterJobPauseAsync
213  * @tc.type: FUNC
214  */
HWTEST_F(TaskInnerUnitTest, TaskRegisterJobPauseAsync, TestSize.Level1)215 HWTEST_F(TaskInnerUnitTest, TaskRegisterJobPauseAsync, TestSize.Level1)
216 {
217     std::shared_ptr<Task> task6 = std::make_shared<Task>("workTask6");
218     task6->RegisterJob([]() {
219         bool runningState =true;
220         int count = 0;
221         while (runningState) {
222             count++;
223             MEDIA_LOG_I("Task TaskRegisterJobPauseAsync running at " PUBLIC_LOG_U32, count);
224             sleep(1);
225             if (count > 10) { //10 second
226                 runningState = false;
227             }
228         }
229         return 0;
230     });
231     task6->Start();
232     task6->PauseAsync();
233     sleep(1);
234     bool rtv = task6->IsTaskRunning();
235     EXPECT_EQ(false, rtv);
236     task6->PauseAsync();
237     sleep(1);
238     rtv = task6->IsTaskRunning();
239     EXPECT_EQ(false, rtv);
240 }
241 
242 
243 /**
244  * @tc.name: TaskRegisterJobStopAsync
245  * @tc.desc: TaskRegisterJobStopAsync
246  * @tc.type: FUNC
247  */
HWTEST_F(TaskInnerUnitTest, TaskRegisterJobStopAsync, TestSize.Level1)248 HWTEST_F(TaskInnerUnitTest, TaskRegisterJobStopAsync, TestSize.Level1)
249 {
250     std::shared_ptr<Task> task7 = std::make_shared<Task>("workTask7");
251     task7->RegisterJob([]() {
252         bool runningState =true;
253         int count = 0;
254         while (runningState) {
255             count++;
256             MEDIA_LOG_I("Task TaskRegisterJobStopAsync running at " PUBLIC_LOG_U32, count);
257             sleep(1);
258             if (count > 10) { //10 second
259                 runningState = false;
260             }
261         }
262         return 0;
263     });
264     task7->Start();
265     sleep(1);
266     task7->StopAsync();
267     sleep(1);
268     bool rtv = task7->IsTaskRunning();
269     EXPECT_EQ(false, rtv);
270 }
271 
272 /**
273  * @tc.name: TaskRegisterJobStop
274  * @tc.desc: TaskRegisterJobStop
275  * @tc.type: FUNC
276  */
HWTEST_F(TaskInnerUnitTest, TaskRegisterJobStop, TestSize.Level1)277 HWTEST_F(TaskInnerUnitTest, TaskRegisterJobStop, TestSize.Level1)
278 {
279     std::shared_ptr<Task> task8 = std::make_shared<Task>("workTask8");
280     task8->RegisterJob([]() {
281         bool runningState =true;
282         int count = 0;
283         while (runningState) {
284             count++;
285             MEDIA_LOG_I("Task TaskRegisterJobStop running at " PUBLIC_LOG_U32, count);
286             sleep(1);
287             if (count > 10) { //10 second
288                 runningState = false;
289             }
290         }
291         return 0;
292     });
293     task8->Start();
294     sleep(2);
295     task8->Stop();
296     sleep(1);
297     bool rtv = task8->IsTaskRunning();
298     EXPECT_EQ(false, rtv);
299 }
300 
301 /**
302  * @tc.name: TaskRegisterJobStopResume
303  * @tc.desc: TaskRegisterJobStopResume
304  * @tc.type: FUNC
305  */
HWTEST_F(TaskInnerUnitTest, TaskRegisterJobStopResume, TestSize.Level1)306 HWTEST_F(TaskInnerUnitTest, TaskRegisterJobStopResume, TestSize.Level1)
307 {
308     std::shared_ptr<Task> task9 = std::make_shared<Task>("workTask9");
309     task9->RegisterJob([]() {
310         bool runningState =true;
311         int count = 0;
312         while (runningState) {
313             count++;
314             MEDIA_LOG_I("Task TaskRegisterJobStopResume running at " PUBLIC_LOG_U32, count);
315             sleep(1);
316             if (count > 10) { //10 second
317                 runningState = false;
318             }
319         }
320         return 0;
321     });
322     task9->Start();
323     sleep(2);
324     task9->Stop();
325     sleep(1);
326     task9->Start();
327     sleep(1);
328     bool rtv = task9->IsTaskRunning();
329     EXPECT_EQ(true, rtv);
330 }
331 
332 /**
333  * @tc.name: TaskJobPauseStopResumeStart
334  * @tc.desc: TaskJobPauseStopResumeStart
335  * @tc.type: FUNC
336  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart, TestSize.Level1)337 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart, TestSize.Level1)
338 {
339     std::shared_ptr<Task> task10 = std::make_shared<Task>("workTask10");
340     task10->RegisterJob([this]() {
341         bool runningState =true;
342         int count = 0;
343         while (runningState) {
344             count++;
345             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
346             sleep(1);
347             if (count > 5) { //5 second
348                 this->modifyMsg_ = "middle";
349             }
350             if (count > 20) { //20 second
351                 runningState = false;
352             }
353         }
354         return 0;
355     });
356     task10->Start();
357     sleep(3);
358     task10->Pause();
359     sleep(2);
360     task10->Start();
361     sleep(2);
362     task10->Stop();
363     sleep(1);
364     EXPECT_EQ("middle", modifyMsg_);
365     task10->Start();
366     sleep(1);
367     bool rtv = task10->IsTaskRunning();
368     EXPECT_EQ(true, rtv);
369 }
370 
371 /**
372  * @tc.name: WaitFor_Succ
373  * @tc.desc: WaitFor_Succ
374  * @tc.type: FUNC
375  */
HWTEST_F(TaskInnerUnitTest, WaitFor_Succ, TestSize.Level1)376 HWTEST_F(TaskInnerUnitTest, WaitFor_Succ, TestSize.Level1)
377 {
378     std::shared_ptr<Task> task01 = std::make_shared<Task>("workTask01");
379     AutoLock lock(mutex_);
380     task01->RegisterJob([]() {
381         bool runningState =true;
382         int count = 0;
383         while (runningState) {
384             count++;
385             MEDIA_LOG_I("Task WaitFor_Succ running at " PUBLIC_LOG_U32, count);
386             sleep(1);
387             if (count > 10){ //10 second
388                 runningState = false;
389             }
390         }
391         return 0;
392     });
393     task01->Start();
394     int timeoutMs = 1000;
395     isStop_.store(true);
396     auto rtv = cv.WaitFor(lock, timeoutMs, [this] { return isStop_.load(); });
397     EXPECT_EQ(true, rtv);
398 }
399 
400 /**
401  * @tc.name: TaskJobPauseStopResumeStart03
402  * @tc.desc: TaskJobPauseStopResumeStart03
403  * @tc.type: FUNC
404  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart03, TestSize.Level1)405 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart03, TestSize.Level1)
406 {
407     std::shared_ptr<Task> task03 = std::make_shared<Task>("workTask03",
408      "", TaskType::GLOBAL, TaskPriority::NORMAL, true);
409     task03->RegisterJob([this]() {
410         bool runningState =true;
411         int count = 0;
412         while (runningState) {
413             count++;
414             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
415             sleep(1);
416             if (count > 5) { //5 second
417                 this->modifyMsg_ = "middle";
418             }
419             if (count > 20) { //20 second
420                 runningState = false;
421             }
422         }
423         return 0;
424     });
425     task03->Start();
426     sleep(3);
427     task03->Pause();
428     sleep(2);
429     task03->Start();
430     sleep(2);
431     task03->Stop();
432     sleep(1);
433     EXPECT_EQ("middle", modifyMsg_);
434     task03->Start();
435     sleep(1);
436     bool rtv = task03->IsTaskRunning();
437     EXPECT_EQ(true, rtv);
438     task03->Stop();
439 }
440 
441 /**
442  * @tc.name: TaskJobPauseStopResumeStart04
443  * @tc.desc: TaskJobPauseStopResumeStart04
444  * @tc.type: FUNC
445  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart04, TestSize.Level1)446 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart04, TestSize.Level1)
447 {
448     std::shared_ptr<Task> task04 = std::make_shared<Task>("workTask04",
449      "", TaskType::VIDEO, TaskPriority::NORMAL, true);
450     task04->RegisterJob([this]() {
451         bool runningState =true;
452         int count = 0;
453         while (runningState) {
454             count++;
455             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
456             sleep(1);
457             if (count > 5) { //5 second
458                 this->modifyMsg_ = "middle";
459             }
460             if (count > 20) { //20 second
461                 runningState = false;
462             }
463         }
464         return 0;
465     });
466     task04->Start();
467     sleep(3);
468     task04->Pause();
469     sleep(2);
470     task04->Start();
471     sleep(2);
472     task04->Stop();
473     sleep(1);
474     EXPECT_EQ("middle", modifyMsg_);
475     task04->Start();
476     sleep(1);
477     bool rtv = task04->IsTaskRunning();
478     EXPECT_EQ(true, rtv);
479     task04->Stop();
480 }
481 
482 /**
483  * @tc.name: TaskJobPauseStopResumeStart05
484  * @tc.desc: TaskJobPauseStopResumeStart05
485  * @tc.type: FUNC
486  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart05, TestSize.Level1)487 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart05, TestSize.Level1)
488 {
489     std::shared_ptr<Task> task05 = std::make_shared<Task>("workTask05",
490      "", TaskType::AUDIO, TaskPriority::NORMAL, true);
491     task05->RegisterJob([this]() {
492         bool runningState =true;
493         int count = 0;
494         while (runningState) {
495             count++;
496             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
497             sleep(1);
498             if (count > 5) { //5 second
499                 this->modifyMsg_ = "middle";
500             }
501             if (count > 20) { //20 second
502                 runningState = false;
503             }
504         }
505         return 0;
506     });
507     task05->Start();
508     sleep(3);
509     task05->Pause();
510     sleep(2);
511     task05->Start();
512     sleep(2);
513     task05->Stop();
514     sleep(1);
515     EXPECT_EQ("middle", modifyMsg_);
516     task05->Start();
517     sleep(1);
518     bool rtv = task05->IsTaskRunning();
519     EXPECT_EQ(true, rtv);
520     task05->Stop();
521 }
522 
523 /**
524  * @tc.name: TaskJobPauseStopResumeStart06
525  * @tc.desc: TaskJobPauseStopResumeStart06
526  * @tc.type: FUNC
527  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart06, TestSize.Level1)528 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart06, TestSize.Level1)
529 {
530     std::shared_ptr<Task> task06 = std::make_shared<Task>("workTask06",
531      "", TaskType::SUBTITLE, TaskPriority::NORMAL, true);
532     task06->RegisterJob([this]() {
533         bool runningState =true;
534         int count = 0;
535         while (runningState) {
536             count++;
537             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
538             sleep(1);
539             if (count > 5) { //5 second
540                 this->modifyMsg_ = "middle";
541             }
542             if (count > 20) { //20 second
543                 runningState = false;
544             }
545         }
546         return 0;
547     });
548     task06->Start();
549     sleep(3);
550     task06->Pause();
551     sleep(2);
552     task06->Start();
553     sleep(2);
554     task06->Stop();
555     sleep(1);
556     EXPECT_EQ("middle", modifyMsg_);
557     task06->Start();
558     sleep(1);
559     bool rtv = task06->IsTaskRunning();
560     EXPECT_EQ(true, rtv);
561     task06->Stop();
562 }
563 
564 /**
565  * @tc.name: TaskJobPauseStopResumeStart07
566  * @tc.desc: TaskJobPauseStopResumeStart07
567  * @tc.type: FUNC
568  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart07, TestSize.Level1)569 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart07, TestSize.Level1)
570 {
571     std::shared_ptr<Task> task07 = std::make_shared<Task>("workTask07",
572      "", TaskType::GLOBAL, TaskPriority::LOW, true);
573     task07->RegisterJob([this]() {
574         bool runningState =true;
575         int count = 0;
576         while (runningState) {
577             count++;
578             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
579             sleep(1);
580             if (count > 5) { //5 second
581                 this->modifyMsg_ = "middle";
582             }
583             if (count > 20) { //20 second
584                 runningState = false;
585             }
586         }
587         return 0;
588     });
589     task07->Start();
590     sleep(3);
591     task07->Pause();
592     sleep(2);
593     task07->Start();
594     sleep(2);
595     task07->Stop();
596     sleep(1);
597     EXPECT_EQ("middle", modifyMsg_);
598     task07->Start();
599     sleep(1);
600     bool rtv = task07->IsTaskRunning();
601     EXPECT_EQ(true, rtv);
602     task07->Stop();
603 }
604 
605 /**
606  * @tc.name: TaskJobPauseStopResumeStart08
607  * @tc.desc: TaskJobPauseStopResumeStart08
608  * @tc.type: FUNC
609  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart08, TestSize.Level1)610 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart08, TestSize.Level1)
611 {
612     std::shared_ptr<Task> task08 = std::make_shared<Task>("workTask08",
613      "", TaskType::VIDEO, TaskPriority::LOW, true);
614     task08->RegisterJob([this]() {
615         bool runningState =true;
616         int count = 0;
617         while (runningState) {
618             count++;
619             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
620             sleep(1);
621             if (count > 5) { //5 second
622                 this->modifyMsg_ = "middle";
623             }
624             if (count > 20) { //20 second
625                 runningState = false;
626             }
627         }
628         return 0;
629     });
630     task08->Start();
631     sleep(3);
632     task08->Pause();
633     sleep(2);
634     task08->Start();
635     sleep(2);
636     task08->Stop();
637     sleep(1);
638     EXPECT_EQ("middle", modifyMsg_);
639     task08->Start();
640     sleep(1);
641     bool rtv = task08->IsTaskRunning();
642     EXPECT_EQ(true, rtv);
643     task08->Stop();
644 }
645 
646 /**
647  * @tc.name: TaskJobPauseStopResumeStart09
648  * @tc.desc: TaskJobPauseStopResumeStart09
649  * @tc.type: FUNC
650  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart09, TestSize.Level1)651 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart09, TestSize.Level1)
652 {
653     std::shared_ptr<Task> task09 = std::make_shared<Task>("workTask09",
654      "", TaskType::AUDIO, TaskPriority::LOW, true);
655     task09->RegisterJob([this]() {
656         bool runningState =true;
657         int count = 0;
658         while (runningState) {
659             count++;
660             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
661             sleep(1);
662             if (count > 5) { //5 second
663                 this->modifyMsg_ = "middle";
664             }
665             if (count > 20) { //20 second
666                 runningState = false;
667             }
668         }
669         return 0;
670     });
671     task09->Start();
672     sleep(3);
673     task09->Pause();
674     sleep(2);
675     task09->Start();
676     sleep(2);
677     task09->Stop();
678     sleep(1);
679     EXPECT_EQ("middle", modifyMsg_);
680     task09->Start();
681     sleep(1);
682     bool rtv = task09->IsTaskRunning();
683     EXPECT_EQ(true, rtv);
684     task09->Stop();
685 }
686 
687 /**
688  * @tc.name: TaskJobPauseStopResumeStart20
689  * @tc.desc: TaskJobPauseStopResumeStart20
690  * @tc.type: FUNC
691  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart20, TestSize.Level1)692 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart20, TestSize.Level1)
693 {
694     std::shared_ptr<Task> task20 = std::make_shared<Task>("workTask20",
695      "", TaskType::SUBTITLE, TaskPriority::LOW, true);
696     task20->RegisterJob([this]() {
697         bool runningState =true;
698         int count = 0;
699         while (runningState) {
700             count++;
701             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
702             sleep(1);
703             if (count > 5) { //5 second
704                 this->modifyMsg_ = "middle";
705             }
706             if (count > 20) { //20 second
707                 runningState = false;
708             }
709         }
710         return 0;
711     });
712     task20->Start();
713     sleep(3);
714     task20->Pause();
715     sleep(2);
716     task20->Start();
717     sleep(2);
718     task20->Stop();
719     sleep(1);
720     EXPECT_EQ("middle", modifyMsg_);
721     task20->Start();
722     sleep(1);
723     bool rtv = task20->IsTaskRunning();
724     EXPECT_EQ(true, rtv);
725     task20->Stop();
726 }
727 
728 /**
729  * @tc.name: TaskJobPauseStopResumeStart21
730  * @tc.desc: TaskJobPauseStopResumeStart21
731  * @tc.type: FUNC
732  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart21, TestSize.Level1)733 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart21, TestSize.Level1)
734 {
735     std::shared_ptr<Task> task21 = std::make_shared<Task>("workTask21",
736      "", TaskType::SINGLETON, TaskPriority::LOW, true);
737     task21->RegisterJob([this]() {
738         bool runningState =true;
739         int count = 0;
740         while (runningState) {
741             count++;
742             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
743             sleep(1);
744             if (count > 5) { //5 second
745                 this->modifyMsg_ = "middle";
746             }
747             if (count > 20) { //20 second
748                 runningState = false;
749             }
750         }
751         return 0;
752     });
753     task21->Start();
754     sleep(3);
755     task21->Pause();
756     sleep(2);
757     task21->Start();
758     sleep(2);
759     task21->Stop();
760     sleep(1);
761     EXPECT_EQ("middle", modifyMsg_);
762     task21->Start();
763     sleep(1);
764     bool rtv = task21->IsTaskRunning();
765     EXPECT_EQ(true, rtv);
766 }
767 
768 /**
769  * @tc.name: TaskJobPauseStopResumeStart22
770  * @tc.desc: TaskJobPauseStopResumeStart22
771  * @tc.type: FUNC
772  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart22, TestSize.Level1)773 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart22, TestSize.Level1)
774 {
775     std::shared_ptr<Task> task22 = std::make_shared<Task>("workTask22",
776      "", TaskType::GLOBAL, TaskPriority::MIDDLE, true);
777     task22->RegisterJob([this]() {
778         bool runningState =true;
779         int count = 0;
780         while (runningState) {
781             count++;
782             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
783             sleep(1);
784             if (count > 5) { //5 second
785                 this->modifyMsg_ = "middle";
786             }
787             if (count > 20) { //20 second
788                 runningState = false;
789             }
790         }
791         return 0;
792     });
793     task22->Start();
794     sleep(3);
795     task22->Pause();
796     sleep(2);
797     task22->Start();
798     sleep(2);
799     task22->Stop();
800     sleep(1);
801     EXPECT_EQ("middle", modifyMsg_);
802     task22->Start();
803     sleep(1);
804     bool rtv = task22->IsTaskRunning();
805     EXPECT_EQ(true, rtv);
806     task22->Stop();
807 }
808 
809 /**
810  * @tc.name: TaskJobPauseStopResumeStart23
811  * @tc.desc: TaskJobPauseStopResumeStart23
812  * @tc.type: FUNC
813  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart23, TestSize.Level1)814 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart23, TestSize.Level1)
815 {
816     std::shared_ptr<Task> task23 = std::make_shared<Task>("workTask23",
817      "", TaskType::VIDEO, TaskPriority::MIDDLE, true);
818     task23->RegisterJob([this]() {
819         bool runningState =true;
820         int count = 0;
821         while (runningState) {
822             count++;
823             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
824             sleep(1);
825             if (count > 5) { //5 second
826                 this->modifyMsg_ = "middle";
827             }
828             if (count > 20) { //20 second
829                 runningState = false;
830             }
831         }
832         return 0;
833     });
834     task23->Start();
835     sleep(3);
836     task23->Pause();
837     sleep(2);
838     task23->Start();
839     sleep(2);
840     task23->Stop();
841     sleep(1);
842     EXPECT_EQ("middle", modifyMsg_);
843     task23->Start();
844     sleep(1);
845     bool rtv = task23->IsTaskRunning();
846     EXPECT_EQ(true, rtv);
847     task23->Stop();
848 }
849 
850 /**
851  * @tc.name: TaskJobPauseStopResumeStart24
852  * @tc.desc: TaskJobPauseStopResumeStart24
853  * @tc.type: FUNC
854  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart24, TestSize.Level1)855 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart24, TestSize.Level1)
856 {
857     std::shared_ptr<Task> task24 = std::make_shared<Task>("workTask24",
858      "", TaskType::AUDIO, TaskPriority::MIDDLE, true);
859     task24->RegisterJob([this]() {
860         bool runningState =true;
861         int count = 0;
862         while (runningState) {
863             count++;
864             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
865             sleep(1);
866             if (count > 5) { //5 second
867                 this->modifyMsg_ = "middle";
868             }
869             if (count > 20) { //20 second
870                 runningState = false;
871             }
872         }
873         return 0;
874     });
875     task24->Start();
876     sleep(3);
877     task24->Pause();
878     sleep(2);
879     task24->Start();
880     sleep(2);
881     task24->Stop();
882     sleep(1);
883     EXPECT_EQ("middle", modifyMsg_);
884     task24->Start();
885     sleep(1);
886     bool rtv = task24->IsTaskRunning();
887     EXPECT_EQ(true, rtv);
888     task24->Stop();
889 }
890 
891 /**
892  * @tc.name: TaskJobPauseStopResumeStart25
893  * @tc.desc: TaskJobPauseStopResumeStart25
894  * @tc.type: FUNC
895  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart25, TestSize.Level1)896 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart25, TestSize.Level1)
897 {
898     std::shared_ptr<Task> task25 = std::make_shared<Task>("workTask25",
899      "", TaskType::SUBTITLE, TaskPriority::MIDDLE, true);
900     task25->RegisterJob([this]() {
901         bool runningState =true;
902         int count = 0;
903         while (runningState) {
904             count++;
905             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
906             sleep(1);
907             if (count > 5) { //5 second
908                 this->modifyMsg_ = "middle";
909             }
910             if (count > 20) { //20 second
911                 runningState = false;
912             }
913         }
914         return 0;
915     });
916     task25->Start();
917     sleep(3);
918     task25->Pause();
919     sleep(2);
920     task25->Start();
921     sleep(2);
922     task25->Stop();
923     sleep(1);
924     EXPECT_EQ("middle", modifyMsg_);
925     task25->Start();
926     sleep(1);
927     bool rtv = task25->IsTaskRunning();
928     EXPECT_EQ(true, rtv);
929     task25->Stop();
930 }
931 
932 /**
933  * @tc.name: TaskJobPauseStopResumeStart26
934  * @tc.desc: TaskJobPauseStopResumeStart26
935  * @tc.type: FUNC
936  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart26, TestSize.Level1)937 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart26, TestSize.Level1)
938 {
939     std::shared_ptr<Task> task26 = std::make_shared<Task>("workTask26",
940      "", TaskType::SINGLETON, TaskPriority::MIDDLE, true);
941     task26->RegisterJob([this]() {
942         bool runningState =true;
943         int count = 0;
944         while (runningState) {
945             count++;
946             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
947             sleep(1);
948             if (count > 5) { //5 second
949                 this->modifyMsg_ = "middle";
950             }
951             if (count > 20) { //20 second
952                 runningState = false;
953             }
954         }
955         return 0;
956     });
957     task26->Start();
958     sleep(3);
959     task26->Pause();
960     sleep(2);
961     task26->Start();
962     sleep(2);
963     task26->Stop();
964     sleep(1);
965     EXPECT_EQ("middle", modifyMsg_);
966     task26->Start();
967     sleep(1);
968     bool rtv = task26->IsTaskRunning();
969     EXPECT_EQ(true, rtv);
970 }
971 
972 /**
973  * @tc.name: TaskJobPauseStopResumeStart27
974  * @tc.desc: TaskJobPauseStopResumeStart27
975  * @tc.type: FUNC
976  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart27, TestSize.Level1)977 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart27, TestSize.Level1)
978 {
979     std::shared_ptr<Task> task27 = std::make_shared<Task>("workTask27",
980      "", TaskType::GLOBAL, TaskPriority::HIGH, true);
981     task27->RegisterJob([this]() {
982         bool runningState =true;
983         int count = 0;
984         while (runningState) {
985             count++;
986             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
987             sleep(1);
988             if (count > 5) { //5 second
989                 this->modifyMsg_ = "middle";
990             }
991             if (count > 20) { //20 second
992                 runningState = false;
993             }
994         }
995         return 0;
996     });
997     task27->Start();
998     sleep(3);
999     task27->Pause();
1000     sleep(2);
1001     task27->Start();
1002     sleep(2);
1003     task27->Stop();
1004     sleep(1);
1005     EXPECT_EQ("middle", modifyMsg_);
1006     task27->Start();
1007     sleep(1);
1008     bool rtv = task27->IsTaskRunning();
1009     EXPECT_EQ(true, rtv);
1010     task27->Stop();
1011 }
1012 
1013 /**
1014  * @tc.name: TaskJobPauseStopResumeStart28
1015  * @tc.desc: TaskJobPauseStopResumeStart28
1016  * @tc.type: FUNC
1017  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart28, TestSize.Level1)1018 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart28, TestSize.Level1)
1019 {
1020     std::shared_ptr<Task> task28 = std::make_shared<Task>("workTask28",
1021      "", TaskType::VIDEO, TaskPriority::HIGH, true);
1022     task28->RegisterJob([this]() {
1023         bool runningState =true;
1024         int count = 0;
1025         while (runningState) {
1026             count++;
1027             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
1028             sleep(1);
1029             if (count > 5) { //5 second
1030                 this->modifyMsg_ = "middle";
1031             }
1032             if (count > 20) { //20 second
1033                 runningState = false;
1034             }
1035         }
1036         return 0;
1037     });
1038     task28->Start();
1039     sleep(3);
1040     task28->Pause();
1041     sleep(2);
1042     task28->Start();
1043     sleep(2);
1044     task28->Stop();
1045     sleep(1);
1046     EXPECT_EQ("middle", modifyMsg_);
1047     task28->Start();
1048     sleep(1);
1049     bool rtv = task28->IsTaskRunning();
1050     EXPECT_EQ(true, rtv);
1051     task28->Stop();
1052 }
1053 
1054 /**
1055  * @tc.name: TaskJobPauseStopResumeStart29
1056  * @tc.desc: TaskJobPauseStopResumeStart29
1057  * @tc.type: FUNC
1058  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart29, TestSize.Level1)1059 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart29, TestSize.Level1)
1060 {
1061     std::shared_ptr<Task> task29 = std::make_shared<Task>("workTask29",
1062      "", TaskType::AUDIO, TaskPriority::HIGH, true);
1063     task29->RegisterJob([this]() {
1064         bool runningState =true;
1065         int count = 0;
1066         while (runningState) {
1067             count++;
1068             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
1069             sleep(1);
1070             if (count > 5) { //5 second
1071                 this->modifyMsg_ = "middle";
1072             }
1073             if (count > 20) { //20 second
1074                 runningState = false;
1075             }
1076         }
1077         return 0;
1078     });
1079     task29->Start();
1080     sleep(3);
1081     task29->Pause();
1082     sleep(2);
1083     task29->Start();
1084     sleep(2);
1085     task29->Stop();
1086     sleep(1);
1087     EXPECT_EQ("middle", modifyMsg_);
1088     task29->Start();
1089     sleep(1);
1090     bool rtv = task29->IsTaskRunning();
1091     EXPECT_EQ(true, rtv);
1092     task29->Stop();
1093 }
1094 
1095 /**
1096  * @tc.name: TaskJobPauseStopResumeStart30
1097  * @tc.desc: TaskJobPauseStopResumeStart30
1098  * @tc.type: FUNC
1099  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart30, TestSize.Level1)1100 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart30, TestSize.Level1)
1101 {
1102     std::shared_ptr<Task> task30 = std::make_shared<Task>("workTask30",
1103      "", TaskType::SUBTITLE, TaskPriority::HIGH, true);
1104     task30->RegisterJob([this]() {
1105         bool runningState =true;
1106         int count = 0;
1107         while (runningState) {
1108             count++;
1109             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
1110             sleep(1);
1111             if (count > 5) { //5 second
1112                 this->modifyMsg_ = "middle";
1113             }
1114             if (count > 20) { //20 second
1115                 runningState = false;
1116             }
1117         }
1118         return 0;
1119     });
1120     task30->Start();
1121     sleep(3);
1122     task30->Pause();
1123     sleep(2);
1124     task30->Start();
1125     sleep(2);
1126     task30->Stop();
1127     sleep(1);
1128     EXPECT_EQ("middle", modifyMsg_);
1129     task30->Start();
1130     sleep(1);
1131     bool rtv = task30->IsTaskRunning();
1132     EXPECT_EQ(true, rtv);
1133     task30->Stop();
1134 }
1135 
1136 /**
1137  * @tc.name: TaskJobPauseStopResumeStart31
1138  * @tc.desc: TaskJobPauseStopResumeStart31
1139  * @tc.type: FUNC
1140  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart31, TestSize.Level1)1141 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart31, TestSize.Level1)
1142 {
1143     std::shared_ptr<Task> task31 = std::make_shared<Task>("workTask31",
1144      "", TaskType::SINGLETON, TaskPriority::HIGH, true);
1145     task31->RegisterJob([this]() {
1146         bool runningState =true;
1147         int count = 0;
1148         while (runningState) {
1149             count++;
1150             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
1151             sleep(1);
1152             if (count > 5) { //5 second
1153                 this->modifyMsg_ = "middle";
1154             }
1155             if (count > 20) { //20 second
1156                 runningState = false;
1157             }
1158         }
1159         return 0;
1160     });
1161     task31->Start();
1162     sleep(3);
1163     task31->Pause();
1164     sleep(2);
1165     task31->Start();
1166     sleep(2);
1167     task31->Stop();
1168     sleep(1);
1169     EXPECT_EQ("middle", modifyMsg_);
1170     task31->Start();
1171     sleep(1);
1172     bool rtv = task31->IsTaskRunning();
1173     EXPECT_EQ(true, rtv);
1174 }
1175 
1176 /**
1177  * @tc.name: TaskJobPauseStopResumeStart32
1178  * @tc.desc: TaskJobPauseStopResumeStart32
1179  * @tc.type: FUNC
1180  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart32, TestSize.Level1)1181 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart32, TestSize.Level1)
1182 {
1183     std::shared_ptr<Task> task32 = std::make_shared<Task>("workTask32",
1184      "", TaskType::GLOBAL, TaskPriority::HIGHEST, true);
1185     task32->RegisterJob([this]() {
1186         bool runningState =true;
1187         int count = 0;
1188         while (runningState) {
1189             count++;
1190             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
1191             sleep(1);
1192             if (count > 5) { //5 second
1193                 this->modifyMsg_ = "middle";
1194             }
1195             if (count > 20) { //20 second
1196                 runningState = false;
1197             }
1198         }
1199         return 0;
1200     });
1201     task32->Start();
1202     sleep(3);
1203     task32->Pause();
1204     sleep(2);
1205     task32->Start();
1206     sleep(2);
1207     task32->Stop();
1208     sleep(1);
1209     EXPECT_EQ("middle", modifyMsg_);
1210     task32->Start();
1211     sleep(1);
1212     bool rtv = task32->IsTaskRunning();
1213     EXPECT_EQ(true, rtv);
1214     task32->Stop();
1215 }
1216 
1217 /**
1218  * @tc.name: TaskJobPauseStopResumeStart33
1219  * @tc.desc: TaskJobPauseStopResumeStart33
1220  * @tc.type: FUNC
1221  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart33, TestSize.Level1)1222 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart33, TestSize.Level1)
1223 {
1224     std::shared_ptr<Task> task33 = std::make_shared<Task>("workTask33",
1225      "", TaskType::VIDEO, TaskPriority::HIGHEST, true);
1226     task33->RegisterJob([this]() {
1227         bool runningState =true;
1228         int count = 0;
1229         while (runningState) {
1230             count++;
1231             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
1232             sleep(1);
1233             if (count > 5) { //5 second
1234                 this->modifyMsg_ = "middle";
1235             }
1236             if (count > 20) { //20 second
1237                 runningState = false;
1238             }
1239         }
1240         return 0;
1241     });
1242     task33->Start();
1243     sleep(3);
1244     task33->Pause();
1245     sleep(2);
1246     task33->Start();
1247     sleep(2);
1248     task33->Stop();
1249     sleep(1);
1250     EXPECT_EQ("middle", modifyMsg_);
1251     task33->Start();
1252     sleep(1);
1253     bool rtv = task33->IsTaskRunning();
1254     EXPECT_EQ(true, rtv);
1255     task33->Stop();
1256 }
1257 
1258 /**
1259  * @tc.name: TaskJobPauseStopResumeStart34
1260  * @tc.desc: TaskJobPauseStopResumeStart34
1261  * @tc.type: FUNC
1262  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart34, TestSize.Level1)1263 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart34, TestSize.Level1)
1264 {
1265     std::shared_ptr<Task> task34 = std::make_shared<Task>("workTask34",
1266      "", TaskType::AUDIO, TaskPriority::HIGHEST, true);
1267     task34->RegisterJob([this]() {
1268         bool runningState =true;
1269         int count = 0;
1270         while (runningState) {
1271             count++;
1272             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
1273             sleep(1);
1274             if (count > 5) { //5 second
1275                 this->modifyMsg_ = "middle";
1276             }
1277             if (count > 20) { //20 second
1278                 runningState = false;
1279             }
1280         }
1281         return 0;
1282     });
1283     task34->Start();
1284     sleep(3);
1285     task34->Pause();
1286     sleep(2);
1287     task34->Start();
1288     sleep(2);
1289     task34->Stop();
1290     sleep(1);
1291     EXPECT_EQ("middle", modifyMsg_);
1292     task34->Start();
1293     sleep(1);
1294     bool rtv = task34->IsTaskRunning();
1295     EXPECT_EQ(true, rtv);
1296     task34->Stop();
1297 }
1298 
1299 /**
1300  * @tc.name: TaskJobPauseStopResumeStart35
1301  * @tc.desc: TaskJobPauseStopResumeStart35
1302  * @tc.type: FUNC
1303  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart35, TestSize.Level1)1304 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart35, TestSize.Level1)
1305 {
1306     std::shared_ptr<Task> task35 = std::make_shared<Task>("workTask35",
1307      "", TaskType::SUBTITLE, TaskPriority::HIGHEST, true);
1308     task35->RegisterJob([this]() {
1309         bool runningState =true;
1310         int count = 0;
1311         while (runningState) {
1312             count++;
1313             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
1314             sleep(1);
1315             if (count > 5) { //5 second
1316                 this->modifyMsg_ = "middle";
1317             }
1318             if (count > 20) { //20 second
1319                 runningState = false;
1320             }
1321         }
1322         return 0;
1323     });
1324     task35->Start();
1325     sleep(3);
1326     task35->Pause();
1327     sleep(2);
1328     task35->Start();
1329     sleep(2);
1330     task35->Stop();
1331     sleep(1);
1332     EXPECT_EQ("middle", modifyMsg_);
1333     task35->Start();
1334     sleep(1);
1335     bool rtv = task35->IsTaskRunning();
1336     EXPECT_EQ(true, rtv);
1337     task35->Stop();
1338 }
1339 
1340 /**
1341  * @tc.name: TaskJobPauseStopResumeStart36
1342  * @tc.desc: TaskJobPauseStopResumeStart36
1343  * @tc.type: FUNC
1344  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart36, TestSize.Level1)1345 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart36, TestSize.Level1)
1346 {
1347     std::shared_ptr<Task> task36 = std::make_shared<Task>("workTask36",
1348      "", TaskType::SINGLETON, TaskPriority::HIGHEST, true);
1349     task36->RegisterJob([this]() {
1350         bool runningState =true;
1351         int count = 0;
1352         while (runningState) {
1353             count++;
1354             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
1355             sleep(1);
1356             if (count > 5) { //5 second
1357                 this->modifyMsg_ = "middle";
1358             }
1359             if (count > 20) { //20 second
1360                 runningState = false;
1361             }
1362         }
1363         return 0;
1364     });
1365     task36->Start();
1366     sleep(3);
1367     task36->Pause();
1368     sleep(2);
1369     task36->Start();
1370     sleep(2);
1371     task36->Stop();
1372     sleep(1);
1373     EXPECT_EQ("middle", modifyMsg_);
1374     task36->Start();
1375     sleep(1);
1376     bool rtv = task36->IsTaskRunning();
1377     EXPECT_EQ(true, rtv);
1378 }
1379 
1380 /**
1381  * @tc.name: TaskJobPauseStopResumeStart37
1382  * @tc.desc: TaskJobPauseStopResumeStart37
1383  * @tc.type: FUNC
1384  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart37, TestSize.Level1)1385 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart37, TestSize.Level1)
1386 {
1387     std::shared_ptr<Task> task37 = std::make_shared<Task>("workTask37",
1388      "", TaskType::SINGLETON, TaskPriority::NORMAL, false);
1389     task37->RegisterJob([this]() {
1390         bool runningState =true;
1391         int count = 0;
1392         while (runningState) {
1393             count++;
1394             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
1395             sleep(1);
1396             if (count > 5) { //5 second
1397                 this->modifyMsg_ = "middle";
1398             }
1399             if (count > 20) { //20 second
1400                 runningState = false;
1401             }
1402         }
1403         return 0;
1404     });
1405     task37->Start();
1406     sleep(3);
1407     task37->Pause();
1408     sleep(2);
1409     task37->Start();
1410     sleep(2);
1411     task37->Stop();
1412     sleep(1);
1413     EXPECT_EQ("", modifyMsg_);
1414     task37->Start();
1415     sleep(1);
1416     bool rtv = task37->IsTaskRunning();
1417     EXPECT_EQ(true, rtv);
1418 }
1419 
1420 /**
1421  * @tc.name: TaskJobPauseStopResumeStart38
1422  * @tc.desc: TaskJobPauseStopResumeStart38
1423  * @tc.type: FUNC
1424  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart38, TestSize.Level1)1425 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart38, TestSize.Level1)
1426 {
1427     std::shared_ptr<Task> task38 = std::make_shared<Task>("workTask38",
1428      "", TaskType::GLOBAL, TaskPriority::NORMAL, false);
1429     task38->RegisterJob([this]() {
1430         bool runningState =true;
1431         int count = 0;
1432         while (runningState) {
1433             count++;
1434             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
1435             sleep(1);
1436             if (count > 5) { //5 second
1437                 this->modifyMsg_ = "middle";
1438             }
1439             if (count > 20) { //20 second
1440                 runningState = false;
1441             }
1442         }
1443         return 0;
1444     });
1445     task38->Start();
1446     sleep(3);
1447     task38->Pause();
1448     sleep(2);
1449     task38->Start();
1450     sleep(2);
1451     task38->Stop();
1452     sleep(1);
1453     EXPECT_EQ("", modifyMsg_);
1454     task38->Start();
1455     sleep(1);
1456     bool rtv = task38->IsTaskRunning();
1457     EXPECT_EQ(true, rtv);
1458     task38->Stop();
1459 }
1460 
1461 /**
1462  * @tc.name: TaskJobPauseStopResumeStart39
1463  * @tc.desc: TaskJobPauseStopResumeStart39
1464  * @tc.type: FUNC
1465  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart39, TestSize.Level1)1466 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart39, TestSize.Level1)
1467 {
1468     std::shared_ptr<Task> task39 = std::make_shared<Task>("workTask39",
1469      "", TaskType::VIDEO, TaskPriority::NORMAL, false);
1470     task39->RegisterJob([this]() {
1471         bool runningState =true;
1472         int count = 0;
1473         while (runningState) {
1474             count++;
1475             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
1476             sleep(1);
1477             if (count > 5) { //5 second
1478                 this->modifyMsg_ = "middle";
1479             }
1480             if (count > 20) { //20 second
1481                 runningState = false;
1482             }
1483         }
1484         return 0;
1485     });
1486     task39->Start();
1487     sleep(3);
1488     task39->Pause();
1489     sleep(2);
1490     task39->Start();
1491     sleep(2);
1492     task39->Stop();
1493     sleep(1);
1494     EXPECT_EQ("", modifyMsg_);
1495     task39->Start();
1496     sleep(1);
1497     bool rtv = task39->IsTaskRunning();
1498     EXPECT_EQ(true, rtv);
1499     task39->Stop();
1500 }
1501 
1502 /**
1503  * @tc.name: TaskJobPauseStopResumeStart40
1504  * @tc.desc: TaskJobPauseStopResumeStart40
1505  * @tc.type: FUNC
1506  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart40, TestSize.Level1)1507 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart40, TestSize.Level1)
1508 {
1509     std::shared_ptr<Task> task40 = std::make_shared<Task>("workTask40",
1510      "", TaskType::AUDIO, TaskPriority::NORMAL, false);
1511     task40->RegisterJob([this]() {
1512         bool runningState =true;
1513         int count = 0;
1514         while (runningState) {
1515             count++;
1516             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
1517             sleep(1);
1518             if (count > 5) { //5 second
1519                 this->modifyMsg_ = "middle";
1520             }
1521             if (count > 20) { //20 second
1522                 runningState = false;
1523             }
1524         }
1525         return 0;
1526     });
1527     task40->Start();
1528     sleep(3);
1529     task40->Pause();
1530     sleep(2);
1531     task40->Start();
1532     sleep(2);
1533     task40->Stop();
1534     sleep(1);
1535     EXPECT_EQ("", modifyMsg_);
1536     task40->Start();
1537     sleep(1);
1538     bool rtv = task40->IsTaskRunning();
1539     EXPECT_EQ(true, rtv);
1540     task40->Stop();
1541 }
1542 
1543 /**
1544  * @tc.name: TaskJobPauseStopResumeStart41
1545  * @tc.desc: TaskJobPauseStopResumeStart41
1546  * @tc.type: FUNC
1547  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart41, TestSize.Level1)1548 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart41, TestSize.Level1)
1549 {
1550     std::shared_ptr<Task> task41 = std::make_shared<Task>("workTask41",
1551      "", TaskType::SUBTITLE, TaskPriority::NORMAL, false);
1552     task41->RegisterJob([this]() {
1553         bool runningState =true;
1554         int count = 0;
1555         while (runningState) {
1556             count++;
1557             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
1558             sleep(1);
1559             if (count > 5) { //5 second
1560                 this->modifyMsg_ = "middle";
1561             }
1562             if (count > 20) { //20 second
1563                 runningState = false;
1564             }
1565         }
1566         return 0;
1567     });
1568     task41->Start();
1569     sleep(3);
1570     task41->Pause();
1571     sleep(2);
1572     task41->Start();
1573     sleep(2);
1574     task41->Stop();
1575     sleep(1);
1576     EXPECT_EQ("", modifyMsg_);
1577     task41->Start();
1578     sleep(1);
1579     bool rtv = task41->IsTaskRunning();
1580     EXPECT_EQ(true, rtv);
1581     task41->Stop();
1582 }
1583 
1584 /**
1585  * @tc.name: TaskJobPauseStopResumeStart42
1586  * @tc.desc: TaskJobPauseStopResumeStart42
1587  * @tc.type: FUNC
1588  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart42, TestSize.Level1)1589 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart42, TestSize.Level1)
1590 {
1591     std::shared_ptr<Task> task42 = std::make_shared<Task>("workTask42",
1592      "", TaskType::GLOBAL, TaskPriority::LOW, false);
1593     task42->RegisterJob([this]() {
1594         bool runningState =true;
1595         int count = 0;
1596         while (runningState) {
1597             count++;
1598             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
1599             sleep(1);
1600             if (count > 5) { //5 second
1601                 this->modifyMsg_ = "middle";
1602             }
1603             if (count > 20) { //20 second
1604                 runningState = false;
1605             }
1606         }
1607         return 0;
1608     });
1609     task42->Start();
1610     sleep(3);
1611     task42->Pause();
1612     sleep(2);
1613     task42->Start();
1614     sleep(2);
1615     task42->Stop();
1616     sleep(1);
1617     EXPECT_EQ("", modifyMsg_);
1618     task42->Start();
1619     sleep(1);
1620     bool rtv = task42->IsTaskRunning();
1621     EXPECT_EQ(true, rtv);
1622     task42->Stop();
1623 }
1624 
1625 /**
1626  * @tc.name: TaskJobPauseStopResumeStart43
1627  * @tc.desc: TaskJobPauseStopResumeStart43
1628  * @tc.type: FUNC
1629  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart43, TestSize.Level1)1630 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart43, TestSize.Level1)
1631 {
1632     std::shared_ptr<Task> task43 = std::make_shared<Task>("workTask43",
1633      "", TaskType::VIDEO, TaskPriority::LOW, false);
1634     task43->RegisterJob([this]() {
1635         bool runningState =true;
1636         int count = 0;
1637         while (runningState) {
1638             count++;
1639             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
1640             sleep(1);
1641             if (count > 5) { //5 second
1642                 this->modifyMsg_ = "middle";
1643             }
1644             if (count > 20) { //20 second
1645                 runningState = false;
1646             }
1647         }
1648         return 0;
1649     });
1650     task43->Start();
1651     sleep(3);
1652     task43->Pause();
1653     sleep(2);
1654     task43->Start();
1655     sleep(2);
1656     task43->Stop();
1657     sleep(1);
1658     EXPECT_EQ("", modifyMsg_);
1659     task43->Start();
1660     sleep(1);
1661     bool rtv = task43->IsTaskRunning();
1662     EXPECT_EQ(true, rtv);
1663     task43->Stop();
1664 }
1665 
1666 /**
1667  * @tc.name: TaskJobPauseStopResumeStart44
1668  * @tc.desc: TaskJobPauseStopResumeStart44
1669  * @tc.type: FUNC
1670  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart44, TestSize.Level1)1671 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart44, TestSize.Level1)
1672 {
1673     std::shared_ptr<Task> task44 = std::make_shared<Task>("workTask44",
1674      "", TaskType::AUDIO, TaskPriority::LOW, false);
1675     task44->RegisterJob([this]() {
1676         bool runningState =true;
1677         int count = 0;
1678         while (runningState) {
1679             count++;
1680             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
1681             sleep(1);
1682             if (count > 5) { //5 second
1683                 this->modifyMsg_ = "middle";
1684             }
1685             if (count > 20) { //20 second
1686                 runningState = false;
1687             }
1688         }
1689         return 0;
1690     });
1691     task44->Start();
1692     sleep(3);
1693     task44->Pause();
1694     sleep(2);
1695     task44->Start();
1696     sleep(2);
1697     task44->Stop();
1698     sleep(1);
1699     EXPECT_EQ("", modifyMsg_);
1700     task44->Start();
1701     sleep(1);
1702     bool rtv = task44->IsTaskRunning();
1703     EXPECT_EQ(true, rtv);
1704     task44->Stop();
1705 }
1706 
1707 /**
1708  * @tc.name: TaskJobPauseStopResumeStart45
1709  * @tc.desc: TaskJobPauseStopResumeStart45
1710  * @tc.type: FUNC
1711  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart45, TestSize.Level1)1712 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart45, TestSize.Level1)
1713 {
1714     std::shared_ptr<Task> task45 = std::make_shared<Task>("workTask45",
1715      "", TaskType::SUBTITLE, TaskPriority::LOW, false);
1716     task45->RegisterJob([this]() {
1717         bool runningState =true;
1718         int count = 0;
1719         while (runningState) {
1720             count++;
1721             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
1722             sleep(1);
1723             if (count > 5) { //5 second
1724                 this->modifyMsg_ = "middle";
1725             }
1726             if (count > 20) { //20 second
1727                 runningState = false;
1728             }
1729         }
1730         return 0;
1731     });
1732     task45->Start();
1733     sleep(3);
1734     task45->Pause();
1735     sleep(2);
1736     task45->Start();
1737     sleep(2);
1738     task45->Stop();
1739     sleep(1);
1740     EXPECT_EQ("", modifyMsg_);
1741     task45->Start();
1742     sleep(1);
1743     bool rtv = task45->IsTaskRunning();
1744     EXPECT_EQ(true, rtv);
1745     task45->Stop();
1746 }
1747 
1748 /**
1749  * @tc.name: TaskJobPauseStopResumeStart46
1750  * @tc.desc: TaskJobPauseStopResumeStart46
1751  * @tc.type: FUNC
1752  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart46, TestSize.Level1)1753 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart46, TestSize.Level1)
1754 {
1755     std::shared_ptr<Task> task46 = std::make_shared<Task>("workTask46",
1756      "", TaskType::SINGLETON, TaskPriority::LOW, false);
1757     task46->RegisterJob([this]() {
1758         bool runningState =true;
1759         int count = 0;
1760         while (runningState) {
1761             count++;
1762             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
1763             sleep(1);
1764             if (count > 5) { //5 second
1765                 this->modifyMsg_ = "middle";
1766             }
1767             if (count > 20) { //20 second
1768                 runningState = false;
1769             }
1770         }
1771         return 0;
1772     });
1773     task46->Start();
1774     sleep(3);
1775     task46->Pause();
1776     sleep(2);
1777     task46->Start();
1778     sleep(2);
1779     task46->Stop();
1780     sleep(1);
1781     EXPECT_EQ("", modifyMsg_);
1782     task46->Start();
1783     sleep(1);
1784     bool rtv = task46->IsTaskRunning();
1785     EXPECT_EQ(true, rtv);
1786 }
1787 
1788 /**
1789  * @tc.name: TaskJobPauseStopResumeStart47
1790  * @tc.desc: TaskJobPauseStopResumeStart47
1791  * @tc.type: FUNC
1792  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart47, TestSize.Level1)1793 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart47, TestSize.Level1)
1794 {
1795     std::shared_ptr<Task> task47 = std::make_shared<Task>("workTask47",
1796      "", TaskType::GLOBAL, TaskPriority::MIDDLE, false);
1797     task47->RegisterJob([this]() {
1798         bool runningState =true;
1799         int count = 0;
1800         while (runningState) {
1801             count++;
1802             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
1803             sleep(1);
1804             if (count > 5) { //5 second
1805                 this->modifyMsg_ = "middle";
1806             }
1807             if (count > 20) { //20 second
1808                 runningState = false;
1809             }
1810         }
1811         return 0;
1812     });
1813     task47->Start();
1814     sleep(3);
1815     task47->Pause();
1816     sleep(2);
1817     task47->Start();
1818     sleep(2);
1819     task47->Stop();
1820     sleep(1);
1821     EXPECT_EQ("", modifyMsg_);
1822     task47->Start();
1823     sleep(1);
1824     bool rtv = task47->IsTaskRunning();
1825     EXPECT_EQ(true, rtv);
1826     task47->Stop();
1827 }
1828 
1829 /**
1830  * @tc.name: TaskJobPauseStopResumeStart48
1831  * @tc.desc: TaskJobPauseStopResumeStart48
1832  * @tc.type: FUNC
1833  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart48, TestSize.Level1)1834 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart48, TestSize.Level1)
1835 {
1836     std::shared_ptr<Task> task48 = std::make_shared<Task>("workTask48",
1837      "", TaskType::VIDEO, TaskPriority::MIDDLE, false);
1838     task48->RegisterJob([this]() {
1839         bool runningState =true;
1840         int count = 0;
1841         while (runningState) {
1842             count++;
1843             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
1844             sleep(1);
1845             if (count > 5) { //5 second
1846                 this->modifyMsg_ = "middle";
1847             }
1848             if (count > 20) { //20 second
1849                 runningState = false;
1850             }
1851         }
1852         return 0;
1853     });
1854     task48->Start();
1855     sleep(3);
1856     task48->Pause();
1857     sleep(2);
1858     task48->Start();
1859     sleep(2);
1860     task48->Stop();
1861     sleep(1);
1862     EXPECT_EQ("", modifyMsg_);
1863     task48->Start();
1864     sleep(1);
1865     bool rtv = task48->IsTaskRunning();
1866     EXPECT_EQ(true, rtv);
1867     task48->Stop();
1868 }
1869 
1870 /**
1871  * @tc.name: TaskJobPauseStopResumeStart49
1872  * @tc.desc: TaskJobPauseStopResumeStart49
1873  * @tc.type: FUNC
1874  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart49, TestSize.Level1)1875 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart49, TestSize.Level1)
1876 {
1877     std::shared_ptr<Task> task49 = std::make_shared<Task>("workTask49",
1878      "", TaskType::AUDIO, TaskPriority::MIDDLE, false);
1879     task49->RegisterJob([this]() {
1880         bool runningState =true;
1881         int count = 0;
1882         while (runningState) {
1883             count++;
1884             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
1885             sleep(1);
1886             if (count > 5) { //5 second
1887                 this->modifyMsg_ = "middle";
1888             }
1889             if (count > 20) { //20 second
1890                 runningState = false;
1891             }
1892         }
1893         return 0;
1894     });
1895     task49->Start();
1896     sleep(3);
1897     task49->Pause();
1898     sleep(2);
1899     task49->Start();
1900     sleep(2);
1901     task49->Stop();
1902     sleep(1);
1903     EXPECT_EQ("", modifyMsg_);
1904     task49->Start();
1905     sleep(1);
1906     bool rtv = task49->IsTaskRunning();
1907     EXPECT_EQ(true, rtv);
1908     task49->Stop();
1909 }
1910 
1911 /**
1912  * @tc.name: TaskJobPauseStopResumeStart50
1913  * @tc.desc: TaskJobPauseStopResumeStart50
1914  * @tc.type: FUNC
1915  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart50, TestSize.Level1)1916 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart50, TestSize.Level1)
1917 {
1918     std::shared_ptr<Task> task50 = std::make_shared<Task>("workTask50",
1919      "", TaskType::SUBTITLE, TaskPriority::MIDDLE, false);
1920     task50->RegisterJob([this]() {
1921         bool runningState =true;
1922         int count = 0;
1923         while (runningState) {
1924             count++;
1925             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
1926             sleep(1);
1927             if (count > 5) { //5 second
1928                 this->modifyMsg_ = "middle";
1929             }
1930             if (count > 20) { //20 second
1931                 runningState = false;
1932             }
1933         }
1934         return 0;
1935     });
1936     task50->Start();
1937     sleep(3);
1938     task50->Pause();
1939     sleep(2);
1940     task50->Start();
1941     sleep(2);
1942     task50->Stop();
1943     sleep(1);
1944     EXPECT_EQ("", modifyMsg_);
1945     task50->Start();
1946     sleep(1);
1947     bool rtv = task50->IsTaskRunning();
1948     EXPECT_EQ(true, rtv);
1949     task50->Stop();
1950 }
1951 
1952 /**
1953  * @tc.name: TaskJobPauseStopResumeStart51
1954  * @tc.desc: TaskJobPauseStopResumeStart51
1955  * @tc.type: FUNC
1956  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart51, TestSize.Level1)1957 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart51, TestSize.Level1)
1958 {
1959     std::shared_ptr<Task> task51 = std::make_shared<Task>("workTask51",
1960      "", TaskType::SINGLETON, TaskPriority::MIDDLE, false);
1961     task51->RegisterJob([this]() {
1962         bool runningState =true;
1963         int count = 0;
1964         while (runningState) {
1965             count++;
1966             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
1967             sleep(1);
1968             if (count > 5) { //5 second
1969                 this->modifyMsg_ = "middle";
1970             }
1971             if (count > 20) { //20 second
1972                 runningState = false;
1973             }
1974         }
1975         return 0;
1976     });
1977     task51->Start();
1978     sleep(3);
1979     task51->Pause();
1980     sleep(2);
1981     task51->Start();
1982     sleep(2);
1983     task51->Stop();
1984     sleep(1);
1985     EXPECT_EQ("", modifyMsg_);
1986     task51->Start();
1987     sleep(1);
1988     bool rtv = task51->IsTaskRunning();
1989     EXPECT_EQ(true, rtv);
1990 }
1991 
1992 /**
1993  * @tc.name: TaskJobPauseStopResumeStart52
1994  * @tc.desc: TaskJobPauseStopResumeStart52
1995  * @tc.type: FUNC
1996  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart52, TestSize.Level1)1997 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart52, TestSize.Level1)
1998 {
1999     std::shared_ptr<Task> task52 = std::make_shared<Task>("workTask52",
2000      "", TaskType::GLOBAL, TaskPriority::HIGH, false);
2001     task52->RegisterJob([this]() {
2002         bool runningState =true;
2003         int count = 0;
2004         while (runningState) {
2005             count++;
2006             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
2007             sleep(1);
2008             if (count > 5) { //5 second
2009                 this->modifyMsg_ = "middle";
2010             }
2011             if (count > 20) { //20 second
2012                 runningState = false;
2013             }
2014         }
2015         return 0;
2016     });
2017     task52->Start();
2018     sleep(3);
2019     task52->Pause();
2020     sleep(2);
2021     task52->Start();
2022     sleep(2);
2023     task52->Stop();
2024     sleep(1);
2025     EXPECT_EQ("", modifyMsg_);
2026     task52->Start();
2027     sleep(1);
2028     bool rtv = task52->IsTaskRunning();
2029     EXPECT_EQ(true, rtv);
2030     task52->Stop();
2031 }
2032 
2033 /**
2034  * @tc.name: TaskJobPauseStopResumeStart53
2035  * @tc.desc: TaskJobPauseStopResumeStart53
2036  * @tc.type: FUNC
2037  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart53, TestSize.Level1)2038 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart53, TestSize.Level1)
2039 {
2040     std::shared_ptr<Task> task53 = std::make_shared<Task>("workTask53",
2041      "", TaskType::VIDEO, TaskPriority::HIGH, false);
2042     task53->RegisterJob([this]() {
2043         bool runningState =true;
2044         int count = 0;
2045         while (runningState) {
2046             count++;
2047             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
2048             sleep(1);
2049             if (count > 5) { //5 second
2050                 this->modifyMsg_ = "middle";
2051             }
2052             if (count > 20) { //20 second
2053                 runningState = false;
2054             }
2055         }
2056         return 0;
2057     });
2058     task53->Start();
2059     sleep(3);
2060     task53->Pause();
2061     sleep(2);
2062     task53->Start();
2063     sleep(2);
2064     task53->Stop();
2065     sleep(1);
2066     EXPECT_EQ("", modifyMsg_);
2067     task53->Start();
2068     sleep(1);
2069     bool rtv = task53->IsTaskRunning();
2070     EXPECT_EQ(true, rtv);
2071     task53->Stop();
2072 }
2073 
2074 /**
2075  * @tc.name: TaskJobPauseStopResumeStart54
2076  * @tc.desc: TaskJobPauseStopResumeStart54
2077  * @tc.type: FUNC
2078  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart54, TestSize.Level1)2079 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart54, TestSize.Level1)
2080 {
2081     std::shared_ptr<Task> task54 = std::make_shared<Task>("workTask54",
2082      "", TaskType::AUDIO, TaskPriority::HIGH, false);
2083     task54->RegisterJob([this]() {
2084         bool runningState =true;
2085         int count = 0;
2086         while (runningState) {
2087             count++;
2088             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
2089             sleep(1);
2090             if (count > 5) { //5 second
2091                 this->modifyMsg_ = "middle";
2092             }
2093             if (count > 20) { //20 second
2094                 runningState = false;
2095             }
2096         }
2097         return 0;
2098     });
2099     task54->Start();
2100     sleep(3);
2101     task54->Pause();
2102     sleep(2);
2103     task54->Start();
2104     sleep(2);
2105     task54->Stop();
2106     sleep(1);
2107     EXPECT_EQ("", modifyMsg_);
2108     task54->Start();
2109     sleep(1);
2110     bool rtv = task54->IsTaskRunning();
2111     EXPECT_EQ(true, rtv);
2112     task54->Stop();
2113 }
2114 
2115 /**
2116  * @tc.name: TaskJobPauseStopResumeStart55
2117  * @tc.desc: TaskJobPauseStopResumeStart55
2118  * @tc.type: FUNC
2119  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart55, TestSize.Level1)2120 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart55, TestSize.Level1)
2121 {
2122     std::shared_ptr<Task> task55 = std::make_shared<Task>("workTask55",
2123      "", TaskType::SUBTITLE, TaskPriority::HIGH, false);
2124     task55->RegisterJob([this]() {
2125         bool runningState =true;
2126         int count = 0;
2127         while (runningState) {
2128             count++;
2129             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
2130             sleep(1);
2131             if (count > 5) { //5 second
2132                 this->modifyMsg_ = "middle";
2133             }
2134             if (count > 20) { //20 second
2135                 runningState = false;
2136             }
2137         }
2138         return 0;
2139     });
2140     task55->Start();
2141     sleep(3);
2142     task55->Pause();
2143     sleep(2);
2144     task55->Start();
2145     sleep(2);
2146     task55->Stop();
2147     sleep(1);
2148     EXPECT_EQ("", modifyMsg_);
2149     task55->Start();
2150     sleep(1);
2151     bool rtv = task55->IsTaskRunning();
2152     EXPECT_EQ(true, rtv);
2153     task55->Stop();
2154 }
2155 
2156 /**
2157  * @tc.name: TaskJobPauseStopResumeStart56
2158  * @tc.desc: TaskJobPauseStopResumeStart56
2159  * @tc.type: FUNC
2160  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart56, TestSize.Level1)2161 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart56, TestSize.Level1)
2162 {
2163     std::shared_ptr<Task> task56 = std::make_shared<Task>("workTask56",
2164      "", TaskType::SINGLETON, TaskPriority::HIGH, false);
2165     task56->RegisterJob([this]() {
2166         bool runningState =true;
2167         int count = 0;
2168         while (runningState) {
2169             count++;
2170             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
2171             sleep(1);
2172             if (count > 5) { //5 second
2173                 this->modifyMsg_ = "middle";
2174             }
2175             if (count > 20) { //20 second
2176                 runningState = false;
2177             }
2178         }
2179         return 0;
2180     });
2181     task56->Start();
2182     sleep(3);
2183     task56->Pause();
2184     sleep(2);
2185     task56->Start();
2186     sleep(2);
2187     task56->Stop();
2188     sleep(1);
2189     EXPECT_EQ("", modifyMsg_);
2190     task56->Start();
2191     sleep(1);
2192     bool rtv = task56->IsTaskRunning();
2193     EXPECT_EQ(true, rtv);
2194 }
2195 
2196 /**
2197  * @tc.name: TaskJobPauseStopResumeStart57
2198  * @tc.desc: TaskJobPauseStopResumeStart57
2199  * @tc.type: FUNC
2200  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart57, TestSize.Level1)2201 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart57, TestSize.Level1)
2202 {
2203     std::shared_ptr<Task> task57 = std::make_shared<Task>("workTask57",
2204      "", TaskType::GLOBAL, TaskPriority::HIGHEST, false);
2205     task57->RegisterJob([this]() {
2206         bool runningState =true;
2207         int count = 0;
2208         while (runningState) {
2209             count++;
2210             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
2211             sleep(1);
2212             if (count > 5) { //5 second
2213                 this->modifyMsg_ = "middle";
2214             }
2215             if (count > 20) { //20 second
2216                 runningState = false;
2217             }
2218         }
2219         return 0;
2220     });
2221     task57->Start();
2222     sleep(3);
2223     task57->Pause();
2224     sleep(2);
2225     task57->Start();
2226     sleep(2);
2227     task57->Stop();
2228     sleep(1);
2229     EXPECT_EQ("", modifyMsg_);
2230     task57->Start();
2231     sleep(1);
2232     bool rtv = task57->IsTaskRunning();
2233     EXPECT_EQ(true, rtv);
2234     task57->Stop();
2235 }
2236 
2237 /**
2238  * @tc.name: TaskJobPauseStopResumeStart58
2239  * @tc.desc: TaskJobPauseStopResumeStart58
2240  * @tc.type: FUNC
2241  */
HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart58, TestSize.Level1)2242 HWTEST_F(TaskInnerUnitTest, TaskJobPauseStopResumeStart58, TestSize.Level1)
2243 {
2244     std::shared_ptr<Task> task58 = std::make_shared<Task>("workTask58",
2245      "", TaskType::VIDEO, TaskPriority::HIGHEST, false);
2246     task58->RegisterJob([this]() {
2247         bool runningState =true;
2248         int count = 0;
2249         while (runningState) {
2250             count++;
2251             MEDIA_LOG_I("Task TaskJobPauseStopResumeStart running at " PUBLIC_LOG_U32, count);
2252             sleep(1);
2253             if (count > 5) { //5 second
2254                 this->modifyMsg_ = "middle";
2255             }
2256             if (count > 20) { //20 second
2257                 runningState = false;
2258             }
2259         }
2260         return 0;
2261     });
2262     task58->Start();
2263     sleep(3);
2264     task58->Pause();
2265     sleep(2);
2266     task58->Start();
2267     sleep(2);
2268     task58->Stop();
2269     sleep(1);
2270     EXPECT_EQ("", modifyMsg_);
2271     task58->Start();
2272     sleep(1);
2273     bool rtv = task58->IsTaskRunning();
2274     EXPECT_EQ(true, rtv);
2275     task58->Stop();
2276 }
2277 
2278 /**
2279  * @tc.name: WaitFor_Failed
2280  * @tc.desc: WaitFor_Failed
2281  * @tc.type: FUNC
2282  */
HWTEST_F(TaskInnerUnitTest, WaitFor_Failed, TestSize.Level1)2283 HWTEST_F(TaskInnerUnitTest, WaitFor_Failed, TestSize.Level1)
2284 {
2285     std::shared_ptr<Task> task02 = std::make_shared<Task>("workTask02");
2286     AutoLock lock(mutex_);
2287     task02->RegisterJob([]() {
2288         bool runningState =true;
2289         int count = 0;
2290         while (runningState) {
2291             count++;
2292             MEDIA_LOG_I("Task WaitFor_Failed running at " PUBLIC_LOG_U32, count);
2293             sleep(1);
2294             if (count > 10){ //10 second
2295                 runningState = false;
2296             }
2297         }
2298         return 0;
2299     });
2300     task02->Start();
2301     int timeoutMs = 100;
2302     isStop_.store(false);
2303     auto rtv = cv.WaitFor(lock, timeoutMs, [this] { return isStop_.load(); });
2304     EXPECT_EQ(false, rtv);
2305 }
2306 } // namespace MetaFuncUT
2307 } // namespace Media
2308 } // namespace OHOS
2309