1 /*
2 * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <functional>
17 #include <gtest/gtest.h>
18
19 #include "work_status.h"
20 #include "work_condition.h"
21 #include "work_sched_data_manager.h"
22 #include "work_sched_hilog.h"
23 #include "work_info.h"
24
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace WorkScheduler {
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: dump_002
462 * @tc.desc: Test WorkStatus Dump.
463 * @tc.type: FUNC
464 * @tc.require: I95QHG
465 */
466 HWTEST_F(WorkStatusTest, dump_002, TestSize.Level1)
467 {
468 workStatus_->workInfo_->saId_ = 1000;
469 workStatus_->workInfo_->residentSa_ = true;
470
471 std::string result;
472 workStatus_->Dump(result);
473 EXPECT_TRUE(workStatus_->workInfo_->IsSA());
474 }
475
476 /**
477 * @tc.name: getMinInterval_001
478 * @tc.desc: Test WorkStatus GetMinInterval.
479 * @tc.type: FUNC
480 * @tc.require: I95QHG
481 */
482 HWTEST_F(WorkStatusTest, getMinInterval_001, TestSize.Level1)
483 {
484 int64_t interval = 7200000;
485 workStatus_->SetMinIntervalByDump(interval);
486 int64_t ret = workStatus_->GetMinInterval();
487 EXPECT_TRUE(ret == interval);
488 }
489
490 /**
491 * @tc.name: isRepeating_001
492 * @tc.desc: Test WorkStatus IsRepeating.
493 * @tc.type: FUNC
494 * @tc.require: I95QHG
495 */
496 HWTEST_F(WorkStatusTest, isRepeating_001, TestSize.Level1)
497 {
498 workStatus_->conditionMap_.erase(WorkCondition::Type::TIMER);
499 bool ret = workStatus_->IsRepeating();
500 EXPECT_FALSE(ret);
501
502 std::shared_ptr<Condition> timerCondition = std::make_shared<Condition>();
503 timerCondition->boolVal = true;
504 workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, timerCondition);
505 bool ret1 = workStatus_->IsRepeating();
506 EXPECT_TRUE(ret1);
507
508 std::shared_ptr<Condition> timerCondition1 = std::make_shared<Condition>();
509 timerCondition1->boolVal = false;
510 timerCondition1->intVal = 1200;
511 workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, timerCondition1);
512 bool ret2 = workStatus_->IsRepeating();
513 EXPECT_TRUE(ret2);
514 }
515
516 /**
517 * @tc.name: IsReadyStatus_001
518 * @tc.desc: Test WorkStatus IsReadyStatus.
519 * @tc.type: FUNC
520 * @tc.require: IAJSVG
521 */
522 HWTEST_F(WorkStatusTest, IsReadyStatus_001, TestSize.Level1)
523 {
524 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
525 bool ret = workStatus_->IsReadyStatus();
526 EXPECT_FALSE(ret);
527 }
528
529 /**
530 * @tc.name: IsRemoved_001
531 * @tc.desc: Test WorkStatus IsRemoved.
532 * @tc.type: FUNC
533 * @tc.require: IAJSVG
534 */
535 HWTEST_F(WorkStatusTest, IsRemoved_001, TestSize.Level1)
536 {
537 workStatus_->MarkStatus(WorkStatus::Status::REMOVED);
538 bool ret = workStatus_->IsRemoved();
539 EXPECT_TRUE(ret);
540 workStatus_->MarkRound();
541 }
542
543 /**
544 * @tc.name: NeedRemove_001
545 * @tc.desc: Test WorkStatus NeedRemove.
546 * @tc.type: FUNC
547 * @tc.require: IAJSVG
548 */
549 HWTEST_F(WorkStatusTest, NeedRemove_001, TestSize.Level1)
550 {
551 workStatus_->conditionMap_.clear();
552 bool ret = workStatus_->NeedRemove();
553 EXPECT_TRUE(ret);
554 }
555
556 /**
557 * @tc.name: NeedRemove_002
558 * @tc.desc: Test WorkStatus NeedRemove.
559 * @tc.type: FUNC
560 * @tc.require: IAJSVG
561 */
562 HWTEST_F(WorkStatusTest, NeedRemove_002, TestSize.Level1)
563 {
564 workStatus_->conditionMap_.clear();
565 std::shared_ptr<Condition> repeatCycle = std::make_shared<Condition>();
566 repeatCycle->boolVal = true;
567 workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, repeatCycle);
568 bool ret = workStatus_->NeedRemove();
569 EXPECT_FALSE(ret);
570 }
571
572 /**
573 * @tc.name: NeedRemove_003
574 * @tc.desc: Test WorkStatus NeedRemove.
575 * @tc.type: FUNC
576 * @tc.require: IAJSVG
577 */
578 HWTEST_F(WorkStatusTest, NeedRemove_003, TestSize.Level1)
579 {
580 workStatus_->conditionMap_.clear();
581 std::shared_ptr<Condition> repeatCycle = std::make_shared<Condition>();
582 repeatCycle->boolVal = false;
583 repeatCycle->intVal = 0;
584 workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, repeatCycle);
585 bool ret = workStatus_->NeedRemove();
586 EXPECT_TRUE(ret);
587 }
588
589 /**
590 * @tc.name: NeedRemove_004
591 * @tc.desc: Test WorkStatus NeedRemove.
592 * @tc.type: FUNC
593 * @tc.require: IAJSVG
594 */
595 HWTEST_F(WorkStatusTest, NeedRemove_004, TestSize.Level1)
596 {
597 workStatus_->conditionMap_.clear();
598 std::shared_ptr<Condition> repeatCycle = std::make_shared<Condition>();
599 repeatCycle->boolVal = false;
600 repeatCycle->intVal = 1;
601 workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, repeatCycle);
602 bool ret = workStatus_->NeedRemove();
603 EXPECT_FALSE(ret);
604 }
605
606 /**
607 * @tc.name: UpdateTimerIfNeed_001
608 * @tc.desc: Test WorkStatus UpdateTimerIfNeed.
609 * @tc.type: FUNC
610 * @tc.require: IAJSVG
611 */
612 HWTEST_F(WorkStatusTest, UpdateTimerIfNeed_001, TestSize.Level1)
613 {
614 workStatus_->conditionMap_.clear();
615 workStatus_->UpdateTimerIfNeed();
616
617 std::shared_ptr<Condition> repeatCycle = std::make_shared<Condition>();
618 repeatCycle->boolVal = false;
619 repeatCycle->intVal = 1;
620 workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, repeatCycle);
621 workStatus_->UpdateTimerIfNeed();
622 EXPECT_TRUE(repeatCycle->intVal == 0);
623 }
624
625 /**
626 * @tc.name: UpdateTimerIfNeed_002
627 * @tc.desc: Test WorkStatus UpdateTimerIfNeed.
628 * @tc.type: FUNC
629 * @tc.require: IAJSVG
630 */
631 HWTEST_F(WorkStatusTest, UpdateTimerIfNeed_002, TestSize.Level1)
632 {
633 workStatus_->conditionMap_.clear();
634 workStatus_->UpdateTimerIfNeed();
635
636 std::shared_ptr<Condition> repeatCycle = std::make_shared<Condition>();
637 repeatCycle->boolVal = true;
638 repeatCycle->intVal = 1;
639 workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, repeatCycle);
640 workStatus_->UpdateTimerIfNeed();
641 EXPECT_TRUE(repeatCycle->intVal == 1);
642 }
643
644 /**
645 * @tc.name: MarkTimeout_001
646 * @tc.desc: Test WorkStatus MarkTimeout.
647 * @tc.type: FUNC
648 * @tc.require: IAJSVG
649 */
650 HWTEST_F(WorkStatusTest, MarkTimeout_001, TestSize.Level1)
651 {
652 workStatus_->MarkTimeout();
653 bool ret = workStatus_->IsLastWorkTimeout();
654 EXPECT_TRUE(ret);
655 }
656
657 /**
658 * @tc.name: IsNapReady_001
659 * @tc.desc: Test WorkStatus IsNapReady.
660 * @tc.type: FUNC
661 * @tc.require: IAJSVG
662 */
663 HWTEST_F(WorkStatusTest, IsNapReady_001, TestSize.Level1)
664 {
665 WorkInfo workInfo = WorkInfo();
666 std::shared_ptr<Condition> repeatCycle1 = std::make_shared<Condition>();
667 repeatCycle1->boolVal = true;
668 workInfo.conditionMap_.emplace(WorkCondition::Type::DEEP_IDLE, repeatCycle1);
669 workStatus_->workInfo_ = std::make_shared<WorkInfo>(workInfo);
670
671 std::shared_ptr<Condition> repeatCycle2 = std::make_shared<Condition>();
672 repeatCycle2->boolVal = false;
673 workStatus_->conditionMap_.emplace(WorkCondition::Type::DEEP_IDLE, repeatCycle2);
674
675 bool ret = workStatus_->IsNapReady(WorkCondition::Type::DEEP_IDLE);
676 EXPECT_FALSE(ret);
677 }
678
679 /**
680 * @tc.name: IsNapReady_002
681 * @tc.desc: Test WorkStatus IsNapReady.
682 * @tc.type: FUNC
683 * @tc.require: IAJSVG
684 */
685 HWTEST_F(WorkStatusTest, IsNapReady_002, TestSize.Level1)
686 {
687 WorkInfo workInfo = WorkInfo();
688 std::shared_ptr<Condition> repeatCycle1 = std::make_shared<Condition>();
689 repeatCycle1->boolVal = true;
690 workInfo.conditionMap_.emplace(WorkCondition::Type::DEEP_IDLE, repeatCycle1);
691 workStatus_->workInfo_ = std::make_shared<WorkInfo>(workInfo);
692
693 std::shared_ptr<Condition> repeatCycle2 = std::make_shared<Condition>();
694 repeatCycle2->boolVal = true;
695 workStatus_->conditionMap_.emplace(WorkCondition::Type::DEEP_IDLE, repeatCycle2);
696
697 bool ret = workStatus_->IsNapReady(WorkCondition::Type::DEEP_IDLE);
698 EXPECT_FALSE(ret);
699 }
700
701 /**
702 * @tc.name: UpdateUidLastTimeMap_001
703 * @tc.desc: Test WorkStatus UpdateUidLastTimeMap.
704 * @tc.type: FUNC
705 * @tc.require: IAJSVG
706 */
707 HWTEST_F(WorkStatusTest, UpdateUidLastTimeMap_001, TestSize.Level1)
708 {
709 workStatus_->s_uid_last_time_map.clear();
710 workStatus_->uid_ = 1;
711 workStatus_->UpdateUidLastTimeMap();
712 workStatus_->ClearUidLastTimeMap(1);
713 EXPECT_TRUE(workStatus_->s_uid_last_time_map.empty());
714 }
715
716 /**
717 * @tc.name: GetStatus_001
718 * @tc.desc: Test WorkStatus GetStatus.
719 * @tc.type: FUNC
720 * @tc.require: IAJSVG
721 */
722 HWTEST_F(WorkStatusTest, GetStatus_001, TestSize.Level1)
723 {
724 workStatus_->MarkStatus(WorkStatus::Status::RUNNING);
725 EXPECT_EQ(workStatus_->GetStatus(), WorkStatus::Status::RUNNING);
726 }
727
728 /**
729 * @tc.name: IsSAReady_001
730 * @tc.desc: Test WorkStatus IsSAReady.
731 * @tc.type: FUNC
732 * @tc.require: I95QHG
733 */
734 HWTEST_F(WorkStatusTest, IsSAReady_001, TestSize.Level1)
735 {
736 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
737 workInfo_->workId_ = -1;
738 workStatus_->MarkStatus(WorkStatus::Status::RUNNING);
739 workStatus_->workInfo_ = workInfo_;
740 bool result = workStatus_->IsSAReady();
741 EXPECT_TRUE(result);
742 }
743
744 /**
745 * @tc.name: IsSAReady_002
746 * @tc.desc: Test WorkStatus IsSAReady.
747 * @tc.type: FUNC
748 * @tc.require: I95QHG
749 */
750 HWTEST_F(WorkStatusTest, IsSAReady_002, TestSize.Level1)
751 {
752 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
753 workInfo_->workId_ = -1;
754 workInfo_->RequestNetworkType(WorkCondition::Network::NETWORK_UNKNOWN);
755 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
756 workStatus_->workInfo_ = workInfo_;
757 bool result = workStatus_->IsSAReady();
758 EXPECT_FALSE(result);
759 }
760
761 /**
762 * @tc.name: IsSAReady_003
763 * @tc.desc: Test WorkStatus IsSAReady.
764 * @tc.type: FUNC
765 * @tc.require: I95QHG
766 */
767 HWTEST_F(WorkStatusTest, IsSAReady_003, TestSize.Level1)
768 {
769 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
770 workInfo_->workId_ = -1;
771 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
772 workInfo_->RequestNetworkType(WorkCondition::Network::NETWORK_TYPE_BLUETOOTH);
773 std::shared_ptr<Condition> networkCondition = std::make_shared<Condition>();
774 networkCondition->enumVal = WorkCondition::Network::NETWORK_TYPE_ETHERNET;
775 workStatus_->conditionMap_.emplace(WorkCondition::Type::NETWORK, networkCondition);
776 workStatus_->workInfo_ = workInfo_;
777 bool result = workStatus_->IsSAReady();
778 EXPECT_FALSE(result);
779 }
780
781 /**
782 * @tc.name: IsSAReady_004
783 * @tc.desc: Test WorkStatus IsSAReady.
784 * @tc.type: FUNC
785 * @tc.require: I95QHG
786 */
787 HWTEST_F(WorkStatusTest, IsSAReady_004, TestSize.Level1)
788 {
789 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
790 workInfo_->workId_ = -1;
791 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
792 workInfo_->RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
793 std::shared_ptr<Condition> batteryCondition = std::make_shared<Condition>();
794 batteryCondition->enumVal = WorkCondition::BatteryStatus::BATTERY_STATUS_OKAY;
795 workStatus_->conditionMap_.emplace(WorkCondition::Type::BATTERY_STATUS, batteryCondition);
796 workStatus_->workInfo_ = workInfo_;
797 bool result = workStatus_->IsSAReady();
798 EXPECT_FALSE(result);
799 }
800
801 /**
802 * @tc.name: IsSAReady_005
803 * @tc.desc: Test WorkStatus IsSAReady.
804 * @tc.type: FUNC
805 * @tc.require: I95QHG
806 */
807 HWTEST_F(WorkStatusTest, IsSAReady_005, TestSize.Level1)
808 {
809 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
810 workInfo_->workId_ = -1;
811 workInfo_->RequestBatteryLevel(80);
812 std::shared_ptr<Condition> batteryLevelCondition = std::make_shared<Condition>();
813 batteryLevelCondition->intVal = 70;
814 workStatus_->conditionMap_.emplace(WorkCondition::Type::BATTERY_LEVEL, batteryLevelCondition);
815 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
816 workStatus_->workInfo_ = workInfo_;
817 bool result = workStatus_->IsSAReady();
818 EXPECT_FALSE(result);
819 }
820
821 /**
822 * @tc.name: IsSAReady_006
823 * @tc.desc: Test WorkStatus IsSAReady.
824 * @tc.type: FUNC
825 * @tc.require: I95QHG
826 */
827 HWTEST_F(WorkStatusTest, IsSAReady_006, TestSize.Level1)
828 {
829 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
830 workInfo_->workId_ = -1;
831 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
832 workInfo_->RequestBatteryLevel(60);
833 workInfo_->SetPreinstalled(true);
834 std::shared_ptr<Condition> batteryLevelCondition = std::make_shared<Condition>();
835 batteryLevelCondition->intVal = 70;
836 workStatus_->conditionMap_.emplace(WorkCondition::Type::BATTERY_LEVEL, batteryLevelCondition);
837 workStatus_->workInfo_ = workInfo_;
838 bool result = workStatus_->IsSAReady();
839 EXPECT_TRUE(result);
840 }
841
842 /**
843 * @tc.name: IsSAReady_007
844 * @tc.desc: Test WorkStatus IsSAReady.
845 * @tc.type: FUNC
846 * @tc.require: I95QHG
847 */
848 HWTEST_F(WorkStatusTest, IsSAReady_007, TestSize.Level1)
849 {
850 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
851 workInfo_->workId_ = -1;
852 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
853 workInfo_->RequestStorageLevel(WorkCondition::Storage::STORAGE_LEVEL_OKAY);
854 std::shared_ptr<Condition> storageCondition = std::make_shared<Condition>();
855 storageCondition->enumVal = WorkCondition::Storage::STORAGE_LEVEL_LOW;
856 workStatus_->conditionMap_.emplace(WorkCondition::Type::STORAGE, storageCondition);
857 workStatus_->workInfo_ = workInfo_;
858 bool result = workStatus_->IsSAReady();
859 EXPECT_FALSE(result);
860 }
861
862 /**
863 * @tc.name: IsSAReady_008
864 * @tc.desc: Test WorkStatus IsSAReady.
865 * @tc.type: FUNC
866 * @tc.require: I95QHG
867 */
868 HWTEST_F(WorkStatusTest, IsSAReady_008, TestSize.Level1)
869 {
870 workStatus_->s_uid_last_time_map.clear();
871 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
872 workInfo_->workId_ = -1;
873 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
874 uint32_t timeInterval = 1200;
875 workInfo_->RequestRepeatCycle(timeInterval);
876 workInfo_->SetPreinstalled(true);
877 workStatus_->workInfo_ = workInfo_;
878
879 std::shared_ptr<Condition> timerCondition = std::make_shared<Condition>();
880 timerCondition->boolVal = true;
881 timerCondition->uintVal = 7200001;
882 workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, timerCondition);
883 bool result = workStatus_->IsSAReady();
884 EXPECT_TRUE(result);
885 }
886
887 /**
888 * @tc.name: IsSAReady_009
889 * @tc.desc: Test WorkStatus IsSAReady.
890 * @tc.type: FUNC
891 * @tc.require: I95QHG
892 */
893 HWTEST_F(WorkStatusTest, IsSAReady_009, TestSize.Level1)
894 {
895 workStatus_->s_uid_last_time_map.clear();
896 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
897 workInfo_->workId_ = -1;
898 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
899 workInfo_->RequestStorageLevel(WorkCondition::Storage::STORAGE_LEVEL_OKAY);
900 std::shared_ptr<Condition> storageCondition = std::make_shared<Condition>();
901 storageCondition->enumVal = WorkCondition::Storage::STORAGE_LEVEL_OKAY;
902 workStatus_->conditionMap_.emplace(WorkCondition::Type::STORAGE, storageCondition);
903 workStatus_->workInfo_ = workInfo_;
904 bool result = workStatus_->IsSAReady();
905 EXPECT_FALSE(result);
906 }
907
908 /**
909 * @tc.name: IsSAReady_0010
910 * @tc.desc: Test WorkStatus IsSAReady.
911 * @tc.type: FUNC
912 * @tc.require: I95QHG
913 */
914 HWTEST_F(WorkStatusTest, IsSAReady_0010, TestSize.Level1)
915 {
916 workStatus_->s_uid_last_time_map.clear();
917 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
918 workInfo_->workId_ = -1;
919 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
920 workInfo_->RequestStorageLevel(WorkCondition::Storage::STORAGE_LEVEL_OKAY);
921 workStatus_->workInfo_ = workInfo_;
922 bool result = workStatus_->IsSAReady();
923 EXPECT_FALSE(result);
924 }
925
926 /**
927 * @tc.name: IsSAReady_0011
928 * @tc.desc: Test WorkStatus IsSAReady.
929 * @tc.type: FUNC
930 * @tc.require: I95QHG
931 */
932 HWTEST_F(WorkStatusTest, IsSAReady_0011, TestSize.Level1)
933 {
934 workStatus_->s_uid_last_time_map.clear();
935 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
936 workInfo_->workId_ = -1;
937 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
938 workInfo_->RequestChargerType(true, WorkCondition::Charger::CHARGING_PLUGGED_AC);
939 std::shared_ptr<Condition> chargingCondition = std::make_shared<Condition>();
940 chargingCondition->enumVal = WorkCondition::Charger::CHARGING_PLUGGED_USB;
941 chargingCondition->boolVal = false;
942 workStatus_->conditionMap_.emplace(WorkCondition::Type::CHARGER, chargingCondition);
943 workStatus_->workInfo_ = workInfo_;
944 bool result = workStatus_->IsSAReady();
945 EXPECT_FALSE(result);
946 }
947
948 /**
949 * @tc.name: IsSAReady_0012
950 * @tc.desc: Test WorkStatus IsSAReady.
951 * @tc.type: FUNC
952 * @tc.require: I95QHG
953 */
954 HWTEST_F(WorkStatusTest, IsSAReady_0012, TestSize.Level1)
955 {
956 workStatus_->s_uid_last_time_map.clear();
957 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
958 workInfo_->workId_ = -1;
959 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
960 workInfo_->RequestChargerType(true, WorkCondition::Charger::CHARGING_PLUGGED_AC);
961 std::shared_ptr<Condition> chargingCondition = std::make_shared<Condition>();
962 chargingCondition->enumVal = WorkCondition::Charger::CHARGING_PLUGGED_USB;
963 chargingCondition->boolVal = true;
964 workStatus_->conditionMap_.emplace(WorkCondition::Type::CHARGER, chargingCondition);
965 workStatus_->workInfo_ = workInfo_;
966 bool result = workStatus_->IsSAReady();
967 EXPECT_FALSE(result);
968 }
969
970 /**
971 * @tc.name: IsSAReady_0013
972 * @tc.desc: Test WorkStatus IsSAReady.
973 * @tc.type: FUNC
974 * @tc.require: I95QHG
975 */
976 HWTEST_F(WorkStatusTest, IsSAReady_0013, TestSize.Level1)
977 {
978 workStatus_->s_uid_last_time_map.clear();
979 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
980 workInfo_->workId_ = -1;
981 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
982 workInfo_->RequestChargerType(false, WorkCondition::Charger::CHARGING_PLUGGED_AC);
983 std::shared_ptr<Condition> chargingCondition = std::make_shared<Condition>();
984 chargingCondition->enumVal = WorkCondition::Charger::CHARGING_PLUGGED_USB;
985 chargingCondition->boolVal = false;
986 workStatus_->conditionMap_.emplace(WorkCondition::Type::CHARGER, chargingCondition);
987 workStatus_->workInfo_ = workInfo_;
988 bool result = workStatus_->IsSAReady();
989 EXPECT_FALSE(result);
990 }
991
992 /**
993 * @tc.name: IsSAReady_0014
994 * @tc.desc: Test WorkStatus IsSAReady.
995 * @tc.type: FUNC
996 * @tc.require: I95QHG
997 */
998 HWTEST_F(WorkStatusTest, IsSAReady_0014, TestSize.Level1)
999 {
1000 workStatus_->s_uid_last_time_map.clear();
1001 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
1002 workInfo_->workId_ = -1;
1003 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
1004 workInfo_->RequestChargerType(true, WorkCondition::Charger::CHARGING_PLUGGED_AC);
1005 std::shared_ptr<Condition> chargingCondition = std::make_shared<Condition>();
1006 chargingCondition->enumVal = WorkCondition::Charger::CHARGING_PLUGGED_AC;
1007 chargingCondition->boolVal = true;
1008 workStatus_->conditionMap_.emplace(WorkCondition::Type::CHARGER, chargingCondition);
1009 workStatus_->workInfo_ = workInfo_;
1010 bool result = workStatus_->IsSAReady();
1011 EXPECT_FALSE(result);
1012 }
1013
1014 /**
1015 * @tc.name: ToString_001
1016 * @tc.desc: Test WorkStatus ToString.
1017 * @tc.type: FUNC
1018 * @tc.require: I95QHG
1019 */
1020 HWTEST_F(WorkStatusTest, ToString_001, TestSize.Level1)
1021 {
1022 workStatus_->conditionStatus_.clear();
1023 std::shared_ptr<DataManager> dataManager = DelayedSingleton<DataManager>::GetInstance();
1024 dataManager->SetDeviceSleep(false);
1025 workStatus_->ToString(WorkCondition::Type::TIMER);
1026 EXPECT_TRUE(workStatus_->conditionStatus_.empty());
1027 }
1028
1029 /**
1030 * @tc.name: ToString_002
1031 * @tc.desc: Test WorkStatus ToString.
1032 * @tc.type: FUNC
1033 * @tc.require: I95QHG
1034 */
1035 HWTEST_F(WorkStatusTest, ToString_002, TestSize.Level1)
1036 {
1037 workStatus_->conditionStatus_.clear();
1038 std::shared_ptr<DataManager> dataManager = DelayedSingleton<DataManager>::GetInstance();
1039 dataManager->SetDeviceSleep(false);
1040 workStatus_->conditionStatus_ = "TIMER&ready";
1041 workStatus_->workInfo_->saId_ = 1000;
1042 workStatus_->workInfo_->residentSa_ = true;
1043 workStatus_->ToString(WorkCondition::Type::TIMER);
1044 EXPECT_FALSE(workStatus_->conditionStatus_.empty());
1045 }
1046
1047 /**
1048 * @tc.name: ToString_003
1049 * @tc.desc: Test WorkStatus ToString.
1050 * @tc.type: FUNC
1051 * @tc.require: I95QHG
1052 */
1053 HWTEST_F(WorkStatusTest, ToString_003, TestSize.Level1)
1054 {
1055 workStatus_->conditionStatus_.clear();
1056 std::shared_ptr<DataManager> dataManager = DelayedSingleton<DataManager>::GetInstance();
1057 dataManager->SetDeviceSleep(false);
1058 workStatus_->conditionStatus_ = "TIMER&ready";
1059 workStatus_->ToString(WorkCondition::Type::TIMER);
1060 EXPECT_FALSE(workStatus_->conditionStatus_.empty());
1061 }
1062 }
1063 }