1 /*
2  * Copyright (c) 2024-2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <functional>
17 #include <gtest/gtest.h>
18 
19 #include "work_status.h"
20 #include "work_condition.h"
21 #include "work_sched_hilog.h"
22 #include "work_info.h"
23 
24 using namespace testing::ext;
25 
26 namespace OHOS {
27 namespace WorkScheduler {
28 
29 class WorkStatusTest : public testing::Test {
30 public:
31     static void SetUpTestCase();
TearDownTestCase()32     static void TearDownTestCase() {}
SetUp()33     void SetUp() {}
TearDown()34     void TearDown() {}
35     static std::shared_ptr<WorkStatus> workStatus_;
36     static std::shared_ptr<WorkInfo> workInfo_;
37 };
38 
39 std::shared_ptr<WorkStatus> WorkStatusTest::workStatus_ = nullptr;
40 std::shared_ptr<WorkInfo> WorkStatusTest::workInfo_ = nullptr;
41 
SetUpTestCase()42 void WorkStatusTest::SetUpTestCase()
43 {
44     workInfo_ = std::make_shared<WorkInfo>();
45     workInfo_->SetWorkId(-1);
46     std::string bundleName = "com.example.workStatus";
47     std::string abilityName = "workStatusAbility";
48     workInfo_->SetElement(bundleName, abilityName);
49     workInfo_->RequestPersisted(false);
50     time_t baseTime;
51     (void)time(&baseTime);
52     workInfo_->RequestBaseTime(baseTime);
53     workStatus_ = std::make_shared<WorkStatus>(*(workInfo_.get()), -1);
54 }
55 
56 /**
57  * @tc.name: makeWorkId_001
58  * @tc.desc: Test WorkStatus MakeWorkId.
59  * @tc.type: FUNC
60  * @tc.require: I95QHG
61  */
62 HWTEST_F(WorkStatusTest, makeWorkId_001, TestSize.Level1)
63 {
64     std::string result = workStatus_->MakeWorkId(1, 1);
65     EXPECT_EQ(result, "u1_1");
66 }
67 
68 /**
69  * @tc.name: isSameUser_001
70  * @tc.desc: Test WorkStatus IsSameUser.
71  * @tc.type: FUNC
72  * @tc.require: I95QHG
73  */
74 HWTEST_F(WorkStatusTest, isSameUser_001, TestSize.Level1)
75 {
76     workStatus_->uid_ = -1;
77     bool result = workStatus_->IsSameUser();
78     EXPECT_TRUE(result);
79 }
80 
81 /**
82  * @tc.name: isSameUser_002
83  * @tc.desc: Test WorkStatus IsSameUser.
84  * @tc.type: FUNC
85  * @tc.require: I95QHG
86  */
87 HWTEST_F(WorkStatusTest, isSameUser_002, TestSize.Level1)
88 {
89     workStatus_->uid_ = 1;
90     bool result = workStatus_->IsSameUser();
91     EXPECT_TRUE(result);
92 }
93 
94 /**
95  * @tc.name: isUriKeySwitchOn_001
96  * @tc.desc: Test WorkStatus IsUriKeySwitchOn.
97  * @tc.type: FUNC
98  * @tc.require: I95QHG
99  */
100 HWTEST_F(WorkStatusTest, isUriKeySwitchOn_001, TestSize.Level1)
101 {
102     std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
103     workInfo_->SetPreinstalled(false);
104     workStatus_->workInfo_ = workInfo_;
105     bool result = workStatus_->IsUriKeySwitchOn();
106     EXPECT_TRUE(result);
107 }
108 
109 /**
110  * @tc.name: isUriKeySwitchOn_002
111  * @tc.desc: Test WorkStatus IsUriKeySwitchOn.
112  * @tc.type: FUNC
113  * @tc.require: I95QHG
114  */
115 HWTEST_F(WorkStatusTest, isUriKeySwitchOn_002, TestSize.Level1)
116 {
117     std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
118     workInfo_->SetPreinstalled(true);
119     workInfo_->workId_ = 1;
120     workStatus_->workInfo_ = workInfo_;
121     bool result = workStatus_->IsUriKeySwitchOn();
122     EXPECT_FALSE(result);
123 }
124 
125 /**
126  * @tc.name: isUriKeySwitchOn_003
127  * @tc.desc: Test WorkStatus IsUriKeySwitchOn.
128  * @tc.type: FUNC
129  * @tc.require: I95QHG
130  */
131 HWTEST_F(WorkStatusTest, isUriKeySwitchOn_003, TestSize.Level1)
132 {
133     std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
134     workInfo_->workId_ = 1;
135     workInfo_->SetPreinstalled(true);
136     workInfo_->uriKey_ = "key";
137     workStatus_->workInfo_ = workInfo_;
138     bool result = workStatus_->IsUriKeySwitchOn();
139     EXPECT_FALSE(result);
140 }
141 
142 /**
143  * @tc.name: isReady_001
144  * @tc.desc: Test WorkStatus IsReady.
145  * @tc.type: FUNC
146  * @tc.require: I95QHG
147  */
148 HWTEST_F(WorkStatusTest, isReady_001, TestSize.Level1)
149 {
150     std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
151     workInfo_->workId_ = -1;
152     workStatus_->MarkStatus(WorkStatus::Status::RUNNING);
153     workStatus_->workInfo_ = workInfo_;
154     bool result = workStatus_->IsReady();
155     EXPECT_FALSE(result);
156 }
157 
158 /**
159  * @tc.name: isReady_002
160  * @tc.desc: Test WorkStatus IsReady.
161  * @tc.type: FUNC
162  * @tc.require: I95QHG
163  */
164 HWTEST_F(WorkStatusTest, isReady_002, TestSize.Level1)
165 {
166     std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
167     workInfo_->workId_ = -1;
168     workInfo_->RequestNetworkType(WorkCondition::Network::NETWORK_UNKNOWN);
169     workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
170     workStatus_->workInfo_ = workInfo_;
171     bool result = workStatus_->IsReady();
172     EXPECT_FALSE(result);
173 }
174 
175 /**
176  * @tc.name: isReady_003
177  * @tc.desc: Test WorkStatus IsReady.
178  * @tc.type: FUNC
179  * @tc.require: I95QHG
180  */
181 HWTEST_F(WorkStatusTest, isReady_003, TestSize.Level1)
182 {
183     std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
184     workInfo_->workId_ = -1;
185     workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
186     workInfo_->RequestNetworkType(WorkCondition::Network::NETWORK_TYPE_BLUETOOTH);
187     std::shared_ptr<Condition> networkCondition = std::make_shared<Condition>();
188     networkCondition->enumVal = WorkCondition::Network::NETWORK_TYPE_ETHERNET;
189     workStatus_->conditionMap_.emplace(WorkCondition::Type::NETWORK, networkCondition);
190     workStatus_->workInfo_ = workInfo_;
191     bool result = workStatus_->IsReady();
192     EXPECT_FALSE(result);
193 }
194 
195 /**
196  * @tc.name: isReady_004
197  * @tc.desc: Test WorkStatus IsReady.
198  * @tc.type: FUNC
199  * @tc.require: I95QHG
200  */
201 HWTEST_F(WorkStatusTest, isReady_004, TestSize.Level1)
202 {
203     std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
204     workInfo_->workId_ = -1;
205     workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
206     workInfo_->RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
207     std::shared_ptr<Condition> batteryCondition = std::make_shared<Condition>();
208     batteryCondition->enumVal = WorkCondition::BatteryStatus::BATTERY_STATUS_OKAY;
209     workStatus_->conditionMap_.emplace(WorkCondition::Type::BATTERY_STATUS, batteryCondition);
210     workStatus_->workInfo_ = workInfo_;
211     bool result = workStatus_->IsReady();
212     EXPECT_FALSE(result);
213 }
214 
215 /**
216  * @tc.name: isReady_005
217  * @tc.desc: Test WorkStatus IsReady.
218  * @tc.type: FUNC
219  * @tc.require: I95QHG
220  */
221 HWTEST_F(WorkStatusTest, isReady_005, TestSize.Level1)
222 {
223     std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
224     workInfo_->workId_ = -1;
225     workInfo_->RequestBatteryLevel(80);
226     std::shared_ptr<Condition> batteryLevelCondition = std::make_shared<Condition>();
227     batteryLevelCondition->intVal = 70;
228     workStatus_->conditionMap_.emplace(WorkCondition::Type::BATTERY_LEVEL, batteryLevelCondition);
229     workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
230     workStatus_->workInfo_ = workInfo_;
231     bool result = workStatus_->IsReady();
232     EXPECT_FALSE(result);
233 }
234 
235 /**
236  * @tc.name: isReady_006
237  * @tc.desc: Test WorkStatus IsReady.
238  * @tc.type: FUNC
239  * @tc.require: I95QHG
240  */
241 HWTEST_F(WorkStatusTest, isReady_006, TestSize.Level1)
242 {
243     std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
244     workInfo_->workId_ = -1;
245     workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
246     workInfo_->RequestBatteryLevel(60);
247     workInfo_->SetPreinstalled(true);
248     std::shared_ptr<Condition> batteryLevelCondition = std::make_shared<Condition>();
249     batteryLevelCondition->intVal = 70;
250     workStatus_->conditionMap_.emplace(WorkCondition::Type::BATTERY_LEVEL, batteryLevelCondition);
251     workStatus_->workInfo_ = workInfo_;
252     bool result = workStatus_->IsReady();
253     EXPECT_FALSE(result);
254 }
255 
256 /**
257  * @tc.name: isReady_007
258  * @tc.desc: Test WorkStatus IsReady.
259  * @tc.type: FUNC
260  * @tc.require: I95QHG
261  */
262 HWTEST_F(WorkStatusTest, isReady_007, TestSize.Level1)
263 {
264     std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
265     workInfo_->workId_ = -1;
266     workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
267     workInfo_->RequestStorageLevel(WorkCondition::Storage::STORAGE_LEVEL_OKAY);
268     std::shared_ptr<Condition> storageCondition = std::make_shared<Condition>();
269     storageCondition->enumVal = WorkCondition::Storage::STORAGE_LEVEL_LOW;
270     workStatus_->conditionMap_.emplace(WorkCondition::Type::STORAGE, storageCondition);
271     workStatus_->workInfo_ = workInfo_;
272     bool result = workStatus_->IsReady();
273     EXPECT_FALSE(result);
274 }
275 
276 /**
277  * @tc.name: isReady_008
278  * @tc.desc: Test WorkStatus IsReady.
279  * @tc.type: FUNC
280  * @tc.require: I95QHG
281  */
282 HWTEST_F(WorkStatusTest, isReady_008, TestSize.Level1)
283 {
284     std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
285     workInfo_->workId_ = -1;
286     workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
287     uint32_t timeInterval = 1200;
288     workInfo_->RequestRepeatCycle(timeInterval);
289     workInfo_->SetPreinstalled(true);
290     workStatus_->workInfo_ = workInfo_;
291 
292     std::shared_ptr<Condition> timerCondition = std::make_shared<Condition>();
293     timerCondition->boolVal = true;
294     timerCondition->uintVal = 7200001;
295     workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, timerCondition);
296     bool result = workStatus_->IsReady();
297     EXPECT_FALSE(result);
298 }
299 
300 /**
301  * @tc.name: isReady_009
302  * @tc.desc: Test WorkStatus IsReady.
303  * @tc.type: FUNC
304  * @tc.require: I95QHG
305  */
306 HWTEST_F(WorkStatusTest, isReady_009, TestSize.Level1)
307 {
308     std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
309     workInfo_->workId_ = -1;
310     workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
311     workInfo_->RequestStorageLevel(WorkCondition::Storage::STORAGE_LEVEL_OKAY);
312     std::shared_ptr<Condition> storageCondition = std::make_shared<Condition>();
313     storageCondition->enumVal = WorkCondition::Storage::STORAGE_LEVEL_OKAY;
314     workStatus_->conditionMap_.emplace(WorkCondition::Type::STORAGE, storageCondition);
315     workStatus_->workInfo_ = workInfo_;
316     bool result = workStatus_->IsReady();
317     EXPECT_FALSE(result);
318 }
319 
320 /**
321  * @tc.name: isReady_0010
322  * @tc.desc: Test WorkStatus IsReady.
323  * @tc.type: FUNC
324  * @tc.require: I95QHG
325  */
326 HWTEST_F(WorkStatusTest, isReady_0010, TestSize.Level1)
327 {
328     std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
329     workInfo_->workId_ = -1;
330     workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
331     workInfo_->RequestStorageLevel(WorkCondition::Storage::STORAGE_LEVEL_OKAY);
332     workStatus_->workInfo_ = workInfo_;
333     bool result = workStatus_->IsReady();
334     EXPECT_FALSE(result);
335 }
336 
337 /**
338  * @tc.name: isReady_0011
339  * @tc.desc: Test WorkStatus IsReady.
340  * @tc.type: FUNC
341  * @tc.require: I95QHG
342  */
343 HWTEST_F(WorkStatusTest, isReady_0011, TestSize.Level1)
344 {
345     std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
346     workInfo_->workId_ = -1;
347     workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
348     workInfo_->RequestChargerType(true, WorkCondition::Charger::CHARGING_PLUGGED_AC);
349     std::shared_ptr<Condition> chargingCondition = std::make_shared<Condition>();
350     chargingCondition->enumVal = WorkCondition::Charger::CHARGING_PLUGGED_USB;
351     chargingCondition->boolVal = false;
352     workStatus_->conditionMap_.emplace(WorkCondition::Type::CHARGER, chargingCondition);
353     workStatus_->workInfo_ = workInfo_;
354     bool result = workStatus_->IsReady();
355     EXPECT_FALSE(result);
356 }
357 
358 /**
359  * @tc.name: isReady_0012
360  * @tc.desc: Test WorkStatus IsReady.
361  * @tc.type: FUNC
362  * @tc.require: I95QHG
363  */
364 HWTEST_F(WorkStatusTest, isReady_0012, TestSize.Level1)
365 {
366     std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
367     workInfo_->workId_ = -1;
368     workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
369     workInfo_->RequestChargerType(true, WorkCondition::Charger::CHARGING_PLUGGED_AC);
370     std::shared_ptr<Condition> chargingCondition = std::make_shared<Condition>();
371     chargingCondition->enumVal = WorkCondition::Charger::CHARGING_PLUGGED_USB;
372     chargingCondition->boolVal = true;
373     workStatus_->conditionMap_.emplace(WorkCondition::Type::CHARGER, chargingCondition);
374     workStatus_->workInfo_ = workInfo_;
375     bool result = workStatus_->IsReady();
376     EXPECT_FALSE(result);
377 }
378 
379 /**
380  * @tc.name: isReady_0013
381  * @tc.desc: Test WorkStatus IsReady.
382  * @tc.type: FUNC
383  * @tc.require: I95QHG
384  */
385 HWTEST_F(WorkStatusTest, isReady_0013, TestSize.Level1)
386 {
387     std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
388     workInfo_->workId_ = -1;
389     workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
390     workInfo_->RequestChargerType(false, WorkCondition::Charger::CHARGING_PLUGGED_AC);
391     std::shared_ptr<Condition> chargingCondition = std::make_shared<Condition>();
392     chargingCondition->enumVal = WorkCondition::Charger::CHARGING_PLUGGED_USB;
393     chargingCondition->boolVal = false;
394     workStatus_->conditionMap_.emplace(WorkCondition::Type::CHARGER, chargingCondition);
395     workStatus_->workInfo_ = workInfo_;
396     bool result = workStatus_->IsReady();
397     EXPECT_FALSE(result);
398 }
399 
400 /**
401  * @tc.name: isReady_0014
402  * @tc.desc: Test WorkStatus IsReady.
403  * @tc.type: FUNC
404  * @tc.require: I95QHG
405  */
406 HWTEST_F(WorkStatusTest, isReady_0014, TestSize.Level1)
407 {
408     std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
409     workInfo_->workId_ = -1;
410     workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
411     workInfo_->RequestChargerType(true, WorkCondition::Charger::CHARGING_PLUGGED_AC);
412     std::shared_ptr<Condition> chargingCondition = std::make_shared<Condition>();
413     chargingCondition->enumVal = WorkCondition::Charger::CHARGING_PLUGGED_AC;
414     chargingCondition->boolVal = true;
415     workStatus_->conditionMap_.emplace(WorkCondition::Type::CHARGER, chargingCondition);
416     workStatus_->workInfo_ = workInfo_;
417     bool result = workStatus_->IsReady();
418     EXPECT_FALSE(result);
419 }
420 
421 /**
422  * @tc.name: dump_001
423  * @tc.desc: Test WorkStatus Dump.
424  * @tc.type: FUNC
425  * @tc.require: I95QHG
426  */
427 HWTEST_F(WorkStatusTest, dump_001, TestSize.Level1)
428 {
429     std::shared_ptr<Condition> chargingCondition = std::make_shared<Condition>();
430     chargingCondition->enumVal = WorkCondition::Charger::CHARGING_PLUGGED_AC;
431     chargingCondition->boolVal = true;
432     workStatus_->conditionMap_.emplace(WorkCondition::Type::CHARGER, chargingCondition);
433 
434     std::shared_ptr<Condition> networkCondition = std::make_shared<Condition>();
435     networkCondition->enumVal = WorkCondition::Network::NETWORK_TYPE_ANY;
436     workStatus_->conditionMap_.emplace(WorkCondition::Type::NETWORK, networkCondition);
437 
438     std::shared_ptr<Condition> batteryLevelCondition = std::make_shared<Condition>();
439     batteryLevelCondition->intVal = 66;
440     workStatus_->conditionMap_.emplace(WorkCondition::Type::BATTERY_LEVEL, batteryLevelCondition);
441 
442     std::shared_ptr<Condition> batteryStatusCondition = std::make_shared<Condition>();
443     batteryStatusCondition->enumVal = WorkCondition::BatteryStatus::BATTERY_STATUS_OKAY;
444     workStatus_->conditionMap_.emplace(WorkCondition::Type::BATTERY_STATUS, batteryStatusCondition);
445 
446     std::shared_ptr<Condition> storageCondition = std::make_shared<Condition>();
447     storageCondition->enumVal = WorkCondition::Storage::STORAGE_LEVEL_OKAY;
448     workStatus_->conditionMap_.emplace(WorkCondition::Type::STORAGE, storageCondition);
449 
450     std::shared_ptr<Condition> timerCondition = std::make_shared<Condition>();
451     timerCondition->boolVal = false;
452     workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, timerCondition);
453 
454     std::string result;
455     workStatus_->Dump(result);
456     bool ret = result.empty();
457     EXPECT_FALSE(ret);
458 }
459 
460 /**
461  * @tc.name: getMinInterval_001
462  * @tc.desc: Test WorkStatus GetMinInterval.
463  * @tc.type: FUNC
464  * @tc.require: I95QHG
465  */
466 HWTEST_F(WorkStatusTest, getMinInterval_001, TestSize.Level1)
467 {
468     int64_t interval = 7200000;
469     workStatus_->SetMinIntervalByDump(interval);
470     int64_t ret = workStatus_->GetMinInterval();
471     EXPECT_TRUE(ret == interval);
472 }
473 
474 /**
475  * @tc.name: isRepeating_001
476  * @tc.desc: Test WorkStatus IsRepeating.
477  * @tc.type: FUNC
478  * @tc.require: I95QHG
479  */
480 HWTEST_F(WorkStatusTest, isRepeating_001, TestSize.Level1)
481 {
482     workStatus_->conditionMap_.erase(WorkCondition::Type::TIMER);
483     bool ret = workStatus_->IsRepeating();
484     EXPECT_FALSE(ret);
485 
486     std::shared_ptr<Condition> timerCondition = std::make_shared<Condition>();
487     timerCondition->boolVal = true;
488     workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, timerCondition);
489     bool ret1 = workStatus_->IsRepeating();
490     EXPECT_TRUE(ret1);
491 
492     std::shared_ptr<Condition> timerCondition1 = std::make_shared<Condition>();
493     timerCondition1->boolVal = false;
494     timerCondition1->intVal = 1200;
495     workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, timerCondition1);
496     bool ret2 = workStatus_->IsRepeating();
497     EXPECT_TRUE(ret2);
498 }
499 
500 /**
501  * @tc.name: IsReadyStatus_001
502  * @tc.desc: Test WorkStatus IsReadyStatus.
503  * @tc.type: FUNC
504  * @tc.require: IAJSVG
505  */
506 HWTEST_F(WorkStatusTest, IsReadyStatus_001, TestSize.Level1)
507 {
508     workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
509     bool ret = workStatus_->IsReadyStatus();
510     EXPECT_FALSE(ret);
511 }
512 
513 /**
514  * @tc.name: IsRemoved_001
515  * @tc.desc: Test WorkStatus IsRemoved.
516  * @tc.type: FUNC
517  * @tc.require: IAJSVG
518  */
519 HWTEST_F(WorkStatusTest, IsRemoved_001, TestSize.Level1)
520 {
521     workStatus_->MarkStatus(WorkStatus::Status::REMOVED);
522     bool ret = workStatus_->IsRemoved();
523     EXPECT_TRUE(ret);
524     workStatus_->MarkRound();
525 }
526 
527 /**
528  * @tc.name: NeedRemove_001
529  * @tc.desc: Test WorkStatus NeedRemove.
530  * @tc.type: FUNC
531  * @tc.require: IAJSVG
532  */
533 HWTEST_F(WorkStatusTest, NeedRemove_001, TestSize.Level1)
534 {
535     workStatus_->conditionMap_.clear();
536     bool ret = workStatus_->NeedRemove();
537     EXPECT_TRUE(ret);
538 }
539 
540 /**
541  * @tc.name: NeedRemove_002
542  * @tc.desc: Test WorkStatus NeedRemove.
543  * @tc.type: FUNC
544  * @tc.require: IAJSVG
545  */
546 HWTEST_F(WorkStatusTest, NeedRemove_002, TestSize.Level1)
547 {
548     workStatus_->conditionMap_.clear();
549     std::shared_ptr<Condition> repeatCycle = std::make_shared<Condition>();
550     repeatCycle->boolVal = true;
551     workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, repeatCycle);
552     bool ret = workStatus_->NeedRemove();
553     EXPECT_FALSE(ret);
554 }
555 
556 /**
557  * @tc.name: NeedRemove_003
558  * @tc.desc: Test WorkStatus NeedRemove.
559  * @tc.type: FUNC
560  * @tc.require: IAJSVG
561  */
562 HWTEST_F(WorkStatusTest, NeedRemove_003, TestSize.Level1)
563 {
564     workStatus_->conditionMap_.clear();
565     std::shared_ptr<Condition> repeatCycle = std::make_shared<Condition>();
566     repeatCycle->boolVal = false;
567     repeatCycle->intVal = 0;
568     workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, repeatCycle);
569     bool ret = workStatus_->NeedRemove();
570     EXPECT_TRUE(ret);
571 }
572 
573 /**
574  * @tc.name: NeedRemove_004
575  * @tc.desc: Test WorkStatus NeedRemove.
576  * @tc.type: FUNC
577  * @tc.require: IAJSVG
578  */
579 HWTEST_F(WorkStatusTest, NeedRemove_004, TestSize.Level1)
580 {
581     workStatus_->conditionMap_.clear();
582     std::shared_ptr<Condition> repeatCycle = std::make_shared<Condition>();
583     repeatCycle->boolVal = false;
584     repeatCycle->intVal = 1;
585     workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, repeatCycle);
586     bool ret = workStatus_->NeedRemove();
587     EXPECT_FALSE(ret);
588 }
589 
590 /**
591  * @tc.name: UpdateTimerIfNeed_001
592  * @tc.desc: Test WorkStatus UpdateTimerIfNeed.
593  * @tc.type: FUNC
594  * @tc.require: IAJSVG
595  */
596 HWTEST_F(WorkStatusTest, UpdateTimerIfNeed_001, TestSize.Level1)
597 {
598     workStatus_->conditionMap_.clear();
599     workStatus_->UpdateTimerIfNeed();
600 
601     std::shared_ptr<Condition> repeatCycle = std::make_shared<Condition>();
602     repeatCycle->boolVal = false;
603     workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, repeatCycle);
604     workStatus_->UpdateTimerIfNeed();
605 }
606 
607 /**
608  * @tc.name: UpdateTimerIfNeed_002
609  * @tc.desc: Test WorkStatus UpdateTimerIfNeed.
610  * @tc.type: FUNC
611  * @tc.require: IAJSVG
612  */
613 HWTEST_F(WorkStatusTest, UpdateTimerIfNeed_002, TestSize.Level1)
614 {
615     workStatus_->conditionMap_.clear();
616     workStatus_->UpdateTimerIfNeed();
617 
618     std::shared_ptr<Condition> repeatCycle = std::make_shared<Condition>();
619     repeatCycle->boolVal = true;
620     repeatCycle->intVal = 1;
621     workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, repeatCycle);
622     workStatus_->UpdateTimerIfNeed();
623 }
624 
625 /**
626  * @tc.name: MarkTimeout_001
627  * @tc.desc: Test WorkStatus MarkTimeout.
628  * @tc.type: FUNC
629  * @tc.require: IAJSVG
630  */
631 HWTEST_F(WorkStatusTest, MarkTimeout_001, TestSize.Level1)
632 {
633     workStatus_->MarkTimeout();
634     bool ret = workStatus_->IsLastWorkTimeout();
635     EXPECT_TRUE(ret);
636 }
637 
638 /**
639  * @tc.name: IsNapReady_001
640  * @tc.desc: Test WorkStatus IsNapReady.
641  * @tc.type: FUNC
642  * @tc.require: IAJSVG
643  */
644 HWTEST_F(WorkStatusTest, IsNapReady_001, TestSize.Level1)
645 {
646     WorkInfo workInfo = WorkInfo();
647     std::shared_ptr<Condition> repeatCycle1 = std::make_shared<Condition>();
648     repeatCycle1->boolVal = true;
649     workInfo.conditionMap_.emplace(WorkCondition::Type::DEEP_IDLE, repeatCycle1);
650     workStatus_->workInfo_ = std::make_shared<WorkInfo>(workInfo);
651 
652     std::shared_ptr<Condition> repeatCycle2 = std::make_shared<Condition>();
653     repeatCycle2->boolVal = false;
654     workStatus_->conditionMap_.emplace(WorkCondition::Type::DEEP_IDLE, repeatCycle2);
655 
656     bool ret = workStatus_->IsNapReady(WorkCondition::Type::DEEP_IDLE);
657     EXPECT_FALSE(ret);
658 }
659 
660 /**
661  * @tc.name: IsNapReady_002
662  * @tc.desc: Test WorkStatus IsNapReady.
663  * @tc.type: FUNC
664  * @tc.require: IAJSVG
665  */
666 HWTEST_F(WorkStatusTest, IsNapReady_002, TestSize.Level1)
667 {
668     WorkInfo workInfo = WorkInfo();
669     std::shared_ptr<Condition> repeatCycle1 = std::make_shared<Condition>();
670     repeatCycle1->boolVal = true;
671     workInfo.conditionMap_.emplace(WorkCondition::Type::DEEP_IDLE, repeatCycle1);
672     workStatus_->workInfo_ = std::make_shared<WorkInfo>(workInfo);
673 
674     std::shared_ptr<Condition> repeatCycle2 = std::make_shared<Condition>();
675     repeatCycle2->boolVal = true;
676     workStatus_->conditionMap_.emplace(WorkCondition::Type::DEEP_IDLE, repeatCycle2);
677 
678     bool ret = workStatus_->IsNapReady(WorkCondition::Type::DEEP_IDLE);
679     EXPECT_FALSE(ret);
680 }
681 
682 /**
683  * @tc.name: UpdateUidLastTimeMap_001
684  * @tc.desc: Test WorkStatus UpdateUidLastTimeMap.
685  * @tc.type: FUNC
686  * @tc.require: IAJSVG
687  */
688 HWTEST_F(WorkStatusTest, UpdateUidLastTimeMap_001, TestSize.Level1)
689 {
690     workStatus_->uid_ = 1;
691     workStatus_->UpdateUidLastTimeMap();
692     workStatus_->ClearUidLastTimeMap(1);
693 }
694 
695 /**
696  * @tc.name: GetStatus_001
697  * @tc.desc: Test WorkStatus GetStatus.
698  * @tc.type: FUNC
699  * @tc.require: IAJSVG
700  */
701 HWTEST_F(WorkStatusTest, GetStatus_001, TestSize.Level1)
702 {
703     workStatus_->MarkStatus(WorkStatus::Status::RUNNING);
704     EXPECT_EQ(workStatus_->GetStatus(), WorkStatus::Status::RUNNING);
705 }
706 }
707 }